URL https://opencores.org/ocsvn/spacewiresystemc/spacewiresystemc/trunk

Subversion Repositories spacewiresystemc

[/] [spacewiresystemc/] [trunk/] [systemC/] [rx_spw.h] - Blame information for rev 29

Go to most recent revision | Details | Compare with Previous | View Log


//+FHDR------------------------------------------------------------------------
//Copyright (c) 2013 Latin Group American Integhrated Circuit, Inc. All rights reserved
//GLADIC Open Source RTL
//-----------------------------------------------------------------------------
//FILE NAME      :
//DEPARTMENT     : IC Design / Verification
//AUTHOR         : Felipe Fernandes da Costa
//AUTHOR’S EMAIL :
//-----------------------------------------------------------------------------
//RELEASE HISTORY
//VERSION DATE AUTHOR DESCRIPTION
//1.0 YYYY-MM-DD name
//-----------------------------------------------------------------------------
//KEYWORDS : General file searching keywords, leave blank if none.
//-----------------------------------------------------------------------------
//PURPOSE  : ECSS_E_ST_50_12C_31_july_2008
//-----------------------------------------------------------------------------
//PARAMETERS
//PARAM NAME            RANGE   : DESCRIPTION : DEFAULT : UNITS
//e.g.DATA_WIDTH        [32,16] : width of the DATA : 32:
//-----------------------------------------------------------------------------
//REUSE ISSUES
//Reset Strategy        :
//Clock Domains         :
//Critical Timing       :
//Test Features         :
//Asynchronous I/F      :
//Scan Methodology      :
//Instantiations        :
//Synthesizable (y/n)   :
//Other                 :
//-FHDR------------------------------------------------------------------------
 
#ifndef SPW_RX_H
#define SPW_RX_H
 
#define STATE_RESET     0
#define STATE_ENABLED   1
#define STATE_GOT_BIT   2
#define STATE_GOT_NULL  3
 
#define ESC       0
#define FCT       1
#define EOP       2
#define EEP       3
#define DATA      4
#define TIME_CODE 5
 
class SPW_RX_SC;
 
