Subversion Repositories spacewiresystemc

#ifndef TX_RX_SC_TOP_H
#define TX_RX_SC_TOP_H
 
#include "spw_fsm.h"
 
#include "tx_spw.h"
#include "tx_clock.h"
#include "link_sc.h"
 
#include "rx_spw.h"
#include "rx_spw_clock_recovery.h"
 
#include "send_module_sc.h"
 
class sc_TOP;
 
SC_MODULE(sc_TOP)
{
 
	/*FSM signal*/
	sc_in<bool> CLOCK;
	sc_in<bool> RESET;
	sc_in<bool> LINK_START;
	sc_in<bool> LINK_DISABLE;
	sc_in<bool> AUTO_START;
	sc_out<sc_uint<4> > FSM_SPW_OUT;
 
	/*Signal come from RX Receiver*/
	sc_signal<bool> GOT_FCT_RX;
	sc_signal<bool> GOT_TIMECODE_RX;
	sc_signal<bool> GOTNCHAR_RX;
	sc_signal<bool> GOTNULL_RX;
	sc_signal<bool> GOTBIT_RX;
	sc_signal<bool> CREDITERROR_RX;
	sc_signal<bool> RXERROR;
 
	/*Signal come from TX Transmit*/
	sc_signal<bool> ENABLE_TX;
	sc_signal<bool> SEND_NULL_TX;
	sc_signal<bool> SEND_FCT_TX;
	sc_signal<bool> SEND_NCHAR_TX;
	sc_signal<bool> SEND_TIME_CODE_TX;
 
	/*RESET TX / RX*/
	sc_signal<bool> RESET_TX;
 
	//sc_signal<bool> GOT_FCT_TX;
	//TX ONLY
	sc_signal<bool> TICKIN_TX;
	sc_signal<sc_uint<8> > TIMEIN_CONTROL_FLAG_TX;
 
	sc_signal<bool> SEND_FCT_NOW_TOP;
	sc_signal<bool> TXWRITE_TX_S;
	sc_signal<sc_uint<9> > TXDATA_FLAGCTRL_TX;
 
	sc_signal<bool> READY_TX;
	sc_signal<bool> READY_TICK;
 
	sc_signal<bool> CLOCK_TX_OUT;
 
	sc_out<uint> DOUT; //TROCAR PARA UINT QUANDO FOR PARA O VPI
	sc_out<uint> SOUT; //TROCAR PARA UINT QUANDO FOR PARA O VPI
 
	sc_out<sc_uint<4> > FSM_TX;
 
	//MODULE RX
	sc_in<uint>  DIN;
	sc_in<uint>  SIN;
 
	sc_signal<bool> ENABLE_RX;
	sc_signal<bool> RESET_RX;
 
	sc_signal<bool> RX_CLOCK_IN;
	sc_in<bool> BUFFER_READY;
	sc_out<sc_uint<9> > DATARX_FLAG;
	sc_out<bool> BUFFER_WRITE;
 
	sc_out<sc_uint<8> > TIME_OUT;
	sc_out<bool>	TICK_OUT;
	sc_out<bool>	CONTROL_FLAG_OUT;
 
	sc_in<sc_uint<10> > CLOCK_GEN;
	sc_in<bool> E_SEND_DATA;
 
	SPW_TX_SC DUT;
	SPW_TX_CLOCK_SC DUT1;
 
	SPW_RX_SC DUT2;
	SPW_RX_CLOCK_RECOVERY_SC DUT3;
 
	SPW_FSM_SC DUT4;
 
	SPW_TX_SEND_DATA DUT5;
 
 	SC_CTOR(sc_TOP) : DUT("DUT"),DUT1("DUT1"),DUT2("DUT2"),DUT3("DUT3"),DUT4("DUT4"),DUT5("DUT5")
	{
		DUT1.CLOCK_GEN(CLOCK_GEN);
		DUT1.RESET(RESET);
		DUT1.CLOCK_TX_OUT(CLOCK_TX_OUT);
 
		DUT.CLOCK_TX(CLOCK_TX_OUT);
		DUT.CLOCK_SYS(CLOCK);
		DUT.RESET_TX(RESET_TX);
		DUT.TICKIN_TX(TICKIN_TX);
		DUT.TIMEIN_CONTROL_FLAG_TX(TIMEIN_CONTROL_FLAG_TX);
		DUT.TXWRITE_TX(TXWRITE_TX_S);
		DUT.TXDATA_FLAGCTRL_TX(TXDATA_FLAGCTRL_TX);
 
		DUT.SEND_FCT_NOW(SEND_FCT_NOW_TOP);
		DUT.ENABLE_TX(ENABLE_TX);
		DUT.SEND_NULL_TX(SEND_NULL_TX);
		DUT.SEND_FCT_TX(SEND_FCT_TX);
		DUT.SEND_NCHAR_TX(SEND_NCHAR_TX);
		DUT.SEND_TIME_CODE_TX(SEND_TIME_CODE_TX);
		DUT.GOTFCT_TX(GOT_FCT_RX);
		DUT.READY_TX(READY_TX);
 
		DUT.READY_TICK(READY_TICK);
		DUT.DOUT(DOUT);
		DUT.SOUT(SOUT);
		DUT.FSM_TX(FSM_TX);
 
		DUT3.DIN_REC(DIN);
		DUT3.SIN_REC(SIN);
		DUT3.RX_CLOCK_OUT(RX_CLOCK_IN);
 
		DUT2.RX_CLOCK(RX_CLOCK_IN);
		DUT2.DIN(DIN);
		DUT2.SIN(SIN);
		DUT2.CLOCK_SYS(CLOCK);
		DUT2.ENABLE_RX(ENABLE_RX);
		DUT2.RESET_RX(RESET_RX);
		DUT2.RX_ERROR(RXERROR);
		DUT2.RX_CREDIT_ERROR(CREDITERROR_RX);
		DUT2.GOT_BIT(GOTBIT_RX);
		DUT2.GOT_NULL(GOTNULL_RX);
		DUT2.GOT_NCHAR(GOTNCHAR_RX);
		DUT2.GOT_TIME_CODE(GOT_TIMECODE_RX);
		DUT2.GOT_FCT(GOT_FCT_RX);
		DUT2.SEND_FCT_NOW_RX(SEND_FCT_NOW_TOP);
 
		DUT2.BUFFER_READY(BUFFER_READY);
		DUT2.DATARX_FLAG(DATARX_FLAG);
		DUT2.BUFFER_WRITE(BUFFER_WRITE);
		DUT2.TIME_OUT(TIME_OUT);
		DUT2.TICK_OUT(TICK_OUT);
		DUT2.CONTROL_FLAG_OUT(CONTROL_FLAG_OUT);
 
		DUT4.CLOCK(CLOCK);
		DUT4.RESET(RESET);
		DUT4.LINK_START(LINK_START);
		DUT4.LINK_DISABLE(LINK_DISABLE);
		DUT4.AUTO_START(AUTO_START);
		DUT4.FSM_SPW_OUT(FSM_SPW_OUT);
 
		DUT4.GOT_FCT_RX(GOT_FCT_RX);
		DUT4.GOT_TIMECODE_RX(GOT_TIMECODE_RX);
		DUT4.GOTNCHAR_RX(GOTNCHAR_RX);
		DUT4.GOTNULL_RX(GOTNULL_RX);
		DUT4.GOTBIT_RX(GOTBIT_RX);
		DUT4.CREDITERROR_RX(CREDITERROR_RX);
		DUT4.RXERROR_RX(RXERROR);
		DUT4.ENABLE_RX(ENABLE_RX);
 
		DUT4.ENABLE_TX(ENABLE_TX);
		DUT4.SEND_NULL_TX(SEND_NULL_TX);
		DUT4.SEND_FCT_TX(SEND_FCT_TX);
		DUT4.SEND_NCHAR_TX(SEND_NCHAR_TX);
		DUT4.SEND_TIMECODE_TX(SEND_TIME_CODE_TX);
		DUT4.RESET_TX(RESET_TX);
		DUT4.RESET_RX(RESET_RX);
 
		DUT5.CLOCK_SEND_DATA(CLOCK);
		DUT5.RESET_SEND_DATA(RESET);
		DUT5.E_SEND_DATA(E_SEND_DATA);
		DUT5.TICKIN_TX_SEND_DATA(TICKIN_TX);
		DUT5.TIMEIN_CONTROL_FLAG_TX_SEND_DATA(TIMEIN_CONTROL_FLAG_TX);
		DUT5.TXWRITE_TX_SEND_DATA(TXWRITE_TX_S);
		DUT5.TXDATA_FLAGCTRL_TX_SEND_DATA(TXDATA_FLAGCTRL_TX);
		DUT5.READY_TX_SEND_DATA(READY_TX);
		DUT5.READY_TICK_DATA(READY_TICK);
 
		cout << "SC_CTOR(sc_TOP)" << endl;
	}
 
 
 
};
 
#endif