Subversion Repositories dblclockfft

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

//

// Filename:    butterfly_tb.cpp

//

// Project:     A Doubletime Pipelined FFT

//

// Purpose:     A test-bench for the butterfly.v subfile of the double

//              clocked FFT.  This file may be run autonomously.  If so,

//              the last line output will either read "SUCCESS" on success,

//              or some other failure message otherwise.

//

//              This file depends upon verilator to both compile, run, and

//              therefore test butterfly.v

//

// Creator:     Dan Gisselquist, Ph.D.

//              Gisselquist Tecnology, LLC

//

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

//

// Copyright (C) 2015, Gisselquist Technology, LLC

//

// This program is free software (firmware): you can redistribute it and/or

// modify it under the terms of  the GNU General Public License as published

// by the Free Software Foundation, either version 3 of the License, or (at

// your option) any later version.

//

// This program is distributed in the hope that it will be useful, but WITHOUT

// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

// for more details.

//

// You should have received a copy of the GNU General Public License along

// with this program.  (It's in the $(ROOT)/doc directory, run make with no

// target there if the PDF file isn't present.)  If not, see

// <http://www.gnu.org/licenses/> for a copy.

//

// License:     GPL, v3, as defined and found on www.gnu.org,

//              http://www.gnu.org/licenses/gpl.html

//

//

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

#include <stdio.h>

#include "verilated.h"

#include "Vfftmain.h"

#define LGWIDTH 11

#define IWIDTH  16

#define OWIDTH  22

#define FFTLEN  (1<<LGWIDTH)

class   FFT_TB {

public:

        Vfftmain        *m_fft;

        long            m_data[FFTLEN];

        int             m_addr;

        FILE            *m_dumpfp;

        FFT_TB(void) {

                m_fft = new Vfftmain;

                m_addr = 0;

                m_dumpfp = NULL;

        }

        void    tick(void) {

                m_fft->i_clk = 0;

                m_fft->eval();

                m_fft->i_clk = 1;

                m_fft->eval();

        }

        void    reset(void) {

                m_fft->i_ce  = 0;

                m_fft->i_rst = 1;

                tick();

                m_fft->i_rst = 0;

                tick();

        }

        bool    test(int lft, int rht) {

                m_fft->i_ce    = 1;

                m_fft->i_rst   = 0;

                m_fft->i_left  = lft;

                m_fft->i_right = rht;

                tick();

                if (m_fft->o_sync) {

                        m_addr = 0;

                } else m_addr += 2;

                printf("%5d: %08x,%08x -> %09lx,%09lx\t%s%s%s%s%s%s%s%s%s%s %s\n",

                        m_addr,

                        lft, rht, m_fft->o_left, m_fft->o_right,

                        (m_fft->v__DOT__w_s2048)?"S":"-",

                        (m_fft->v__DOT__w_s1024)?"S":"-",

                        (m_fft->v__DOT__w_s512)?"S":"-",

                        (m_fft->v__DOT__w_s256)?"S":"-",

                        (m_fft->v__DOT__w_s128)?"S":"-",

                        (m_fft->v__DOT__w_s64)?"S":"-",

                        (m_fft->v__DOT__w_s32)?"S":"-",

                        (m_fft->v__DOT__w_s16)?"S":"-", // This works

                        (m_fft->v__DOT__w_s8)?"S":"-",

                        (m_fft->v__DOT__w_s4)?"S":"-", // This doesn.t

                        (m_fft->o_sync)?"\t(SYNC!)":"");

                m_data[(m_addr  )&(FFTLEN-1)] = m_fft->o_left;

                m_data[(m_addr+1)&(FFTLEN-1)] = m_fft->o_right;

                if (m_addr == FFTLEN-2)

                        dumpwrite();

                return (m_fft->o_sync);

        }

        bool    test(double lft_r, double lft_i, double rht_r, double rht_i) {

                int     ilft, irht, ilft_r, ilft_i, irht_r, irht_i;

                ilft_r = (int)(lft_r + 0.5) & ((1<<IWIDTH)-1);

                ilft_i = (int)(lft_i + 0.5) & ((1<<IWIDTH)-1);

                irht_r = (int)(rht_r + 0.5) & ((1<<IWIDTH)-1);

                irht_i = (int)(rht_i + 0.5) & ((1<<IWIDTH)-1);

                ilft = (ilft_r << IWIDTH) | ilft_i;

                irht = (irht_r << IWIDTH) | irht_i;

                return test(ilft, irht);

        }