SC_MODULE(SPW_RX_SC)
{
 
        sc_in<bool> RX_CLOCK;
        sc_in<uint>  DIN;
        sc_in<uint>  SIN;
 
        sc_in<bool> CLOCK_SYS;
 
        sc_in<bool> ENABLE_RX;
        sc_in<bool> RESET_RX;
 
        sc_out<bool> RX_ERROR;
        sc_out<bool> RX_CREDIT_ERROR;
        sc_out<bool> GOT_BIT;
        sc_out<bool> GOT_NULL;
        sc_out<bool> GOT_NCHAR;
        sc_out<bool> GOT_TIME_CODE;
        sc_out<bool> GOT_FCT;
 
        sc_out<bool> SEND_FCT_NOW_RX;
 
        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;
 
        //INTERNAL 
        sc_uint<4> state_rx;
 
        sc_uint<4> control;
        sc_uint<10> data;
        sc_uint<10> timecode;
 
        sc_uint<4> control_sys =4;
        sc_uint<4> last_control_sys =4;
 
        sc_uint<10> data_sys;
        sc_uint<10> last_data;
 
        sc_uint<10> timecode_sys;
        sc_uint<10> last_timecode;
 
        sc_signal<bool> tag_found;
 
        unsigned int counter = 0;
        unsigned int counter_fct = 0;
        unsigned int counter_received_data = 0;
        bool enable_bit;
        bool first_time;
 
        bool connected = false;
 
        int cycles=0;
 
        bool control_found;
        bool data_found;
        bool time_code_found;
 
 
        bool NULL_FOUND;
        bool FCT_FOUND;
        bool DATA_FOUND;
        bool TIMECODE_FOUND;
 
        bool control_parity_error;
        bool data_parity_error;
        bool time_code_parity_error;
        bool invalid_combination;
 
        vector<sc_uint<9> > data_store;
        vector<sc_uint<9> > time_code;
 
        unsigned int last_char;
 
        void CalcPARITY()
        {
                control_parity_error = false;
                data_parity_error = false;
                time_code_parity_error = false;
                if(last_char == ESC || last_char == FCT || last_char == EOP || last_char == EEP)
                {
                        if(control_found)
                        {
                                if(!(control_sys[2]^last_control_sys[0]^last_control_sys[1]) != control_sys[3])
                                {
                                        control_parity_error = true;
                                }
                        }else if(data_found)
                        {
                                if(!(data_sys[8]^last_control_sys[0]^last_control_sys[1])  != data_sys[9])
                                {
                                        data_parity_error = true;
                                }
                        }else if(time_code_found)
                        {
                                if(!(timecode_sys[8]^last_control_sys[0]^last_control_sys[1]) != timecode_sys[9])
                                {
                                        time_code_parity_error = true;
                                }
                        }
                }else if(last_char == DATA)
                {
                        if(control_found)
                        {
                                if(!(data_sys[8]^last_control_sys[0]^last_control_sys[1])  != data_sys[9])
                                {
                                        control_parity_error = true;
                                }
                        }else if(data_found)
                        {
                                if(!(data_sys[8]^last_data[0]^last_data[1]^last_data[2]^last_data[3]^last_data[4]^last_data[5]^last_data[6]^last_data[7]) != data_sys[9])
                                {
                                        data_parity_error = true;
                                }
                        }else if(time_code_found)
                        {
                                if(!(data_sys[8]^timecode_sys[0]^timecode_sys[1]^timecode_sys[2]^timecode_sys[3]^timecode_sys[4]^timecode_sys[5]^timecode_sys[6]^timecode_sys[7])  != data_sys[9])
                                {
                                        time_code_parity_error = true;
                                }
                        }
                }else if(last_char == TIME_CODE)
                {
                        if(control_found)
                        {
                                if(!(timecode_sys[8]^last_control_sys[0]^last_control_sys[1])  != timecode_sys[9])
                                {
                                        control_parity_error = true;
                                }
                        }/*else if(data_found)
                        {
                                if(!(timecode[8]^data_sys[0]^data_sys[1]^data_sys[2]^data_sys[3]^data_sys[4])^data_sys[5]^data_sys[6]^data_sys[7] != timecode[9])
                                {
                                        data_parity_error = true;
                                }
                        }else if(time_code_found)
                        {
                                if(!(timecode[8]^timecode_sys[0]^timecode_sys[1]^timecode_sys[2]^timecode_sys[3]^timecode_sys[4]^timecode_sys[5]^timecode_sys[6]^timecode_sys[7])  != timecode[9])
                                {
                                        time_code_parity_error = true;
                                }
                        }*/
                }
        }
 
        void gotFCT()
        {
                while(1)
                {
                        if(!ENABLE_RX)
                        {
                                RX_CREDIT_ERROR = false;
                                counter_fct = 1;
                        }else
                        {
                                if(counter_fct*8 > 56)
                                {
                                        RX_CREDIT_ERROR = true;
                                        wait(1);
                                        RX_CREDIT_ERROR = false;
                                }
                        }
                        wait(1);
                }
        }
 
        void UPDATE_FCT()
        {
                while(1)
                {
                        if(!ENABLE_RX)
                        {
                                SEND_FCT_NOW_RX = false;
                                counter_received_data = 0;
                        }else if(counter_received_data >= 64)
                        {
                                SEND_FCT_NOW_RX = true;
                                counter_received_data = 0;
                        }else { SEND_FCT_NOW_RX = false;}
                        wait(1);
                }
        }
 
 
        void TIMER_ADTER850()
        {
                if(GOT_BIT)
                {
                        cycles=0;
                }
        }
 
        void TIMER_850COUNTER()
        {
                if(!ENABLE_RX)
                {
                        RX_ERROR = false;
                        control_parity_error = false;
                        data_parity_error = false;
                        time_code_parity_error = false;
                        invalid_combination = false;
                        cycles = 0;
                }
                else
                {
                        //if(GOT_BIT)
                        //{
                                if(cycles == 43 || control_parity_error || data_parity_error || time_code_parity_error || invalid_combination)
                                {
                                        //RX_ERROR = true;
                                        #ifdef RX_ERROR_ENABLE
                                        cout << "ERROR RX ENABLE" << endl;
                                        cout << control_parity_error << endl;
                                        cout << data_parity_error << endl;
                                        cout << time_code_parity_error << endl;
                                        cout << invalid_combination << endl;
                                        #endif
                                }
                                else
                                {
                                        RX_ERROR = false;
                                        cycles++;
                                }
                        //}
                }
        }
 
 
        void RX_GET_SIGNAL()
        {
 
                if( NULL_FOUND )
                {
                        GOT_NULL   = true;
                        GOT_FCT    = false;
                        GOT_NCHAR  = false;
                }else if( FCT_FOUND )
                {
                        GOT_FCT    = true;
                        GOT_NULL   = false;
                        GOT_NCHAR  = false;
                }else if( DATA_FOUND )
                {
                        GOT_NCHAR  = true;
                        GOT_FCT    = false;
                        GOT_NULL   = false;
                }else if( TIMECODE_FOUND )
                {
                        GOT_TIME_CODE = true;
                        GOT_NCHAR  = false;
                        GOT_FCT    = false;
                        GOT_NULL   = false;
                }
 
        }
 
        void RX_RECEIVER()
        {
                GOT_BIT        = true;
                NULL_FOUND     = false;
                FCT_FOUND      = false;
                DATA_FOUND     = false;
                TIMECODE_FOUND = false;
                data_col_store.clear();
 
                if(!connected)
                {
                        if(counter == 0)
                        {
                                timecode(0,0) = data(9,9) = control(3,3) = DIN;
                                counter++;
                        }
                        else if(counter == 1)
                        {
                                timecode(1,1) = data(8,8) = control(2,2) = DIN;
                                counter++;
                        }
                        else if(counter == 2)
                        {
                                timecode(2,2) = data(0,0) = control(1,1) = DIN;
                                counter++;
                        }else if(counter == 3)
                        {
                                data_col_store.clear();
 
                                timecode(3,3) = data(1,1) = control(0,0) = DIN;
 
                                counter = 0;
 
                                if(last_control_sys(2,0) == 7 && control(2,0) == 4)
                                {
                                        control_found = true;
                                        NULL_FOUND = true;
                                        FCT_FOUND = false;
                                        DATA_FOUND = false;
                                        last_char = ESC;
 
                                        data_col_store.push_back("NULL");
                                        data_col_store.push_back(" - ");
                                        data_col_store.push_back(last_control_sys(2,0).to_string(SC_HEX) + control(2,0).to_string());
                                        data_col_store.push_back(" - ");
                                        data_col_store.push_back(sc_time_stamp().to_string());
                                        REC_TX_SPW->storedata(data_col_store);
 
                                        if(counter_fct > 0)
                                        {
                                                counter_fct = counter_fct -1;
                                        }
 
 
                                }else if(last_control_sys(2,0) != 7 && control(2,0) == 4)
                                {
                                        last_char = FCT;
                                        counter_fct++;
                                        FCT_FOUND = true;
                                        connected = true;
                                        NULL_FOUND = false;
 
                                        data_col_store.push_back("FCT");
                                        data_col_store.push_back(" - ");
                                        data_col_store.push_back(last_control_sys(2,0).to_string(SC_HEX) + control(2,0).to_string());
                                        data_col_store.push_back(" - ");
                                        data_col_store.push_back(sc_time_stamp().to_string());
                                        REC_TX_SPW->storedata(data_col_store);
 
 
                                }else if(last_control_sys(2,0) == 4 && control(2,0) == 7)
                                {
                                        last_char = ESC;
                                        if(counter_fct > 0)
                                        {
                                                counter_fct = counter_fct -1;
                                        }
                                }else
                                {
                                        invalid_combination = true;
                                        connected = false;
                                        //cout << last_control_sys(2,0) <<  control_sys(2,0) << endl;
                                        data_col_store.push_back("INVALID CONNECTION");
                                        data_col_store.push_back(" - ");
                                        data_col_store.push_back(last_control_sys(2,0).to_string(SC_HEX) + control(2,0).to_string());
                                        data_col_store.push_back(" - ");
                                        data_col_store.push_back(sc_time_stamp().to_string());
                                        REC_TX_SPW->storedata(data_col_store);
                                }
                                last_control_sys = control;
                                //control_sys = control;
 
                        }
                }
                else
                {
                        if(counter == 0)
                        {
                                timecode(9,9) = data(9,9) = control(3,3) = DIN;
                                counter++;
                        }
                        else if(counter == 1)
                        {
                                timecode(8,8) = data(8,8) = control(2,2) = DIN;
                                counter++;
                        }
                        else if(counter == 2)
                        {
                                timecode(0,0) = data(0,0) = control(1,1) = DIN;
                                counter++;
                        }else if(counter == 3)
                        {
                                timecode(1,1) = data(1,1) = control(0,0) = DIN;
 
                                if(control(2,2) == 1)
                                {
                                        control_found = true;
                                        counter = 0;
 
                                        if(last_control_sys(2,0) == 7 && control(2,0) == 4)
                                        {
                                                data_col_store.clear();
 
                                                control_found = true;
                                                NULL_FOUND = true;
                                                FCT_FOUND  = false;
                                                DATA_FOUND = false;
                                                last_char = ESC;
 
                                                data_col_store.push_back("NULL");
                                                data_col_store.push_back(" - ");
                                                data_col_store.push_back(last_control_sys(2,0).to_string(SC_HEX) + control(2,0).to_string());
                                                data_col_store.push_back(" - ");
                                                data_col_store.push_back(sc_time_stamp().to_string());
                                                REC_TX_SPW->storedata(data_col_store);
 
                                                if(counter_fct > 0)
                                                {
                                                        counter_fct = counter_fct -1;
                                                }
 
 
                                        }else if(last_control_sys(2,0) != 7 && control(2,0) == 4)
                                        {
                                                data_col_store.clear();
 
                                                last_char = FCT;
                                                counter_fct++;
 
                                                FCT_FOUND  = true;
                                                NULL_FOUND = false;
                                                DATA_FOUND = false;
 
                                                data_col_store.push_back("FCT");
                                                data_col_store.push_back(" - ");
                                                data_col_store.push_back(last_control_sys(2,0).to_string(SC_HEX) + control(2,0).to_string());
                                                data_col_store.push_back(" - ");
                                                data_col_store.push_back(sc_time_stamp().to_string());
                                                REC_TX_SPW->storedata(data_col_store);
 
                                        }else if(last_control_sys(2,0) != 7 && control(2,0) == 5)
                                        {
                                                data_col_store.clear();
 
                                                last_char = EOP;
                                                data_col_store.push_back("EOP");
 
                                                FCT_FOUND  = false;
                                                NULL_FOUND = false;
                                                DATA_FOUND = true;
 
                                                intermediate_data = data_generated_verilog[data_iteration];
                                                data_col_store.push_back(intermediate_data.to_string(SC_HEX));
 
                                                data_col_store.push_back(last_control_sys(2,0).to_string(SC_HEX) + control(2,0).to_string());
                                                data_col_store.push_back(" ");
                                                COMPARE_SPW->compare_test(&data_col_store);
                                                data_iteration++;
 
                                                data_col_store.push_back(sc_time_stamp().to_string());
                                                REC_TX_SPW->storedata(data_col_store);
 
                                                if(counter_fct > 0)
                                                {
                                                        counter_fct = counter_fct - 1;
                                                }
 
                                                counter_received_data = counter_received_data + 8;
                                        }else if(last_control_sys(2,0) != 7 && control(2,0) == 6)
                                        {
 
                                                data_col_store.clear();
 
                                                last_char = EEP;
 
                                                FCT_FOUND  = false;
                                                NULL_FOUND = false;
                                                DATA_FOUND = true;
 
                                                data_col_store.push_back("EEP");
                                                intermediate_data = data_generated_verilog[data_iteration];
                                                data_col_store.push_back(intermediate_data.to_string(SC_HEX));
 
                                                data_col_store.push_back(last_control_sys(2,0).to_string(SC_HEX) + control(2,0).to_string());
                                                data_col_store.push_back(" ");
                                                COMPARE_SPW->compare_test(&data_col_store);
                                                data_iteration++;
 
                                                data_col_store.push_back(sc_time_stamp().to_string());
                                                REC_TX_SPW->storedata(data_col_store);
 
                                                if(counter_fct > 0)
                                                {
                                                        counter_fct = counter_fct -1;
                                                }
 
                                                counter_received_data = counter_received_data + 8;
                                        }else if((last_control_sys(2,0) == 0 || last_control_sys(2,0) == 6) && control(2,0) == 7)
                                        {
                                                last_char = ESC;
                                                if(counter_fct > 0)
                                                {
                                                        counter_fct = counter_fct -1;
                                                }
                                        }else if(last_control_sys(2,0) == 4 && control(2,0) == 7)
                                        {
                                                last_char = ESC;
                                                if(counter_fct > 0)
                                                {
                                                        counter_fct = counter_fct -1;
                                                }
                                        }else if(last_control_sys(2,0) == 5 && control(2,0) == 7)
                                        {
                                                last_char = ESC;
                                                if(counter_fct > 0)
                                                {
                                                        counter_fct = counter_fct -1;
                                                }
                                        }else
                                        {
                                                data_col_store.clear();
 
                                                invalid_combination = true;
                                                connected = false;
                                                //cout << last_control_sys(2,0) <<  control_sys(2,0) << endl;
                                                data_col_store.push_back("INVALID CONNECTION");
                                                data_col_store.push_back(" - ");
                                                data_col_store.push_back(last_control_sys(2,0).to_string(SC_HEX) + control_sys(2,0).to_string());
                                                data_col_store.push_back(" - ");
                                                data_col_store.push_back(sc_time_stamp().to_string());
                                                REC_TX_SPW->storedata(data_col_store);
                                        }
                                        last_control_sys = control;
 
 
                                }
                                else
                                {
                                        counter++;
                                }
 
                                //cout << control.to_string(SC_HEX) << endl;
                        }else if(counter == 4)
                        {
                                timecode(2,2) = data(2,2) = DIN;
                                counter++;
                        }else if(counter == 5)
                        {
                                timecode(3,3) = data(3,3) = DIN;
                                counter++;
                        }else if(counter == 6)
                        {
                                timecode(4,4) = data(4,4) = DIN;
                                counter++;
                        }else if(counter == 7)
                        {
                                timecode(5,5) = data(5,5) = DIN;
                                counter++;
                        }else if(counter == 8)
                        {
                                timecode(6,6) = data(6,6) = DIN;
                                counter++;
                        }else if(counter == 9)
                        {
                                timecode(7,7) = data(7,7) = DIN;
 
                                if(data(8,8) == 0 && last_control_sys(2,0) != 7)
                                {
                                        data_col_store.clear();
 
                                        data_found = true;
 
                                        FCT_FOUND = false;
                                        NULL_FOUND = false;
                                        DATA_FOUND = true;
                                        //data_store.push_back(data);
                                        last_char = DATA;
 
                                        control_sys = 0;
                                        last_control_sys =0;
 
                                        data_col_store.push_back("DATA");
 
                                        intermediate_data = data_generated_verilog[data_iteration];
                                        data_col_store.push_back(intermediate_data.to_string(SC_HEX));
 
                                        data_col_store.push_back(data(8,0).to_string(SC_HEX));
                                        data_col_store.push_back(" ");
                                        COMPARE_SPW->compare_test(&data_col_store);
 
                                        data_col_store.push_back(sc_time_stamp().to_string());
                                        REC_TX_SPW->storedata(data_col_store);
                                        counter_received_data = counter_received_data + 8;
 
                                        data_iteration++;
                                        last_data = data;
 
                                        if(counter_fct > 0)
                                        {
                                                counter_fct = counter_fct -1;
                                        }
 
 
                                }else if(data(8,8) == 0 && last_control_sys(2,0) == 7)
                                {
                                        FCT_FOUND  = false;
                                        NULL_FOUND = false;
                                        DATA_FOUND = false;
                                        TIMECODE_FOUND = true;
 
                                        time_code_found = true;
                                        timecode_sys = timecode;
                                        time_code_found = false;
 
                                        last_char = TIME_CODE;
                                        control_sys = 0;
                                        last_control_sys =0;
                                        data_col_store.push_back("TIMECODE");
                                        data_col_store.push_back(" - ");
                                        data_col_store.push_back(timecode_sys(7,0).to_string());
                                        data_col_store.push_back(" - ");
                                        data_col_store.push_back(sc_time_stamp().to_string());
                                        REC_TX_SPW->storedata(data_col_store);
                                        last_timecode = timecode_sys;
 
                                        if(counter_fct > 0)
                                        {
                                                counter_fct = counter_fct -1;
                                        }
                                }
                                counter = 0;
                        }
                }
 
        }
 
        SC_CTOR(SPW_RX_SC)
        {
                SC_CTHREAD(gotFCT,CLOCK_SYS.pos());
 
                SC_CTHREAD(UPDATE_FCT,CLOCK_SYS.pos());
 
                SC_METHOD(TIMER_ADTER850);
                sensitive << RX_CLOCK.pos() << RX_CLOCK.neg();
                dont_initialize();
 
                SC_METHOD(TIMER_850COUNTER);
                sensitive << CLOCK_SYS.pos();
                dont_initialize();
 
                SC_METHOD(CalcPARITY);
                sensitive << RX_CLOCK.pos() << RX_CLOCK.neg();
                dont_initialize();
 
                SC_METHOD(RX_RECEIVER);
                sensitive << RX_CLOCK.pos() << RX_CLOCK.neg();
                dont_initialize();
 
                SC_METHOD(RX_GET_SIGNAL);
                sensitive << RX_CLOCK.pos() << RX_CLOCK.neg();
                dont_initialize();
 
        }
};
#endif

