assertions

//arithmetic

module arithmetic

(input [3:0] A, B,

output logic [4:0] Q1,

output logic [3:0] Q2, Q3,

output logic [7:0] Q4);

always_comb

begin

assert(A^B!==4'bx) else $warning("Input is xx");

Q1 = A + B; //addition

Q2 = A - B; //subtraction

Q3 = A / 2; //division

Q4 = A * B; //multiplication

end

endmodule

//test bench-arithmetic

module arithmetic_tb();

logic [3:0] A, B;

logic [4:0] Q1;

logic [3:0] Q2, Q3;

logic [7:0] Q4;

arithmetic DUT(.*);

initial

begin

$fmonitor( $fopen("./arithmetic.txt"),"A B Q1 Q2 Q3 Q4");

$fdisplay( $fopen("./arithmetic.txt"),"A=%b B=%b Q1=%b Q2=%b Q3=%b

Q4=%b", A, B, Q1, Q2, Q3, Q4);

end

initial

repeat(20)

begin

A = $urandom_range(4'b1111);

B = $urandom_range(4'b1111);

#10 $display("A=%b B=%b Q1=%b Q2=%b Q3=%b Q4=%b", A, B, Q1, Q2, Q3,

Q4);

end

endmodule

OUTPUT:

A=0011 B=0000 Q1=00011 Q2=0011 Q3=0001 Q4=00000000

A=1101 B=0010 Q1=01111 Q2=1011 Q3=0110 Q4=00011010

A=0111 B=0001 Q1=01000 Q2=0110 Q3=0011 Q4=00000111

A=0101 B=1100 Q1=10001 Q2=1001 Q3=0010 Q4=00111100

A=1000 B=1100 Q1=10100 Q2=1100 Q3=0100 Q4=01100000

A=1100 B=1011 Q1=10111 Q2=0001 Q3=0110 Q4=10000100

A=1011 B=0101 Q1=10000 Q2=0110 Q3=0101 Q4=00110111

A=0100 B=1100 Q1=10000 Q2=1000 Q3=0010 Q4=00110000

A=0111 B=1100 Q1=10011 Q2=1011 Q3=0011 Q4=01010100

A=1010 B=0110 Q1=10000 Q2=0100 Q3=0101 Q4=00111100

A=0011 B=1101 Q1=10000 Q2=0110 Q3=0001 Q4=00100111

A=1100 B=1000 Q1=10100 Q2=0100 Q3=0110 Q4=01100000

A=1011 B=1011 Q1=10110 Q2=0000 Q3=0101 Q4=01111001

A=0011 B=1101 Q1=10000 Q2=0110 Q3=0001 Q4=00100111

A=1100 B=0110 Q1=10010 Q2=0110 Q3=0110 Q4=01001000

A=1001 B=1001 Q1=10010 Q2=0000 Q3=0100 Q4=01010001

A=1010 B=1110 Q1=11000 Q2=1100 Q3=0101 Q4=10001100

A=1000 B=1101 Q1=10101 Q2=1011 Q3=0100 Q4=01101000

A=0110 B=0110 Q1=01100 Q2=0000 Q3=0011 Q4=00100100

A=0000 B=1011 Q1=01011 Q2=0101 Q3=0000 Q4=00000000

/////////////////////////////////////////////////////////////////////////

//////////

/////////////////////////////////////////////////////////////////////////

//////////

module mux4to1

( input c, d ,e ,f,

input [1:0] s,

output logic MUX_OUT);

always_comb

begin

assert(^s!==1'bx)

else $warning("Select is x");

case (s)

2'b00 : MUX_OUT = c;

2'b01 : MUX_OUT = d;

2'b10 : MUX_OUT = e;

default : MUX_OUT = f;

endcase

end

endmodule

//test bench

module mux4to1_tb();

bit c, d ,e ,f;

logic [1:0] s;

logic MUX_OUT;

mux4to1 DUT(.*);

initial

begin

$fmonitor( $fopen("./mux4to1.txt"),"s MUX_OUT");

$fdisplay( $fopen("./mux4to1.txt"),"s=%b MUX_OUT=%b", s, MUX_OUT);

end

initial

repeat(50)

begin

c= $random();

d= $random();

e= $random();

f= $random();

s= $random();

#10 $display("s=%b MUX_OUT=%b", s, MUX_OUT);

end

endmodule

OUTPUT:

s=01 MUX_OUT=1

s=01 MUX_OUT=1

s=01 MUX_OUT=1

s=11 MUX_OUT=1

s=00 MUX_OUT=0

s=01 MUX_OUT=0

s=10 MUX_OUT=0

s=11 MUX_OUT=1

s=01 MUX_OUT=1

s=00 MUX_OUT=1

s=00 MUX_OUT=0

s=10 MUX_OUT=0

s=01 MUX_OUT=0

s=01 MUX_OUT=1

s=11 MUX_OUT=0

s=00 MUX_OUT=1

s=11 MUX_OUT=0

s=00 MUX_OUT=1

s=01 MUX_OUT=1

s=00 MUX_OUT=1

s=00 MUX_OUT=1

s=10 MUX_OUT=0

s=11 MUX_OUT=1

s=10 MUX_OUT=1

s=01 MUX_OUT=1

s=10 MUX_OUT=0

s=01 MUX_OUT=0

s=10 MUX_OUT=0

s=00 MUX_OUT=0

s=01 MUX_OUT=0

s=10 MUX_OUT=0

s=01 MUX_OUT=0

s=11 MUX_OUT=1

s=01 MUX_OUT=0

s=10 MUX_OUT=0

s=10 MUX_OUT=0

s=10 MUX_OUT=1

s=00 MUX_OUT=0

s=11 MUX_OUT=1

s=01 MUX_OUT=0

s=01 MUX_OUT=0

s=11 MUX_OUT=1

s=01 MUX_OUT=0

s=10 MUX_OUT=0

s=01 MUX_OUT=1

s=11 MUX_OUT=1

s=10 MUX_OUT=0

s=10 MUX_OUT=0

s=10 MUX_OUT=0

s=11 MUX_OUT=1

/////////////////////////////////////////////////////////////////////////

//////

/////////////////////////////////////////////////////////////////////////

//////

module relational

(input [3:0] A, B,

output logic Q1, Q2, Q3, Q4);

always_comb

begin

// Q1 = A > B; //greater than

// Q2 = A < B; //less than

// Q3 = A >= B; //greater than equal to

assert(A^B!=4'bx)

else $warning("Input is xxxx");

if (A

/////////////////////////////////////////////////////////////////////////

//////////////////////

/////////////////////////////////////////////////////////////////////////

//////////////////////

//Tristate

module TRISTATE (

input logic a, e,

output logic y

);

always_comb

begin

assert (^e !== 1'bx)

else ("input data e = X")

if (e)

y B; //logical shift right

end

endmodule

/////////////////////////////////////////////////////////////////////////

//////////////////

/////////////////////////////////////////////////////////////////////////

//////////////////

//Relational Operation

module relational (

input logic [3:0] A, B,

output logic Q1, Q2, Q3, Q4

);

always _comb

begin

assert (^{A, B} !== 1'bx)

else ("inputs = X")

// Q1 = A > B; //greater than

// Q2 = A < B; //less than

// Q3 = A >= B; //greater than equal to

if (A

input logic [2:0] select

);

parameter ADD = 3'b000,

SUB = 3'b001,

INR = 3'b010,

DCR = 3'b011,

CMP = 3'b100,

AND = 3'b101,

OR = 3'b110,

XOR = 3'b111;

always_comb

begin

assert (^select !== 1'bx)

else ("select = X")

case(select)

ADD: {cout, data_out} = x + y;

SUB: {cout, data_out} = x - y;

INR: {cout, data_out} = x + 1'b1;

DCR: {cout, data_out} = x - 1'b1;

CMP: begin data_out = ~x; cout = 1'b0; end

AND: begin data_out = x & y; cout = 1'b0; end

OR: begin data_out = x | y; cout = 1'b0; end

XOR: begin data_out = x ^ y; cout = 1'b0; end

endcase

end

endmodule

/////////////////////////////////////////////////////////////////////////

//////////////////////

/////////////////////////////////////////////////////////////////////////

/////////////////////

////////

assertions

Documents