Verilog

1
Toma Sacco,Ph.D.

Introduction to Verilog
Verilog is a Hardware Description Language
(HDL)
o Behavioral Constructs
o Structural Constructs
Hierarchical description allows us to control
the complexity of a design
A bit may have the values: 1, 0, x, and z

2
Toma Sacco,Ph.D.

Concatenation
The concatenation operator {, }
allows us to combine several wires or
vectors together to form a vector
{w3, w2, w1, w0}
Replication Operator
{3{A}} is equivalent to {A,A,A}
{2{C},3{A}} is equivalent to {C,C,A,A,A}

3
Toma Sacco,Ph.D.

Procedural models
o They are only sensitive to the inputs they are
explicitly waiting for
o Control is transferred to a procedural
assignment statement in a sequential manner,
flowing from one statement to the next
o The flow of control can be interrupted by an
event (@) statement, wait statement, and #delay
statement

4
Toma Sacco,Ph.D.

Assignments
Continuous assignment
o assign a= b&c ;
o Any time any of the inputs (b or c) changes, the
output a is re-evaluated
o The output can only drive nets (signals declared as
wire)

Procedural assignments
o = and <=
o The left-hand sides of all procedural assignments are
registers ( signals declared as reg)
5
Toma Sacco,Ph.D.

timescale
The timescale compiler directive is used to
specify the time units of any delay operator (#)
`timescale 1ns/100ps
When placed before a module definition, then all
delay operators in that module and any module
that followed it would be in units of nanoseconds
and any time calculations would be internally
rounded to the nearest one hundred
picoseconds.
6
Toma Sacco,Ph.D.

Representation of Numbers
Format:
<size_in_bits><radix_identifier><significant_digits>

type

Radix
identifier

binary
octal
hexadecimal

b
o
h

decimal

d
7
Toma Sacco,Ph.D.

sized

unsized

12b101011100110

b100010110

12b1010_1110_0110

o426

12o5346

h116

12hAE6

278

12d2790
-4b101

8
Toma Sacco,Ph.D.

Bitwise Operators
operator

operation

1s complement

&

AND

OR

XOR

~^ or ^~

XNOR
9
Toma Sacco,Ph.D.

Logical Operators
operator

operation

NOT

&&

AND

||

OR

10
Toma Sacco,Ph.D.

Relational operators
operator

operation

>

Greater than

<

Less than

>=

Greater than or equal

<=

Less than or equal

==

Equal to

!=

Not equal to
11
Toma Sacco,Ph.D.

Verilog gates
gate

description

usage

and

f=(a.b ..)

and(f,a,b,)

nand

f=(a.b ..)

nand(f,a,b,)

or

f=(a +b+..)

or(f,a,b,)

nor

f=(a+b+..)

nor(f,a,b,)

xor
xnor

f =( a + b + .)
f =( a . b . .)

xor(f,a,b,)
xnor(f,a,b,)

not

f = a

not(f,a)

buf

f=a

buf(f,a)

notif0

f = (!e? a : bz)

notif0(f,a,e)

notif1

f = ( e? a : bz)

notif1(f,a,e)

bufif0

f = (!e? a : bz)

bufif0(f,a,e)

bufif1

f = ( e? a : bz)

bufif1(f,a,e)
12
Toma Sacco,Ph.D.

Structural Modeling
Full adder using gates
module fulladd (Cin, x, y, s, Cout);
input Cin, x, y;
output s, Cout;
wire z1,z2,z3;
xor (s, x, y, Cin);
and (z1, x, y);
and (z2, x, Cin);
and (z3, y, Cin);
or (Cout, z1, z2, z3);
endmodule

13
Toma Sacco,Ph.D.

module fulladd (Cin, x, y, s, Cout);

input Cin, x, y;
output s, Cout;
wire z1,z2,z3;
xor (s, x, y, Cin);
and (z1, x, y),
(z2, x, Cin),
(z3, y, Cin);
or (Cout, z1, z2, z3);
endmodule

14
Toma Sacco,Ph.D.

Full adder using continuous assignment

module fulladd (Cin, x, y, s, Cout);
input Cin, x, y;
output s, Cout;
assign s = x ^ y ^ Cin;
assign Cout = (x & y) | (x & Cin) | (y & Cin);
endmodule

module fulladd (Cin, x, y, s, Cout);

input Cin, x, y;
output s, Cout;
assign s = x ^ y ^ Cin,
Cout = (x & y) | (x & Cin) | (y & Cin);
endmodule

15
Toma Sacco,Ph.D.

Full adder
module fulladd (Cin, x, y, s, Cout);
input Cin, x, y;
output s, Cout;
assign {Cout, s} = x + y + Cin;
endmodule

16
Toma Sacco,Ph.D.

Four-bit adder
x3 y3
carryout

FA
S3

x2 y2
C3

FA
S2

x1 y1
C2

FA
S1

x0 y0
C1

FA

carryin

S0

module adder4 (carryin, x3, x2, x1, x0, y3, y2, y1, y0, s3, s2, s1, s0, carryout);
input carryin, x3, x2, x1, x0, y3, y2, y1, y0;
output s3, s2, s1, s0, carryout;
wire c1,c2,c3;
fulladd stage0 (carryin, x0, y0, s0, c1);
fulladd stage1 (c1, x1, y1, s1, c2);
fulladd stage2 (c2, x2, y2, s2, c3);
fulladd stage3 (c3, x3, y3, s3, carryout);
endmodule

17
Toma Sacco,Ph.D.

Vector signals
Signals on multiple wires can be represented as a vector
input [3:0] X, Y;
The individual bits can be referenced using index values in square brackets. For
example the most-significant bit of X is referred to as X[3].
module adder4 (carryin, X, Y, S, carryout);
input carryin;
input [3:0] X, Y;
output [3:0] S;
output carryout;
wire [3:1] C;
fulladd stage0 (carryin, X[0], Y[0], S[0], C[1]);
fulladd stage1 (C[1], X[1], Y[1], S[1], C[2]);
fulladd stage2 (C[2], X[2], Y[2], S[2], C[3]);
fulladd stage3 (C[3], X[3], Y[3], S[3], carryout);
endmodule

18
Toma Sacco,Ph.D.

Grave accent character

`timescale 1ns / 1ps
module addt_v;
// Inputs
reg carryin;
reg [3:0] X,Y;
// Outputs
wire [3:0] S;
wire carryout;
adder4 uut (.carryin(carryin),.X(X),.Y(Y),.S(S),
.carryout(carryout));
initial begin
carryin = 0;X = 3;Y = 2;
#1 X=4; Y=7;
#1 Y=6;
#1 X=3; Y=5;
#1 Y=7;
end
endmodule

19
Toma Sacco,Ph.D.

To declare and initialize a one-bit register in verilog we use the following

statement
reg one_bit_reg=1'b0;
Similarly, to declare and initialize a one dimension reg (e.g. 8-bit) we can write
reg [7:0] reg_len_8=8'd0;
We can declare a two dimensional array (e.g. 16x8-bit) as
reg [7:0] reg_dim_2 [15:0];

20
Toma Sacco,Ph.D.

Generic Specification
Use of generic parameters allows the designer to scale the
system to any number of bits. The keyword parameter is
used to define the parameter.

Nets
A net represents a node in a circuit. A wire connects an
output of one logic element in a circuit to an input of another
element

Variables
Variables are used to describe a circuit in terms of its behavior. There are
two types of variables: reg and integer. All signals that are assigned a
value using procedural statements must be declared as variables by
using the reg or integer keywords.
21
Toma Sacco,Ph.D.

Behavioral Modeling
module addern (carryin, X, Y, S, carryout);
parameter n=32;
input carryin;
input [n-1:0] X, Y;
When using a procedure
output [n-1:0] S;
to describe a combinational
output carryout;
circuit, make sure a value
reg [n-1:0] S;
is assigned to every signal
reg carryout;
no matter what path is taken
reg [n:0] C;
within the procedure.
integer k;
always @(X or Y or carryin)
begin
C[0] = carryin;
for (k = 0; k <= n-1; k = k+1)
begin
S[k] = X[k] ^ Y[k] ^ C[k];
C[k+1] = (X[k] & Y[k]) | (X[k] & C[k]) | (Y[k] & C[k]);
end
carryout = C[n];
end
endmodule
22
Toma Sacco,Ph.D.

Arithmetic Assignment Statements

.

operator

operation

example

addition

C = A + B;

subtraction

C = A B;

2s complement

C = -A;

multiplication

division
23
Toma Sacco,Ph.D.

n-bit adder
module addern (carryin, X, Y, S);
parameter n = 32;
input carryin;
input [n-1:0] X, Y;
output [n-1:0] S;
assign S = X + Y + carryin;
endmodule

24
Toma Sacco,Ph.D.

Carryout and overflow

Yn-1 Y0

Xn-1X0
..

..

Carryout Xn-1 Yn-1 Sn-1

C0

n-bit adder
.
Sn-1
S0

Cn

Xn-1 Yn-1 Sn-1

Carryout

Carryout = Xn-1Yn-1+Yn-1Sn-1+Xn-1Sn-1

Overflow

Overflow = Carryout ^ Xn-1 ^ Yn-1 ^ Sn-1

25
Toma Sacco,Ph.D.

module addern (carryin, X, Y, S, carryout, overflow);

parameter n = 32;
input carryin;
input [n-1:0] X, Y;
output [n-1:0] S;
output carryout, overflow;
assign S = X + Y + carryin;
assign carryout = (X[n-1] & Y[n-1]) | (X[n-1] & ~S[n-1]) | (Y[n-1] & ~S[n-1]);
assign overflow = carryout ^ X[n-1] ^ Y[n-1] ^ S[n-1];
endmodule

26
Toma Sacco,Ph.D.

module addern (carryin, X, Y, S, carryout, overflow);

parameter n = 32;
input carryin;
input [n-1:0] X, Y;
output [n-1:0] S;
output carryout, overflow;
assign
assign
assign
assign

Sum = {1'b0,X} + {1'b0,Y} + carryin;

S = Sum[n-1:0];
carryout = Sum[n];
overflow = carryout ^ X[n-1] ^ Y[n-1] ^ S[n-1];

endmodule

27
Toma Sacco,Ph.D.

module addern (carryin, X, Y, S, carryout, overflow);

parameter n = 32;
input carryin;
input [n-1:0] X, Y;
output [n-1:0] S;
output carryout, overflow;
assign {carryout, S} = X + Y + carryin;
assign overflow = carryout ^ X[n-1] ^ Y[n-1] ^ S[n-1];
endmodule

28
Toma Sacco,Ph.D.

`timescale 1ns / 1ps

module addt_v;
// Inputs
reg carryin;
reg [3:0] X,Y;
// Outputs
wire [3:0] S;
wire carryout, overflow;
addern uut (.carryin(carryin),.X(X),.Y(Y),.S(S),
.carryout(carryout).overflow(overflow));
initial begin
carryin = 0;X = 3;Y = 2;
#1 X=4; Y=-2;
#1 Y=6;
#1 X=-3; Y=-2;
#1 Y=-7;
end
endmodule

Toma Sacco,Ph.D.

29

30
Toma Sacco,Ph.D.

`timescale 1ns / 1ps

//////////////////////////////////////////////////////////////////////////////////
// Company: CPP
// Engineer: Toma Sacco
//////////////////////////////////////////////////////////////////////////////////
module PAX(X,Y,S,ov,cout);
parameter n=4;
input [n-1:0] X,Y;
output [n-1:0]S;
output ov,cout;
wire coutn_1;
assign {coutn_1,S[n-2:0]} = {1'b0,X[n-2:0]} + Y[n-2:0];
assign {cout,S[n-1]}= {1'b0,X[n-1]} + Y[n-1]+ coutn_1;
assign ov= cout ^ coutn_1;
nndmodule
`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company: CPP
// Engineer:Toma Sacco
//////////////////////////////////////////////////////////////////////////////////
module PAM(input [7:0] A,B,output coutput,output ov,output [7:0] Sum);
PAX #(8) sub1(A,B,Sum,ov,coutput);
endmodule

31
Toma Sacco,Ph.D.

`timescale 1ns / 1ps

////////////////////////////////////////////////////////////////////////////////
// Company: CPP
// Engineer: Toma Sacco
////////////////////////////////////////////////////////////////////////////////
module test;
reg [7:0] A; reg [7:0] B;
wire coutput;wire ov;wire [7:0] Sum;
PAM uut (.A(A),.B(B),.coutput(coutput),.ov(ov),.Sum(Sum));
initial begin
A = 0;B = 0;
#1 A=50; B=60;
#1 A=-50; B=-60;
#1 A=50; B=-70;
#1 A=100; B=50;
#1 A=-90; B=-90;
end
endmodule
32
Toma Sacco,Ph.D.

33
Toma Sacco,Ph.D.

2x1 MUX using

the conditional operator
Conditional_expression? True_expression: false_expression
If the conditional expression evaluates to 1, then the value of the true
expression is chosen : otherwise, the value of the false_expression is
chosen.

w1

module mux2to1 (w0, w1, s, f);

input w0, w1, s;
output f;

2x1
MUX
f

w0
s

assign f = s ? w1 : w0;
endmodule

34
Toma Sacco,Ph.D.

module mux2to1 (w0, w1, s, f);

input w0, w1, s;
output f;
reg f;
always @(w0 or w1 or s)
if (s==0)
f = w0;
else
f = w1;
endmodule

When using a procedure

to describe a combinational
circuit, make sure a value
is assigned to every signal
no matter what path is taken
within the procedure.

35
Toma Sacco,Ph.D.

4x1
w3 MUX
4x1
w2

MUX

module mux4to1 (w0, w1, w2, w3, S, f);

f
input w0, w1, w2, w3;
w1
input [1:0] S;
output f;
w0
S0
reg f;
S1
always @(w0 or w1 or w2 or w3 or S)
if (S == 2'b00)
f = w0;
else if (S == 2'b01)
When using a procedure
f = w1;
to describe a combinational
circuit, make sure a value
else if (S == 2'b10)
is assigned to every signal
f = w2;
no matter what path is taken
else if (S == 2'b11)
within the procedure.
f = w3;
endmodule
36
Toma Sacco,Ph.D.

module mux4to1 (W, S, f);

input [0:3] W;
input [1:0] S;
output f;
reg f;
always @(W or S)
case (S)
0: f = W[0];
1: f = W[1];
2: f = W[2];
3: f = W[3];
endcase

When using a procedure

to describe a combinational
circuit, make sure a value
is assigned to every signal
no matter what path is taken
within the procedure.

endmodule
37
Toma Sacco,Ph.D.

W15

w3
w2
w1
w0

4x1
MUX f
S1S0

w3
w2
w1
w0

4x1
MUX f
S1S0

w3
w2
w1
w0

4x1
MUX f
S1S0

Hierarchical
16x1 MUX

M3

M2

w3 4x1
w2 MUX
w1
w0 S1 S0

M1

M0

W1

w3
w2
w1
w0

4x1
MUX f
S1S0

S1

S0

S3

S2

38
Toma Sacco,Ph.D.

module mux4to1 (W, S, f);

input [0:3] W;
input [1:0] S;
output f;
reg f;
always @(W or S)
case (S)
0: f = W[0];
1: f = W[1];
2: f = W[2];
3: f = W[3];
endcase

module mux16to1 (W, S16, f);

input [0:15] W;
input [3:0] S16;
output f;
wire [0:3] M;
mux4to1 Mux1 (W[0:3], S16[1:0], M[0]);
mux4to1 Mux2 (W[4:7], S16[1:0], M[1]);
mux4to1 Mux3 (W[8:11], S16[1:0], M[2]);
mux4to1 Mux4 (W[12:15], S16[1:0], M[3]);
mux4to1 Mux5 (M[0:3], S16[3:2], f);
endmodule

endmodule

39
Toma Sacco,Ph.D.

2x4 Decoder
En W1 W0

Y 3Y 2Y 1Y 0

0 x x

0 0 0 0

1 0 0

0 0 01

1 0 1

0 0 1 0

1 1 0

0 1 0 0

1 1 1

1 0 0 0

2x4
Decoder
En

w1
w0

Y3
Y2
Y1
Y0

40
Toma Sacco,Ph.D.

module dec2to4 (W, Y, En);

input [1:0] W;
input En;
output [0:3] Y;
reg [0:3] Y;
always @(W or En)
begin
if (En == 0)
Y = 4'b0000;
else
case (W)
0: Y = 4'b1000;
1: Y = 4'b0100;
2: Y = 4'b0010;
3: Y = 4'b0001;
endcase
end
endmodule

module dec2to4 (W, Y, En);

input [1:0] W;
input En;
output [0:3] Y;
reg [0:3] Y;
always @(W or En)
case ({En, W})
3'b100: Y = 4'b1000;
3'b101: Y = 4'b0100;
3'b110: Y = 4'b0010;
3'b111: Y = 4'b0001;
default: Y = 4'b0000;
endcase
endmodule
41
Toma Sacco,Ph.D.

4x16 Decoder

2x4 Decoder

W1
W0

Y3
Y2
Y1
Y0

w1
w0
En

M3

2x4 Decoder

W3
W2
En

w1
w0
En

2x4 Decoder

M2

Y3
Y2
Y1
Y0

Y15

W1
W0

Y3
Y2
Y1
Y0

w1
w0
En
2x4 Decoder

M1

W1
W0

Y3
Y2
Y1
Y0

w1
w0
En

M0

2x4 Decoder

W1
W0

w1
w0
En

Y3
Y2
Y1
Y0

Y0

42
Toma Sacco,Ph.D.

module dec2to4 (W, Y, En);

input [1:0] W;
input En;
output [0:3] Y;
reg [0:3] Y;
integer k;
always @(W or En)
for (k = 0; k <= 3; k = k+1)
if ((W == k) && (En == 1))
Y[k] = 1;
else
Y[k] = 0;
endmodule

module dec4to16(W, Y, En);

input [3:0] W;
input En;
output [0:15] Y;
wire [0:3] M;
dec2to4 Dec1 (W[3:2], M[0:3], En);
dec2to4 Dec2 (W[1:0], Y[0:3], M[0]);
dec2to4 Dec3 (W[1:0], Y[4:7], M[1]);
dec2to4 Dec4 (W[1:0], Y[8:11], M[2]);
dec2to4 Dec5 (W[1:0], Y[12:15], M[3]);
endmodule

43
Toma Sacco,Ph.D.

xyz
000
001
010
011
100
101
110
111

F
0
1
0
1
1
0
1
0

module TT(
input x,y,z,
output reg F
);
always@(*)
case({x,y,z})
1,3,4,6: F=1'b1;
default: F=0;
endcase
endmodule

module test;
reg x,y,z;
wire F;
TT uut (.x(x), .y(y), .z(z), .F(F));
initial begin
{x,y,z}=0;
repeat(7) #1 {x,y,z}= {x,y,z} +1;
end
endmodule

Toma Sacco,Ph.D.

44

4-bit to 7-segment decoder

a
b
c
d
e
f
g

a
f

b
c

d
Common anode
7-segment
display
module conv(i, ss);
input [3:0] i;
output [6:0] ss;
reg
[6:0] ss;
always @ (i)
begin
case(i)

//abcdefg
0:ss = 7'b0000001 ;
1:ss = 7'b1001111 ;
2:ss = 7'b0010010 ;
3:ss = 7'b0000110 ;
4:ss = 7'b1001100 ;
5:ss = 7'b0100100 ;
6:ss = 7'b0100000 ;
7:ss = 7'b0001111 ;
8:ss = 7'b0000000 ;
9:ss = 7'b0000100
10:ss = 7'b0001000 ;
11:ss = 7'b1100000 ;
12:ss = 7'b0110001 ;
13:ss = 7'b1000010 ;
14:ss = 7'b0110000 ;
15:ss = 7'b0111000 ;
endcase
end
endmodule

45
Toma Sacco,Ph.D.

`timescale 1ns / 1ps

//Seven-Segment driver for a common anode display
module sevensegment(input [3:0] B,output [6:0] ss);
reg [6:0]ROM [0:15];
Initial
begin
ROM[0]= 7'b0000001;
ROM[1]= 7'b1001111 ;
ROM[2]= 7'b0010010 ;
ROM[3]= 7'b0000110 ;
ROM[4]= 7'b1001100 ;
ROM[5]= 7'b0100100 ;
ROM[6]= 7'b0100000 ;
ROM[7]= 7'b0001111 ;
ROM[8]= 7'b0000000 ;
ROM[9]= 7'b0000100 ;
ROM[10]= 7'b0001000 ;
ROM[11]= 7'b1100000 ;
ROM[12]= 7'b0110001 ;
ROM[13]= 7'b1000010 ;
ROM[14]= 7'b0110000 ;
ROM[15]= 7'b0111000 ;
end
assign ss=ROM[B];
endmodule

46
Toma Sacco,Ph.D.

`timescale 1ns / 1ps

module convt_v;
// Inputs
reg [3:0] i;
// Outputs
wire [6:0] ss;
// Instantiate the Unit Under Test (UUT)
conv uut (i, ss);
initial begin
// Initialize Inputs
i = 0;
repeat(15) #1 i = i + 1;
end
endmodule

47
Toma Sacco,Ph.D.

48
Toma Sacco,Ph.D.

Using a lookup table to determine the square of a 4-bit binary number

module squarer(
input [3:0] B,
output [7:0] SQ
);
localparam NL=16;
localparam Nb=8;
reg [Nb-1:0]ROM [0:NL-1];
integer i;
initial
begin
for (i = 0; i < 16; i = i+1)
begin
ROM[i]= i**2;
end
end
assign SQ=ROM[B];
endmodule

Toma Sacco,Ph.D.

49

module testsq;
reg [3:0] B;
wire [7:0] SQ;
// Instantiate the Unit Under Test (UUT)
squarer uut (
.B(B),
.SQ(SQ)
);
initial begin
// Initialize Inputs
B = 0;
#2 B = 1;
#2 B = 2;
#2 B = 4;
#2 B = 5;
#2 B = 10;
#2 B = 15;
end
endmodule

Toma Sacco,Ph.D.

50

Toma Sacco,Ph.D.

51

Arithmetic Logic Unit (ALU)

s 2 s1 s0
0
0
0
0
1
1
1
1

0
0
1
1
0
0
1
1

0
1
0
1
0
1
0
1

F
0000
B-A
A-B
A+B
A XOR B
A OR B
A AND B
1111

module alu(s, A, B, F);

input [2:0] s;
input [3:0] A, B;
output [3:0] F;
reg [3:0] F;
always @(s or A or B)
case (s)
0: F = 4'b0000;
1: F = B - A;
2: F = A - B;
3: F = A + B;
4: F = A ^ B;
5: F = A | B;
6: F = A & B;
7: F = 4'b1111;
endcase
endmodule

52
Toma Sacco,Ph.D.

4-bit comparator
4
4

AgtB
EeqB

AltB

When using a procedure

to describe a combinational
circuit, make sure a value
is assigned to every signal
no matter what path is taken
within the procedure.

module compare (A, B, AeqB, AgtB, AltB);

input [3:0] A, B;
output AeqB, AgtB, AltB;
reg AeqB, AgtB, AltB;
always @(A or B)
begin
AeqB = 0;
AgtB = 0;
AltB = 0;
if(A == B)
AeqB = 1;
else if (A > B)
AgtB = 1;
else
AltB = 1;
end
endmodule

53
Toma Sacco,Ph.D.

module B2BCD(B,hundreds,tens,ones);
input [7:0] B;
output [3:0] hundreds;
output [3:0] tens;
output [3:0] ones;
integer x;
reg [3:0] hundreds, tens, ones;

Binary To BCD
Converter

4
4
4

always @(B)
begin
x=B;
hundreds=0; tens=0; ones = 0;
if(x>99)begin hundreds =hundreds +1; x =x-100; end
if(x>99)begin hundreds =hundreds +1; x =x-100; end
repeat(9)
begin
if(x>9)begin tens = tens +1; x =x-10; end
end
ones =x;
end
endmodule

54
Toma Sacco,Ph.D.

`timescale 1ns/1ps
module B2BCD_B2BCDt_v_tf();
reg [7:0] B;
// Outputs
wire [3:0] hundreds;
wire [3:0] tens;
wire [3:0] ones;
// Instantiate the UUT
B2BCD uut (.B(B), .hundreds(hundreds), .tens(tens), .ones(ones));
// Initialize Inputs
initial begin
B = 0;
#1 B =155;
#1 B = 238;
#1 B= 43;
#1 B= 7;
end
endmodule

55
Toma Sacco,Ph.D.

56
Toma Sacco,Ph.D.

A
B

I0
8

op
module GPadd(cin,x,y,s,cout);
parameter n=4;
input [n-1:0] x,y;
input cin;
output [n-1:0] s;
output cout;
assign {cout,s}={1'b0,x}+y+cin;
endmodule

Y
I1 sel

cout

cout
x
y

cin

module GPmux(sel,I1,I0,Y);
parameter m=4;
input sel;
input [m-1:0] I1,I0;
output [m-1:0] Y;
assign Y=sel?I1:I0;
endmodule

module AddSub(input [7:0] A,B,input op,output [7:0] R,output cout);

wire [7:0] NB,Y;
assign NB = ~B;
GPmux #(8) device1(op,NB,B,Y);
GPadd #(8) device2(op,A,Y,R,cout);
endmodule
57
Toma Sacco,Ph.D.

module systest;
reg [7:0] A;reg [7:0] B;reg op;
wire [7:0] R;wire cout;
AddSub uut (.A(A), .B(B), .op(op),
.R(R), .cout(cout));
initial begin
A = 0; B = 0; op = 0;
#2 A = 20;B = 55;op = 0;
#2 A = 77;B = 55;op = 1;
#2 A = 20;B = 55;op = 1;
end
endmodule

58
Toma Sacco,Ph.D.

59
Toma Sacco,Ph.D.