Subversion Repositories fft2_size

timeunit 1ns;

timeprecision 1ns;

module fft_int_size_tb;

        localparam POW = 9;

        localparam DATA_WIDTH = 32;

        localparam POW_WIDTH = (2**$clog2(POW) > POW - 1) ? $clog2(POW) : $clog2(POW) + 1;

        localparam RES_WIDTH = DATA_WIDTH + POW;

        bit clk = 0, aclr = 1;

        bit sink_sop = 0, sink_eop = 0, sink_valid = 0;

        bit signed [DATA_WIDTH-1:0] sink_Re = 0, sink_Im = 0;

        bit [POW_WIDTH-1:0] pow = 7; // 4..POW

        wire pow_ready;

        wire source_sop, source_eop, source_valid;

        wire signed [RES_WIDTH-1:0] source_Re, source_Im;

        wire error;

        localparam time period = 20ns;

        always #(period/2) clk++;

        initial begin

                repeat(10) @(posedge clk);

                aclr = 0;

                repeat(10) @(posedge clk);

                wait(pow_ready);

                pow = 6;

                @(posedge clk);

                Test(2**pow, 1<<1);

                Test(2**pow, 1<<2);

                Test(2**pow, 5<<1);

                wait(pow_ready);

                pow = 9;

                @(posedge clk);

                Test(2**pow, 1<<1);

                Test(2**pow, 1<<2);

                Test(2**pow, 5<<1);

//              TestLine(2**pow);

//              TestConst(2**pow);

                wait (pow_ready || error);

                if (error) $warning("ERROR");

                repeat(2**pow * 3 + 400) @(posedge clk);

                $stop(2);

        end

        always #(period * 2**POW * 10) begin

                $warning("Timeout");

                $stop(2);

        end

        fft_int_size #(.POW(POW), .DATA_WIDTH(DATA_WIDTH)) dut(.*);

        localparam IFFT_WIDTH = RES_WIDTH + POW;

        wire ifft_pow_ready;

        wire signed [IFFT_WIDTH-1:0] ifft_source_Re, ifft_source_Im;

        wire signed [IFFT_WIDTH-POW-1:0] ifft_Re, ifft_Im;

        wire ifft_sop, ifft_eop, ifft_valid;

        wire ifft_err;

        fft_int_size #(.POW(POW), .DATA_WIDTH(RES_WIDTH)) ifft(

                .clk, .aclr,

                .sink_sop(source_sop), .sink_eop(source_eop), .sink_valid(source_valid),

                .sink_Re(source_Im), .sink_Im(source_Re),

                .pow(pow), .pow_ready(ifft_pow_ready),

                .source_sop(ifft_sop), .source_eop(ifft_eop), .source_valid(ifft_valid),

                .source_Re(ifft_source_Im), .source_Im(ifft_source_Re),

                .error(ifft_err)

        );

        assign ifft_Re = ifft_source_Re / 2**pow;

        assign ifft_Im = ifft_source_Im / 2**pow;

        task Test(int len, int bin_msk = 2);

                int ar[];

                ar = new[len];

                for (int i = 0; i < len; i++)

                        if ((bin_msk & 1<

                                ar[i] = 1<<16;

                        else

                                ar[i] = 0;

                for (int i = 0; i < len; i++) begin

                        sink_sop = i == 0;

                        sink_eop = i == len - 1;

                        sink_valid = 1;

                        sink_Re = ar[i];

                        @(posedge clk);

                end

                sink_sop = 0;

                sink_eop = 0;

                sink_valid = 0;

                sink_Re = 0;

                ar.delete();

        endtask

        task TestLine(int len);

                int ar_Im[], ar_Re[];

                ar_Re = new[len];

                ar_Im = new[len];

                for (int i = 0; i < len; i++) begin

                        ar_Re[i] = (i+1) * 2**16;

                        ar_Im[i] = 0;

//                      ar_Im[i] = -(i+1);

                end

                for (int i = 0; i < len; i++) begin

                        sink_sop = i == 0;

                        sink_eop = i == len - 1;

                        sink_valid = 1;

                        sink_Re = ar_Re[i];

                        sink_Im = ar_Im[i];

                        @(posedge clk);

                end

                sink_sop = 0;

                sink_eop = 0;

                sink_valid = 0;

                sink_Re = 0;

                sink_Im = 0;

                ar_Re.delete();

                ar_Im.delete();

        endtask

        task TestConst(int len);

                for (int i = 0; i < len; i++) begin

                        sink_sop = i == 0;

                        sink_eop = i == len - 1;

                        sink_valid = 1;

                        sink_Re = 2**16;

                        sink_Im = -(2**16);

                        @(posedge clk);

                end

                sink_sop = 0;

                sink_eop = 0;

                sink_valid = 0;

                sink_Re = 0;

                sink_Im = 0;

        endtask

endmodule :fft_int_size_tb