        double  rdata(int addr) {

                long    ivl = m_data[addr & (FFTLEN-1)];

                ivl = ivl >> 17;

                ivl &= ((1<<OWIDTH)-1);

                if (1 & (ivl>>(OWIDTH-1)))

                        ivl |= (-1l << OWIDTH);

                return (double)ivl;

        }

        double  idata(int addr) {

                long    ivl = m_data[addr & (FFTLEN-1)];

                ivl = ivl;

                ivl &= ((1<<OWIDTH)-1);

                if (1 & (ivl>>(OWIDTH-1)))

                        ivl |= (-1l << OWIDTH);

                return (double)ivl;

        }

        void    dump(FILE *fp) {

                m_dumpfp = fp;

        }

        void    dumpwrite(void) {

                if (!m_dumpfp)

                        return;

                double  *buf;

                buf = new double[FFTLEN * 2];

                for(int i=0; i<FFTLEN; i++) {

                        buf[i*2] = rdata(i);

                        buf[i*2+1] = idata(i);

                }

                fwrite(buf, sizeof(double), FFTLEN*2, m_dumpfp);

                delete[] buf;

        }

};

int     main(int argc, char **argv, char **envp) {

        Verilated::commandArgs(argc, argv);

        FFT_TB *fft = new FFT_TB;

        FILE    *fpout;

        fpout = fopen("fft_tb.dbl", "w");

        if (NULL == fpout) {

                fprintf(stderr, "Cannot write output file, fft_tb.dbl\n");

                exit(-1);

        }

        fft->reset();

        fft->dump(fpout);

        // Let's start by just testing our limits ...

        // First, the smallest real number

        for(int k=0; k<FFTLEN/2; k++)

                fft->test(1.0,0.0,1.0,0.0);

        // Then the smallest imaginary number

        for(int k=0; k<FFTLEN/2; k++)

                fft->test(0.0,1.0,0.0,1.0);

        // First, the smallest real number

        for(int k=0; k<FFTLEN/2; k++)

                fft->test(-1.0,0.0,-1.0,0.0);

        // Then the smallest imaginary number

        for(int k=0; k<FFTLEN/2; k++)

                fft->test(0.0,-1.0,0.0,-1.0);

        // Now, how about the smallest alternating real signal

        for(int k=0; k<FFTLEN/2; k++)

                fft->test(1.0,0.0,0.0,0.0); // Don't forget to expect a bias!

        // Now, how about the smallest alternating imaginary signal

        for(int k=0; k<FFTLEN/2; k++)

                fft->test(0.0,1.0,0.0,0.0); // Don't forget to expect a bias!

        // Now, how about the smallest alternating real signal,2nd phase

        for(int k=0; k<FFTLEN/2; k++)

                fft->test(0.0,0.0,1.0,0.0); // Don't forget to expect a bias!

        // Now, how about the smallest alternating imaginary signal,2nd phase

        for(int k=0; k<FFTLEN/2; k++)

                fft->test(0.0,0.0,0.0,1.0); // Don't forget to expect a bias!

        // Now let's go for the largest value

        for(int k=0; k<FFTLEN/2; k++)

                fft->test(-32768.0,-32768.0,-32768.0,-32768.0);

        // And finally, let's clear out our results / buffer

        for(int k=0; k<(FFTLEN/2) * 3; k++)

                fft->test(0.0,0.0,0.0,0.0);

        // Now let's try some exponentials

        // for(int k=0; k<FFTLEN/2; k++)

                // fft->test(-32768.0,-32768.0,-32768.0,-32768.0);

        fclose(fpout);

}

// 564, 874, 1058, 1178, 1300, 1422, 1546, 1666, 1788, 1798 --> SYNC @ 3852

// 2612, 2922, 3106, 3226, 3348, 3470, 3594, 3714, 3836, 3846

// 808, 1118, 1302, 1422, 1544, 1666, 1790, 1910, 2032, 2042 --> SYNC @ 2848

// 8756 .. ??