FIR handshake

#include <systemc.h>

SC_MODULE(fir) {

    sc_in< bool >       clk;

    sc_in< bool >       rst;

    sc_in< sc_int<16> > inp;

    sc_in< bool >       inp_vld;

    sc_out< bool >      inp_rdy;

    sc_out< sc_int<16> >    outp;

    sc_out< bool >      outp_vld;

    sc_in< bool >       outp_rdy;

    // Coefficients for each FIR

    const sc_uint<8> coef[5] = { 18, 77, 107, 77, 18 };

    void fir_main();

    SC_CTOR(fir) {

        SC_CTHREAD(fir_main, clk.pos());

        reset_signal_is(rst, true);

    };

};

#include "fir.h"

void fir::fir_main(void) {

    // Reset protocol

    sc_int<16> taps[5];

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

        taps[i] = 0;

    }

    // Initialize handshake

    inp_rdy.write(0);

    outp_vld.write(0);

    outp.write(0);

    wait();

    // FIR filter

    while (true) {

        sc_int<16> in_val;

        sc_int<16> out_val;

        inp_rdy.write(1);

        do {

            wait();

        } while (!inp_vld.read());

        in_val = inp.read();

        inp_rdy.write(0);

        //Read input into shift register

        for (int i = 5 - 1; i > 0; i--) {

            taps[i] = taps[i - 1];

        }

        taps[0] = inp.read();

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

            out_val += coef[i] * taps[i];

        }

        outp_vld.write(1);

        outp.write(out_val);

        do {

            wait();

        } while (!outp_rdy.read());

        outp_vld.write(0);

    }

}

#include <systemc.h>

SC_MODULE(tb){

    sc_in< bool >       clk;

    sc_out< bool >      rst;

    sc_out< sc_int<16> >    inp;

    sc_out< bool >      inp_vld;

    sc_in< bool >       inp_rdy;

    sc_in< sc_int<16> > outp;

    sc_in< bool >       outp_vld;

    sc_out< bool >      outp_rdy;

    void source();

    void sink();

    SC_CTOR(tb) {

        SC_CTHREAD(source, clk.pos());

        SC_CTHREAD(sink, clk.pos());

    };

};

#include "tb.h"

void tb::source() {

    // Reset

    inp.write(0);

    inp_vld.write(0);

    inp.write(1);

    wait();

    rst.write(0);

    wait();

    sc_int< 16 > tmp;

    // Send stimulus to FIR

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

        if (i > 23 && i < 29)

            tmp = 256;

        else

            tmp = 0;

        inp_vld.write(1);

        inp.write(tmp);

        do {

            wait();

        } while (!inp_rdy.read());

        inp_vld.write(0);

    }

};

void tb::sink() {

    sc_int< 16 > indata;

    char output_file[256];

    sprintf(output_file, "output.dat");

    outfp = fopen(output_file, "wb");

    if (outfp == NULL) {

        printf("Couldn't open output.dat for writing.\n");

        exit(0);

    }

    //Initialize port

    outp_rdy.write(0);

    // Read output coming form DUT

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

        outp_rdy.write(1);

        indata = outp.read( );

        do {

            wait();

        } while (!outp_vld.read());

        indata = outp.read();

        outp_rdy.write(0);

        fprintf(outfp, "%f\n", indata.to_double());

        cout << i << " :\t" << indata.to_double( ) << endl;

    }

    // End simulation

    fclose( outfp );

  sc_stop( );

};

#include <systemc.h>

#include "fir.h"

#include "tb.h"

SC_MODULE(SYSTEM) {

    tb* tb0;

    fir* fir0;

    sc_clock            clk_sig;

    sc_signal< bool >       rst_sig;

    sc_signal< sc_int<16> > inp_sig;

    sc_signal< bool >       inp_sig_vld;

    sc_signal< bool >       inp_sig_rdy;

    sc_signal< sc_int<16> > outp_sig;

    sc_signal< bool >       outp_sig_vld;

    sc_signal< bool >       outp_sig_rdy;

    SC_CTOR(SYSTEM) :clk_sig("clk_sig", 10, SC_NS) {

        tb0 = new tb("tb0");

        tb0->clk(clk_sig);

        tb0->rst(rst_sig);

        tb0->inp(inp_sig);

        tb0->inp_vld(inp_sig_vld);

        tb0->inp_rdy(inp_sig_rdy);

        tb0->outp(outp_sig);

        tb0->outp_vld(outp_sig_vld);

        tb0->outp_rdy(outp_sig_rdy);

        fir0 = new fir("fir0");

        fir0->clk(clk_sig);

        fir0->rst(rst_sig);

        fir0->inp(inp_sig);

        fir0->inp_vld(inp_sig_vld);

        fir0->inp_rdy(inp_sig_rdy);

        fir0->outp(outp_sig);

        fir0->outp_vld(outp_sig_vld);

        fir0->outp_rdy(outp_sig_rdy);

    };

    ~SYSTEM() {

        delete tb0;

        delete fir0;

    } // Destructor

};

int sc_main(int argc, char* argv[]) {

    SYSTEM* top = NULL;

    top = new SYSTEM("top");

    sc_start();

    return 0;

}