I try to simulate in Modelsim my code on Verilog. When I'm simulating it, it shows me X(red) outputs lines. This is my code and testbench:
module alu64bit (
input wire [63:0] a, // Input bit a
input wire [63:0] b, // Input bit b
input wire cin, // Carry in
input wire [1:0] op, // Operation
output wire [63:0] s, // Output S
output wire cout // Carry out
);
wire [63:0] cin_out;
assign cout = cin_out[63];
assign cin = cin_out[0];
genvar i;
generate
for(i=0; i <= 63; i = i + 1) begin
alu1bit alu (.s(s[i]),.cout(cin_out[i+1]),.a(a[i]),.b(b[i]),.cin(cin_out[i]),.op(op));
end
endgenerate
// End of your code
endmodule
TB:
module alu64bit_test;
reg [63:0] a;
reg [63:0] b;
reg [1:0] op;
reg cin;
wire [63:0] s;
wire cout;
alu64bit uut (
.a(a),
.b(b),
.cin(cin),
.op(op),
.s(s),
.cout(cout)
);
initial begin
a = 64'hffffffffffffffff;
b = 64'h0000000000000000;
cin = 0;
op[1] = 1;
op[0] = 0;
#100;
end
endmodule
enter image description here
Can somebody help me with this problem? Thank You!
Related
The output waveform shows no change in the sum, dif, burrow, and out. Even after increasing delay time, still the output shows no change. This should work like the mod adder like add 10 and 2 and with mod 3 give output zero.
CODE
module Mod_adder(a,b,p,out);
input [3:0] a;
input [3:0] b;
input [3:0] p;
output [3:0] out;
wire [3:0] sum;
wire cout;
wire burrow;
wire [3:0] dif;
ripple_carry_adder r1(a,b,sum,cout,1'b0);
ripple_carry_adder r2(sum,~p,dif,burrow,1'b1);
repeat_sum rs1(dif,burrow,sum);
outval o1(sum,burrow,out);
endmodule
module full_adder(in0, in1, cin, out, cout);
input in0, in1, cin;
output out, cout;
assign out = in0 ^ in1 ^ cin;
assign cout = ((in0 ^ in1) & cin) | (in0 & in1);
endmodule
module ripple_carry_adder(in0, in1, out, cout,cin);
input [3:0] in0;
input [3:0] in1;
output [3:0] out;
output cout;
input cin;
wire c1, c2, c3;
full_adder fa0(in0[0], in1[0], cin, out[0], c1);
full_adder fa1(in0[1], in1[1], c1, out[1], c2);
full_adder fa2(in0[2], in1[2], c2, out[2], c3);
full_adder fa3(in0[3], in1[3], c3, out[3], cout);
endmodule
module repeat_sum(dif,burrow,sum);
input [3:0] dif;
input burrow;
output [3:0] sum;
assign sum = (burrow == 1'b0) ? dif:sum;
endmodule
module outval(sum,burrow,out);
input [3:0] sum;
input burrow;
output [3:0] out;
assign out = (burrow == 1'b1) ? sum:out;
endmodule
TEST BENCH
` include "MOD_ADDER.V"
module Mod_adder_tb;
reg [3:0] a;
reg [3:0] b;
reg [3:0] p;
wire [3:0] out; // wires
// Instantiate the module to be tested
Mod_adder MA1(a,b,p,out);
initial begin // initial block
$dumpfile("Test_Full_Adder.vcd");
$dumpvars(1, MA1);
a=4'b1010;
b=4'b0100;
p=4'b0011;
#100;
end // end of initial block
endmodule
I see 2 major problems.
Your out testbench signal is unknown (X) because of driver contention. For example, the sum signal in Mod_adder has multiple drivers: from the r1 instance and from the rs1 instance. The out output of r1 and the sum output of rs1 are both driving the sum wire. You should not drive the same signal from 2 different module instances. You could rename one of the sum signals to something unique, like sum_rs1 and declare a new wire.
wire [3:0] sum, sum_rs1;
Also, you have combinational feed back loops. For example:
assign out = (burrow == 1'b1) ? sum:out;
The out signal should not be on both the LHS and RHS of a continuous assignment.
I am building a shift-unit that is capable of arithmetic and logical right shift, and logical left shift depending on the control signals given to it. However, the arithmetic right shift operator output generates output similar to that logical right shift operator, i.e. sign extension does not occur.
Main code
`timescale 1ns / 1ps
module shift_unit(
input [15:0] a,
input [3:0] b,
input clk,
input isLSL,
input isLSR,
input isASR,
output reg [15:0] result
);
wire [15:0] LSL_result, LSR_result, ASR_result;
LSL lsl(a, b, clk, isLSL, LSL_result);
LSR lsr(a, b, clk, isLSR, LSR_result);
ASR asr(a, b, clk, isASR, ASR_result);
always#(posedge clk) begin
case({isLSL, isLSR, isASR})
3'b001: result <= ASR_result;
3'b010: result <= LSR_result;
3'b100: result <= LSL_result;
endcase
end
endmodule
LSL code:
`timescale 1ns / 1ps
module LSL(
input [15:0] a,
input [3:0] b,
input clk,
input isLSL,
output [15:0] out
);
reg [15:0] result;
always#(posedge clk) begin
if(isLSL) result = a << b;
end
assign out = result;
endmodule
LSR code:
`timescale 1ns / 1ps
module LSR(
input [15:0] a,
input [3:0] b,
input clk,
input isLSR,
output [15:0] out
);
reg [15:0] result;
always#(posedge clk) begin
if(isLSR) result = a >> b;
end
assign out = result;
endmodule
ASR code:
`timescale 1ns / 1ps
module ASR(
input [15:0] a,
input [3:0] b,
input clk,
input isASR,
output [15:0] out
);
reg [15:0] result;
always#(posedge clk) begin
if(isASR) result = a >>> b;
end
assign out = result;
endmodule
And finally, the testbench:
`timescale 1ns / 1ps
module shift_unit_test;
reg [15:0] a;
reg [3:0] b;
reg clk;
reg isLSL;
reg isLSR;
reg isASR;
wire [15:0] result;
shift_unit uut (
.a(a),
.b(b),
.clk(clk),
.isLSL(isLSL),
.isLSR(isLSR),
.isASR(isASR),
.result(result)
);
always #5 clk = ~clk;
initial begin
clk = 1'b0;
a = 16'b1100101011001010;
b = 4;
{isLSL, isLSR, isASR} = 3'b100; #100;
{isLSL, isLSR, isASR} = 3'b010; #100;
{isLSL, isLSR, isASR} = 3'b001; #100;
end
endmodule
The above code has been modelled using Xilinx ISE 14.7.
Any help would be greatly appreciated.
You need to be working with signed signals to get sign extension.
module ASR(
input wire signed [15:0] a,
input [3:0] b,
input clk,
input isASR,
output reg signed [15:0] out
);
always#(posedge clk) begin
if(isASR) out = a >>> b;
end
endmodule
I don't understand why I'm getting this error when using model-sim, I've tried a lot of fixes but don't seem to get around this.
This is what my modelsim transcript says:
** Error: (vsim-3389) C:/Users/VRN/Desktop/sha256/t_processing.v(31): Port 'a_in' not found in the connected module (5th connection).
# Time: 0 ps Iteration: 0 Instance: /t_processing/uut File: C:/Users/VRN/Desktop/sha256/interative_processing.v
7 similar errors with the input ports
`timescale 1ns / 1ps
module interative_processing(clk,rst,w,k,counter_iteration,padding_done,a_out,b_out,c_out,d_out,e_out,f_out,g_out,h_out
);
input clk,rst,padding_done;
input [6:0] counter_iteration;
input [31:0] w,k;
output reg [31:0] a_out,b_out,c_out,d_out,e_out,f_out,g_out,h_out;
reg temp_case,temp_if;
reg [31:0] a_temp,b_temp,c_temp,d_temp,e_temp,f_temp,g_temp,h_temp;
reg [31:0] semation_0,semation_1,ch,maj;
always#(posedge clk)
begin
if(rst==0)
begin
temp_case=1'b0;
a_out=32'h6a09e667;
b_out=32'hbb67ae85;
c_out=32'h3c6ef372;
d_out=32'ha54ff53a;
e_out=32'h510e527f;
f_out=32'h9b05688c;
g_out=32'h1f83d9ab;
h_out=32'h5be0cd19;
end
else
begin
semation_0=({a_out[1:0],a_out[31:2]}) ^ ({a_out[12:0],a_out[31:13]}) ^ ({a_out[21:0],a_out[31:22]}); //last 22 ROTR22
semation_1=({e_out[5:0],e_out[31:6]}) ^ ({e_out[10:0],e_out[31:11]}) ^ ({e_out[24:0],e_out[31:25]});
maj=(a_out & b_out) ^ (a_out & c_out) ^ (b_out & c_out);
ch=(e_out & f_out) ^ (~e_out & g_out);
if(counter_iteration==65)
begin
a_out=a_out;
b_out=b_out;
c_out=c_out;
d_out=d_out;
e_out=e_out;
f_out=f_out;
g_out=g_out;
h_out=h_out;
end
else
begin
if(padding_done==1)
begin
case(temp_case)
1'b0: temp_case=1'b1;
1'b1: temp_if=1'b1;
endcase
end
if(temp_if==1 && counter_iteration!=64)
begin
a_temp= h_out + semation_1 + ch + k + w + semation_0 + maj; // T2= semation_0 + maj(a,b,c);
b_temp= a_out;
c_temp= b_out;
d_temp= c_out;
e_temp= d_out + h_out + semation_1 + ch + k + w; //T1 = h_out + semation_1 + ch + k + w;
f_temp= e_out;
g_temp= f_out;
h_temp= g_out;
a_out=a_temp;
b_out=b_temp;
c_out=c_temp;
d_out=d_temp; //alternative of non-blocking though
e_out=e_temp;
f_out=f_temp;
g_out=g_temp;
h_out=h_temp;
end
end
end
end
endmodule
and my testbench:
`timescale 1ns / 1ps
module t_processing;
// Inputs
reg clk;
reg rst;
reg [31:0] w;
reg [31:0] k;
reg [31:0] a_in;
reg [31:0] b_in;
reg [31:0] c_in;
reg [31:0] d_in;
reg [31:0] e_in;
reg [31:0] f_in;
reg [31:0] g_in;
reg [31:0] h_in;
// Outputs
wire [31:0] a_out;
wire [31:0] b_out;
wire [31:0] c_out;
wire [31:0] d_out;
wire [31:0] e_out;
wire [31:0] f_out;
wire [31:0] g_out;
wire [31:0] h_out;
// Instantiate the Unit Under Test (UUT)
interative_processing uut (
.clk(clk),
.rst(rst),
.w(w),
.k(k),
.a_in(a_in),
.b_in(b_in),
.c_in(c_in),
.d_in(d_in),
.e_in(e_in),
.f_in(f_in),
.g_in(g_in),
.h_in(h_in),
.a_out(a_out),
.b_out(b_out),
.c_out(c_out),
.d_out(d_out),
.e_out(e_out),
.f_out(f_out),
.g_out(g_out),
.h_out(h_out)
);
initial begin
// Initialize Inputs
clk = 0;
rst = 0;
w = 0;
k = 0;
a_in = 0;
b_in = 0;
c_in = 0;
d_in = 0;
e_in = 0;
f_in = 0;
g_in = 0;
h_in = 0;
end
initial
begin // Wait 100 ns for global reset to finish
#100;
end
initial clk=1'b0;
always #(clk) clk<= #5 ~clk;
initial
begin
rst = 1'b0;
#10 rst = 1'b1;
k = 32'hc67178f2;
w = 32'h12b1edeb;
a_in = 32'hd39a2165;
c_in = 32'hb85e2ce9;
d_in = 32'hb6ae8fff;
e_in = 32'hfb121210;
f_in = 32'h948d25b6;
g_in = 32'h961f4894;
h_in = 32'hb21bad3d;
b_in= 32'h04d24d6c;
end
endmodule
Here's a list of the input/output ports you've defined in the interactive_processing module.
input wire clk,
input wire rst,
input wire padding_done;
input wire [6:0] counter_iteration;
input wire [31:0] w,
input wire [31:0] k,
output reg [31:0] a_out,
output reg [31:0] b_out,
output reg [31:0] c_out,
output reg [31:0] d_out,
output reg [31:0] e_out,
output reg [31:0] f_out,
output reg [31:0] g_out,
output reg [31:0] h_out
Here's the list of inputs and outputs you're trying to pass to the interactive_processing module.
.clk(clk),
.rst(rst),
.w(w),
.k(k),
.a_in(a_in),
.b_in(b_in),
.c_in(c_in),
.d_in(d_in),
.e_in(e_in),
.f_in(f_in),
.g_in(g_in),
.h_in(h_in),
.a_out(a_out),
.b_out(b_out),
.c_out(c_out),
.d_out(d_out),
.e_out(e_out),
.f_out(f_out),
.g_out(g_out),
.h_out(h_out)
The compiler has no idea what to do with a__in through h__in because you haven't defined them as inputs to the module.
module DIGITADD(
input [3:0] A,
input [3:0] B,
input CIN,
output COUT,
output [3:0] SUM
);
reg [4:0] s2;
assign SUM = s2[3:0];
assign COUT = s2[4];
//BCD ADDER PART
always # ( * )
begin
s2 = A + B + CIN;
if (s2 > 9)
begin
s2 = s2 + 6;
end
end
endmodule
TEST BENCH
module DIGITADD_tb(
reg [3:0] A,
reg [3:0] B,
reg CIN,
wire COUT,
wire [3:0] SUM);
DIGITADD uut(
.A(A),
.B(B),
.CIN(CIN),
.COUT(COUT),
.SUM(SUM));
initial begin
$dumpfile("dump.vcd");
$dumpvars(1,DIGITADD_tb);
#10;
#10 A=4'b0000;B=4'b0011;CIN=1'b0;
#10 A=4'b0111;B=4'b1000;CIN=1'b1;
$finish;
end
endmodule
You have added local variables in your testbench in the style of a port list:
module DIGITADD_tb(
reg [3:0] A,
reg [3:0] B,
reg CIN,
wire COUT,
wire [3:0] SUM);
Should be:
module DIGITADD_tb(); //<-- no ports
reg [3:0] A; //<-- semicolon
reg [3:0] B;
reg CIN;
wire COUT;
wire [3:0] SUM;
My code compiles but does not dump any dat file for gtkwave. I'm trying to implement a combination shift multiplier object. I don't think my tester is correct.
module combinational_mult(product,multiplier,multiplicand);
input [31:0] multiplier;
input[63:0] multiplicand;
output reg [63:0] product;
reg c;
reg [31:0] m;
integer i;
always #( multiplier or multiplicand )
begin
//initialize
product[63:32] = 16'b0000_0000_0000_0000;
product[32:16] = multiplier;
m = multiplicand;
c = 1'b0;
//add,shift algorithm for unsigned multiplication.
//following the notes.
for(i=0; i<32; i=i+1)
begin
if(product[0]) {c,product[63:32]} = product[63:32] + m ;
product[63:0] = {c,product[63:1]};
c = 0;
end
end
endmodule
module tester(output reg [31:0] multiplier, output reg [63:0] multiplicand, output reg [63:0] product, output reg c, output reg i);
initial begin
i = 0;
$dumpfile("USAMv1.dat");
$dumpvars;
#10 multiplier = 16'b1101_1001_1101_1001;
multiplicand = 16'b0110_1010_1101_1000;
#50 $finish;
end
endmodule
module testbench;
wire[31:0] multiplier;
wire[63:0] multiplicand;
wire[63:0] product;
wire c, i;
tester sim( multiplier, multiplicand, product, c, i);
combinational_mult dut ( product, multiplier, multiplicand);
endmodule
I have created a version on EDA Playground which removes the tester and just runs a test program in the testbench.
I have renamed the dump.dat to dump.vcd to work with EDA Playground. which should launch the wave form window when run.
No real changes to the code other than moving test program to the testbench, and adding a second data point to the test vectors so they can be observed. otherwise the VCD finishes at the point they change.
module testbench;
reg [31:0] multiplier;
reg [63:0] multiplicand;
initial begin
$dumpfile("dump.vcd");
$dumpvars;
#10ns;
multiplier = 16'b1101_1001_1101_1001;
multiplicand = 16'b0110_1010_1101_1000;
#50ns;
multiplier = 16'b0;
multiplicand = 16'b0;
$finish;
end
combinational_mult dut ( product, multiplier, multiplicand);
endmodule