Browse

Tools

Subversion Repositories spacewiresystemc

[/] [spacewiresystemc/] [trunk/] [systemC/] [rx_spw.h] - Blame information for rev 29

Line No.	Rev	Author	Line
1	29	redbear	`//+FHDR------------------------------------------------------------------------`
2			`//Copyright (c) 2013 Latin Group American Integhrated Circuit, Inc. All rights reserved`
3			`//GLADIC Open Source RTL`
4			`//-----------------------------------------------------------------------------`
5			`//FILE NAME :`
6			`//DEPARTMENT : IC Design / Verification`
7			`//AUTHOR : Felipe Fernandes da Costa`
8			`//AUTHOR’S EMAIL :`
9			`//-----------------------------------------------------------------------------`
10			`//RELEASE HISTORY`
11			`//VERSION DATE AUTHOR DESCRIPTION`
12			`//1.0 YYYY-MM-DD name`
13			`//-----------------------------------------------------------------------------`
14			`//KEYWORDS : General file searching keywords, leave blank if none.`
15			`//-----------------------------------------------------------------------------`
16			`//PURPOSE : ECSS_E_ST_50_12C_31_july_2008`
17			`//-----------------------------------------------------------------------------`
18			`//PARAMETERS`
19			`//PARAM NAME RANGE : DESCRIPTION : DEFAULT : UNITS`
20			`//e.g.DATA_WIDTH [32,16] : width of the DATA : 32:`
21			`//-----------------------------------------------------------------------------`
22			`//REUSE ISSUES`
23			`//Reset Strategy :`
24			`//Clock Domains :`
25			`//Critical Timing :`
26			`//Test Features :`
27			`//Asynchronous I/F :`
28			`//Scan Methodology :`
29			`//Instantiations :`
30			`//Synthesizable (y/n) :`
31			`//Other :`
32			`//-FHDR------------------------------------------------------------------------`
33
34			`#ifndef SPW_RX_H`
35			`#define SPW_RX_H`
36
37			`#define STATE_RESET 0`
38			`#define STATE_ENABLED 1`
39			`#define STATE_GOT_BIT 2`
40			`#define STATE_GOT_NULL 3`
41
42			`#define ESC 0`
43			`#define FCT 1`
44			`#define EOP 2`
45			`#define EEP 3`
46			`#define DATA 4`
47			`#define TIME_CODE 5`
48
49			`class SPW_RX_SC;`
50
51			`SC_MODULE(SPW_RX_SC)`
52			`{`
53
54			`sc_in<bool> RX_CLOCK;`
55			`sc_in<uint> DIN;`
56			`sc_in<uint> SIN;`
57
58			`sc_in<bool> CLOCK_SYS;`
59
60			`sc_in<bool> ENABLE_RX;`
61			`sc_in<bool> RESET_RX;`
62
63			`sc_out<bool> RX_ERROR;`
64			`sc_out<bool> RX_CREDIT_ERROR;`
65			`sc_out<bool> GOT_BIT;`
66			`sc_out<bool> GOT_NULL;`
67			`sc_out<bool> GOT_NCHAR;`
68			`sc_out<bool> GOT_TIME_CODE;`
69			`sc_out<bool> GOT_FCT;`
70
71			`sc_out<bool> SEND_FCT_NOW_RX;`
72
73			`sc_in<bool> BUFFER_READY;`
74			`sc_out<sc_uint<9> > DATARX_FLAG;`
75			`sc_out<bool> BUFFER_WRITE;`
76
77			`sc_out<sc_uint<8> > TIME_OUT;`
78			`sc_out<bool> TICK_OUT;`
79			`sc_out<bool> CONTROL_FLAG_OUT;`
80
81			`//INTERNAL`
82			`sc_uint<4> state_rx;`
83
84			`sc_uint<4> control;`
85			`sc_uint<10> data;`
86			`sc_uint<10> timecode;`
87
88			`sc_uint<4> control_sys =4;`
89			`sc_uint<4> last_control_sys =4;`
90
91			`sc_uint<10> data_sys;`
92			`sc_uint<10> last_data;`
93
94			`sc_uint<10> timecode_sys;`
95			`sc_uint<10> last_timecode;`
96
97			`sc_signal<bool> tag_found;`
98
99			`unsigned int counter = 0;`
100			`unsigned int counter_fct = 0;`
101			`unsigned int counter_received_data = 0;`
102			`bool enable_bit;`
103			`bool first_time;`
104
105			`bool connected = false;`
106
107			`int cycles=0;`
108
109			`bool control_found;`
110			`bool data_found;`
111			`bool time_code_found;`
112
113
114			`bool NULL_FOUND;`
115			`bool FCT_FOUND;`
116			`bool DATA_FOUND;`
117			`bool TIMECODE_FOUND;`
118
119			`bool control_parity_error;`
120			`bool data_parity_error;`
121			`bool time_code_parity_error;`
122			`bool invalid_combination;`
123
124			`vector<sc_uint<9> > data_store;`
125			`vector<sc_uint<9> > time_code;`
126
127			`unsigned int last_char;`
128
129			`void CalcPARITY()`
130			`{`
131			`control_parity_error = false;`
132			`data_parity_error = false;`
133			`time_code_parity_error = false;`
134			`if(last_char == ESC \|\| last_char == FCT \|\| last_char == EOP \|\| last_char == EEP)`
135			`{`
136			`if(control_found)`
137			`{`
138			`if(!(control_sys[2]^last_control_sys[0]^last_control_sys[1]) != control_sys[3])`
139			`{`
140			`control_parity_error = true;`
141			`}`
142			`}else if(data_found)`
143			`{`
144			`if(!(data_sys[8]^last_control_sys[0]^last_control_sys[1]) != data_sys[9])`
145			`{`
146			`data_parity_error = true;`
147			`}`
148			`}else if(time_code_found)`
149			`{`
150			`if(!(timecode_sys[8]^last_control_sys[0]^last_control_sys[1]) != timecode_sys[9])`
151			`{`
152			`time_code_parity_error = true;`
153			`}`
154			`}`
155			`}else if(last_char == DATA)`
156			`{`
157			`if(control_found)`
158			`{`
159			`if(!(data_sys[8]^last_control_sys[0]^last_control_sys[1]) != data_sys[9])`
160			`{`
161			`control_parity_error = true;`
162			`}`
163			`}else if(data_found)`
164			`{`
165			`if(!(data_sys[8]^last_data[0]^last_data[1]^last_data[2]^last_data[3]^last_data[4]^last_data[5]^last_data[6]^last_data[7]) != data_sys[9])`
166			`{`
167			`data_parity_error = true;`
168			`}`
169			`}else if(time_code_found)`
170			`{`
171			`if(!(data_sys[8]^timecode_sys[0]^timecode_sys[1]^timecode_sys[2]^timecode_sys[3]^timecode_sys[4]^timecode_sys[5]^timecode_sys[6]^timecode_sys[7]) != data_sys[9])`
172			`{`
173			`time_code_parity_error = true;`
174			`}`
175			`}`
176			`}else if(last_char == TIME_CODE)`
177			`{`
178			`if(control_found)`
179			`{`
180			`if(!(timecode_sys[8]^last_control_sys[0]^last_control_sys[1]) != timecode_sys[9])`
181			`{`
182			`control_parity_error = true;`
183			`}`
184			`}/*else if(data_found)`
185			`{`
186			`if(!(timecode[8]^data_sys[0]^data_sys[1]^data_sys[2]^data_sys[3]^data_sys[4])^data_sys[5]^data_sys[6]^data_sys[7] != timecode[9])`
187			`{`
188			`data_parity_error = true;`
189			`}`
190			`}else if(time_code_found)`
191			`{`
192			`if(!(timecode[8]^timecode_sys[0]^timecode_sys[1]^timecode_sys[2]^timecode_sys[3]^timecode_sys[4]^timecode_sys[5]^timecode_sys[6]^timecode_sys[7]) != timecode[9])`
193			`{`
194			`time_code_parity_error = true;`
195			`}`
196			`}*/`
197			`}`
198			`}`
199
200			`void gotFCT()`
201			`{`
202			`while(1)`
203			`{`
204			`if(!ENABLE_RX)`
205			`{`
206			`RX_CREDIT_ERROR = false;`
207			`counter_fct = 1;`
208			`}else`
209			`{`
210			`if(counter_fct*8 > 56)`
211			`{`
212			`RX_CREDIT_ERROR = true;`
213			`wait(1);`
214			`RX_CREDIT_ERROR = false;`
215			`}`
216			`}`
217			`wait(1);`
218			`}`
219			`}`
220
221			`void UPDATE_FCT()`
222			`{`
223			`while(1)`
224			`{`
225			`if(!ENABLE_RX)`
226			`{`
227			`SEND_FCT_NOW_RX = false;`
228			`counter_received_data = 0;`
229			`}else if(counter_received_data >= 64)`
230			`{`
231			`SEND_FCT_NOW_RX = true;`
232			`counter_received_data = 0;`
233			`}else { SEND_FCT_NOW_RX = false;}`
234			`wait(1);`
235			`}`
236			`}`
237
238
239			`void TIMER_ADTER850()`
240			`{`
241			`if(GOT_BIT)`
242			`{`
243			`cycles=0;`
244			`}`
245			`}`
246
247			`void TIMER_850COUNTER()`
248			`{`
249			`if(!ENABLE_RX)`
250			`{`
251			`RX_ERROR = false;`
252			`control_parity_error = false;`
253			`data_parity_error = false;`
254			`time_code_parity_error = false;`
255			`invalid_combination = false;`
256			`cycles = 0;`
257			`}`
258			`else`
259			`{`
260			`//if(GOT_BIT)`
261			`//{`
262			`if(cycles == 43 \|\| control_parity_error \|\| data_parity_error \|\| time_code_parity_error \|\| invalid_combination)`
263			`{`
264			`//RX_ERROR = true;`
265			`#ifdef RX_ERROR_ENABLE`
266			`cout << "ERROR RX ENABLE" << endl;`
267			`cout << control_parity_error << endl;`
268			`cout << data_parity_error << endl;`
269			`cout << time_code_parity_error << endl;`
270			`cout << invalid_combination << endl;`
271			`#endif`
272			`}`
273			`else`
274			`{`
275			`RX_ERROR = false;`
276			`cycles++;`
277			`}`
278			`//}`
279			`}`
280			`}`
281
282
283			`void RX_GET_SIGNAL()`
284			`{`
285
286			`if( NULL_FOUND )`
287			`{`
288			`GOT_NULL = true;`
289			`GOT_FCT = false;`
290			`GOT_NCHAR = false;`
291			`}else if( FCT_FOUND )`
292			`{`
293			`GOT_FCT = true;`
294			`GOT_NULL = false;`
295			`GOT_NCHAR = false;`
296			`}else if( DATA_FOUND )`
297			`{`
298			`GOT_NCHAR = true;`
299			`GOT_FCT = false;`
300			`GOT_NULL = false;`
301			`}else if( TIMECODE_FOUND )`
302			`{`
303			`GOT_TIME_CODE = true;`
304			`GOT_NCHAR = false;`
305			`GOT_FCT = false;`
306			`GOT_NULL = false;`
307			`}`
308
309			`}`
310
311			`void RX_RECEIVER()`
312			`{`
313			`GOT_BIT = true;`
314			`NULL_FOUND = false;`
315			`FCT_FOUND = false;`
316			`DATA_FOUND = false;`
317			`TIMECODE_FOUND = false;`
318			`data_col_store.clear();`
319
320			`if(!connected)`
321			`{`
322			`if(counter == 0)`
323			`{`
324			`timecode(0,0) = data(9,9) = control(3,3) = DIN;`
325			`counter++;`
326			`}`
327			`else if(counter == 1)`
328			`{`
329			`timecode(1,1) = data(8,8) = control(2,2) = DIN;`
330			`counter++;`
331			`}`
332			`else if(counter == 2)`
333			`{`
334			`timecode(2,2) = data(0,0) = control(1,1) = DIN;`
335			`counter++;`
336			`}else if(counter == 3)`
337			`{`
338			`data_col_store.clear();`
339
340			`timecode(3,3) = data(1,1) = control(0,0) = DIN;`
341
342			`counter = 0;`
343
344			`if(last_control_sys(2,0) == 7 && control(2,0) == 4)`
345			`{`
346			`control_found = true;`
347			`NULL_FOUND = true;`
348			`FCT_FOUND = false;`
349			`DATA_FOUND = false;`
350			`last_char = ESC;`
351
352			`data_col_store.push_back("NULL");`
353			`data_col_store.push_back(" - ");`
354			`data_col_store.push_back(last_control_sys(2,0).to_string(SC_HEX) + control(2,0).to_string());`
355			`data_col_store.push_back(" - ");`
356			`data_col_store.push_back(sc_time_stamp().to_string());`
357			`REC_TX_SPW->storedata(data_col_store);`
358
359			`if(counter_fct > 0)`
360			`{`
361			`counter_fct = counter_fct -1;`
362			`}`
363
364
365			`}else if(last_control_sys(2,0) != 7 && control(2,0) == 4)`
366			`{`
367			`last_char = FCT;`
368			`counter_fct++;`
369			`FCT_FOUND = true;`
370			`connected = true;`
371			`NULL_FOUND = false;`
372
373			`data_col_store.push_back("FCT");`
374			`data_col_store.push_back(" - ");`
375			`data_col_store.push_back(last_control_sys(2,0).to_string(SC_HEX) + control(2,0).to_string());`
376			`data_col_store.push_back(" - ");`
377			`data_col_store.push_back(sc_time_stamp().to_string());`
378			`REC_TX_SPW->storedata(data_col_store);`
379
380
381			`}else if(last_control_sys(2,0) == 4 && control(2,0) == 7)`
382			`{`
383			`last_char = ESC;`
384			`if(counter_fct > 0)`
385			`{`
386			`counter_fct = counter_fct -1;`
387			`}`
388			`}else`
389			`{`
390			`invalid_combination = true;`
391			`connected = false;`
392			`//cout << last_control_sys(2,0) << control_sys(2,0) << endl;`
393			`data_col_store.push_back("INVALID CONNECTION");`
394			`data_col_store.push_back(" - ");`
395			`data_col_store.push_back(last_control_sys(2,0).to_string(SC_HEX) + control(2,0).to_string());`
396			`data_col_store.push_back(" - ");`
397			`data_col_store.push_back(sc_time_stamp().to_string());`
398			`REC_TX_SPW->storedata(data_col_store);`
399			`}`
400			`last_control_sys = control;`
401			`//control_sys = control;`
402
403			`}`
404			`}`
405			`else`
406			`{`
407			`if(counter == 0)`
408			`{`
409			`timecode(9,9) = data(9,9) = control(3,3) = DIN;`
410			`counter++;`
411			`}`
412			`else if(counter == 1)`
413			`{`
414			`timecode(8,8) = data(8,8) = control(2,2) = DIN;`
415			`counter++;`
416			`}`
417			`else if(counter == 2)`
418			`{`
419			`timecode(0,0) = data(0,0) = control(1,1) = DIN;`
420			`counter++;`
421			`}else if(counter == 3)`
422			`{`
423			`timecode(1,1) = data(1,1) = control(0,0) = DIN;`
424
425			`if(control(2,2) == 1)`
426			`{`
427			`control_found = true;`
428			`counter = 0;`
429
430			`if(last_control_sys(2,0) == 7 && control(2,0) == 4)`
431			`{`
432			`data_col_store.clear();`
433
434			`control_found = true;`
435			`NULL_FOUND = true;`
436			`FCT_FOUND = false;`
437			`DATA_FOUND = false;`
438			`last_char = ESC;`
439
440			`data_col_store.push_back("NULL");`
441			`data_col_store.push_back(" - ");`
442			`data_col_store.push_back(last_control_sys(2,0).to_string(SC_HEX) + control(2,0).to_string());`
443			`data_col_store.push_back(" - ");`
444			`data_col_store.push_back(sc_time_stamp().to_string());`
445			`REC_TX_SPW->storedata(data_col_store);`
446
447			`if(counter_fct > 0)`
448			`{`
449			`counter_fct = counter_fct -1;`
450			`}`
451
452
453			`}else if(last_control_sys(2,0) != 7 && control(2,0) == 4)`
454			`{`
455			`data_col_store.clear();`
456
457			`last_char = FCT;`
458			`counter_fct++;`
459
460			`FCT_FOUND = true;`
461			`NULL_FOUND = false;`
462			`DATA_FOUND = false;`
463
464			`data_col_store.push_back("FCT");`
465			`data_col_store.push_back(" - ");`
466			`data_col_store.push_back(last_control_sys(2,0).to_string(SC_HEX) + control(2,0).to_string());`
467			`data_col_store.push_back(" - ");`
468			`data_col_store.push_back(sc_time_stamp().to_string());`
469			`REC_TX_SPW->storedata(data_col_store);`
470
471			`}else if(last_control_sys(2,0) != 7 && control(2,0) == 5)`
472			`{`
473			`data_col_store.clear();`
474
475			`last_char = EOP;`
476			`data_col_store.push_back("EOP");`
477
478			`FCT_FOUND = false;`
479			`NULL_FOUND = false;`
480			`DATA_FOUND = true;`
481
482			`intermediate_data = data_generated_verilog[data_iteration];`
483			`data_col_store.push_back(intermediate_data.to_string(SC_HEX));`
484
485			`data_col_store.push_back(last_control_sys(2,0).to_string(SC_HEX) + control(2,0).to_string());`
486			`data_col_store.push_back(" ");`
487			`COMPARE_SPW->compare_test(&data_col_store);`
488			`data_iteration++;`
489
490			`data_col_store.push_back(sc_time_stamp().to_string());`
491			`REC_TX_SPW->storedata(data_col_store);`
492
493			`if(counter_fct > 0)`
494			`{`
495			`counter_fct = counter_fct - 1;`
496			`}`
497
498			`counter_received_data = counter_received_data + 8;`
499			`}else if(last_control_sys(2,0) != 7 && control(2,0) == 6)`
500			`{`
501
502			`data_col_store.clear();`
503
504			`last_char = EEP;`
505
506			`FCT_FOUND = false;`
507			`NULL_FOUND = false;`
508			`DATA_FOUND = true;`
509
510			`data_col_store.push_back("EEP");`
511			`intermediate_data = data_generated_verilog[data_iteration];`
512			`data_col_store.push_back(intermediate_data.to_string(SC_HEX));`
513
514			`data_col_store.push_back(last_control_sys(2,0).to_string(SC_HEX) + control(2,0).to_string());`
515			`data_col_store.push_back(" ");`
516			`COMPARE_SPW->compare_test(&data_col_store);`
517			`data_iteration++;`
518
519			`data_col_store.push_back(sc_time_stamp().to_string());`
520			`REC_TX_SPW->storedata(data_col_store);`
521
522			`if(counter_fct > 0)`
523			`{`
524			`counter_fct = counter_fct -1;`
525			`}`
526
527			`counter_received_data = counter_received_data + 8;`
528			`}else if((last_control_sys(2,0) == 0 \|\| last_control_sys(2,0) == 6) && control(2,0) == 7)`
529			`{`
530			`last_char = ESC;`
531			`if(counter_fct > 0)`
532			`{`
533			`counter_fct = counter_fct -1;`
534			`}`
535			`}else if(last_control_sys(2,0) == 4 && control(2,0) == 7)`
536			`{`
537			`last_char = ESC;`
538			`if(counter_fct > 0)`
539			`{`
540			`counter_fct = counter_fct -1;`
541			`}`
542			`}else if(last_control_sys(2,0) == 5 && control(2,0) == 7)`
543			`{`
544			`last_char = ESC;`
545			`if(counter_fct > 0)`
546			`{`
547			`counter_fct = counter_fct -1;`
548			`}`
549			`}else`
550			`{`
551			`data_col_store.clear();`
552
553			`invalid_combination = true;`
554			`connected = false;`
555			`//cout << last_control_sys(2,0) << control_sys(2,0) << endl;`
556			`data_col_store.push_back("INVALID CONNECTION");`
557			`data_col_store.push_back(" - ");`
558			`data_col_store.push_back(last_control_sys(2,0).to_string(SC_HEX) + control_sys(2,0).to_string());`
559			`data_col_store.push_back(" - ");`
560			`data_col_store.push_back(sc_time_stamp().to_string());`
561			`REC_TX_SPW->storedata(data_col_store);`
562			`}`
563			`last_control_sys = control;`
564
565
566			`}`
567			`else`
568			`{`
569			`counter++;`
570			`}`
571
572			`//cout << control.to_string(SC_HEX) << endl;`
573			`}else if(counter == 4)`
574			`{`
575			`timecode(2,2) = data(2,2) = DIN;`
576			`counter++;`
577			`}else if(counter == 5)`
578			`{`
579			`timecode(3,3) = data(3,3) = DIN;`
580			`counter++;`
581			`}else if(counter == 6)`
582			`{`
583			`timecode(4,4) = data(4,4) = DIN;`
584			`counter++;`
585			`}else if(counter == 7)`
586			`{`
587			`timecode(5,5) = data(5,5) = DIN;`
588			`counter++;`
589			`}else if(counter == 8)`
590			`{`
591			`timecode(6,6) = data(6,6) = DIN;`
592			`counter++;`
593			`}else if(counter == 9)`
594			`{`
595			`timecode(7,7) = data(7,7) = DIN;`
596
597			`if(data(8,8) == 0 && last_control_sys(2,0) != 7)`
598			`{`
599			`data_col_store.clear();`
600
601			`data_found = true;`
602
603			`FCT_FOUND = false;`
604			`NULL_FOUND = false;`
605			`DATA_FOUND = true;`
606			`//data_store.push_back(data);`
607			`last_char = DATA;`
608
609			`control_sys = 0;`
610			`last_control_sys =0;`
611
612			`data_col_store.push_back("DATA");`
613
614			`intermediate_data = data_generated_verilog[data_iteration];`
615			`data_col_store.push_back(intermediate_data.to_string(SC_HEX));`
616
617			`data_col_store.push_back(data(8,0).to_string(SC_HEX));`
618			`data_col_store.push_back(" ");`
619			`COMPARE_SPW->compare_test(&data_col_store);`
620
621			`data_col_store.push_back(sc_time_stamp().to_string());`
622			`REC_TX_SPW->storedata(data_col_store);`
623			`counter_received_data = counter_received_data + 8;`
624
625			`data_iteration++;`
626			`last_data = data;`
627
628			`if(counter_fct > 0)`
629			`{`
630			`counter_fct = counter_fct -1;`
631			`}`
632
633
634			`}else if(data(8,8) == 0 && last_control_sys(2,0) == 7)`
635			`{`
636			`FCT_FOUND = false;`
637			`NULL_FOUND = false;`
638			`DATA_FOUND = false;`
639			`TIMECODE_FOUND = true;`
640
641			`time_code_found = true;`
642			`timecode_sys = timecode;`
643			`time_code_found = false;`
644
645			`last_char = TIME_CODE;`
646			`control_sys = 0;`
647			`last_control_sys =0;`
648			`data_col_store.push_back("TIMECODE");`
649			`data_col_store.push_back(" - ");`
650			`data_col_store.push_back(timecode_sys(7,0).to_string());`
651			`data_col_store.push_back(" - ");`
652			`data_col_store.push_back(sc_time_stamp().to_string());`
653			`REC_TX_SPW->storedata(data_col_store);`
654			`last_timecode = timecode_sys;`
655
656			`if(counter_fct > 0)`
657			`{`
658			`counter_fct = counter_fct -1;`
659			`}`
660			`}`
661			`counter = 0;`
662			`}`
663			`}`
664
665			`}`
666
667			`SC_CTOR(SPW_RX_SC)`
668			`{`
669			`SC_CTHREAD(gotFCT,CLOCK_SYS.pos());`
670
671			`SC_CTHREAD(UPDATE_FCT,CLOCK_SYS.pos());`
672
673			`SC_METHOD(TIMER_ADTER850);`
674			`sensitive << RX_CLOCK.pos() << RX_CLOCK.neg();`
675			`dont_initialize();`
676
677			`SC_METHOD(TIMER_850COUNTER);`
678			`sensitive << CLOCK_SYS.pos();`
679			`dont_initialize();`
680
681			`SC_METHOD(CalcPARITY);`
682			`sensitive << RX_CLOCK.pos() << RX_CLOCK.neg();`
683			`dont_initialize();`
684
685			`SC_METHOD(RX_RECEIVER);`
686			`sensitive << RX_CLOCK.pos() << RX_CLOCK.neg();`
687			`dont_initialize();`
688
689			`SC_METHOD(RX_GET_SIGNAL);`
690			`sensitive << RX_CLOCK.pos() << RX_CLOCK.neg();`
691			`dont_initialize();`
692
693			`}`
694			`};`
695			`#endif`