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

Subversion Repositories spacewiresystemc

[/] [spacewiresystemc/] [trunk/] [systemC/] [tx_spw.h] - Blame information for rev 40

Details | Compare with Previous | View Log


#ifndef SPW_TX_T_H
#define SPW_TX_T_H
 
#define START           0
#define SEND_NULL_START 1
#define SEND_FCT_START  2
#define SEND_NULL       3
#define SEND_FCT        4
#define SEND_NCHAR      5
#define SEND_TIMEC      6
 
#define TYPE_TIMECODE      4
#define TYPE_FCT           5
#define TYPE_NCHAR         6
#define TYPE_EOP_EEP       7
#define TYPE_NULL          8
 
class SPW_TX_SC;
 
SC_MODULE(SPW_TX_SC)
{
        //SIGNALS
        sc_in<bool> CLOCK_TX;
        sc_in<bool> RESET_TX;
 
        sc_in<bool> CLOCK_SYS;
 
        sc_in<bool> TICKIN_TX;
        sc_in<sc_uint<8> > TIMEIN_CONTROL_FLAG_TX;
 
        sc_in<bool> TXWRITE_TX;
        sc_in<sc_uint<9> > TXDATA_FLAGCTRL_TX;
 
        sc_in<bool> SEND_FCT_NOW;
 
        sc_in<bool> ENABLE_TX;
        sc_in<bool> SEND_NULL_TX;
        sc_in<bool> SEND_FCT_TX;
        sc_in<bool> SEND_NCHAR_TX;
        sc_in<bool> SEND_TIME_CODE_TX;
        sc_in<bool> GOTFCT_TX;
 
        sc_out<bool> READY_TX;
        sc_out<bool> READY_TICK;
        sc_out<uint> DOUT;
        sc_out<uint> SOUT;
        sc_out<sc_uint<4> > FSM_TX;
 
        //INTERNAL
        sc_uint<9> TXDATA_FLAGCTRL_TX_AUX;
        sc_uint<9> TXDATA_FLAGCTRL_TX_LAST;
 
        sc_uint<8> LAST_TIMEIN_CONTROL_FLAG_TX;
 
        sc_uint<8> NULL_TOKEN;
        sc_uint<4> FCT_TOKEN;
        sc_uint<9> DATA_TOKEN;
        sc_uint<14> TIMEC_TOKEN;
 
        sc_uint<14> ALL_TOKEN;
 
        sc_uint<4> state_tx;
 
 
        sc_signal<bool> enable_null;
        sc_signal<bool> enable_fct;
        sc_signal<bool> enable_time_code;
        sc_signal<bool> enable_n_char;
 
        bool first_time;
        bool working;
 
        unsigned int last_type;
        unsigned int COUNTER;
        unsigned int counter_first_time;
 
        uint FCT_COUNTER;
 
        uint FCT_SEND = 0;
 
        sc_uint<4> ESC;
        sc_uint<4> EOP;
        sc_uint<4> EEP;
        sc_uint<4> FCT;
 
        sc_uint<8> NULL_S;
        sc_uint<14> TIME_CODE;
 
        uint DOUT_LAST;
        uint SOUT_LAST;
 
        //STATE MACHINE CONTROL
        void TYPE_DATA_STATE()
        {
                //cout << "TYPE_DATA_STATE" << endl;
 
                        if(RESET_TX)
                        {
                                //cout << "RESETED" << " " << RESET_TX << endl;
                                state_tx = START;
                                DOUT_LAST = 0;
                                COUNTER = 0;
                                FCT_COUNTER = 0;
                                counter_first_time = 0;
                                //FCT_SEND = 0;
 
                                last_type = TYPE_NULL;
 
                                first_time       = true;
                                enable_null      = false;
                                enable_fct       = false;
                                enable_time_code = false;
                                enable_n_char    = false;
                        }
                        else
                        {
                                FSM_TX = state_tx;
                                //cout << "STATE TX: " << state_tx << endl;
                                switch(state_tx)
                                {
                                        case START:
 
                                                if(SEND_NULL_TX && ENABLE_TX)
                                                {
                                                        enable_null      = true;
                                                        enable_fct       = false;
                                                        enable_time_code = false;
                                                        enable_n_char    = false;
                                                        state_tx = SEND_NULL_START;
                                                }
                                        break;
                                        case SEND_NULL_START:
 
                                                enable_null      = true;
                                                enable_fct       = false;
                                                enable_time_code = false;
                                                enable_n_char    = false;
 
                                                state_tx = SEND_NULL_START;
                                                last_type = TYPE_NULL;
 
                                                if(SEND_NULL_TX && SEND_FCT_TX && ENABLE_TX && counter_first_time > 0)
                                                {
                                                        if(COUNTER == 7)
                                                        {
                                                                state_tx = SEND_FCT_START;
                                                        }
                                                        //cout << enable_fct << endl;
                                                }
                                        break;
                                        case SEND_FCT_START:
 
                                                enable_null      = false;
                                                enable_fct       = true;
                                                enable_time_code = false;
                                                enable_n_char    = false;
 
                                                if(COUNTER == 3)
                                                        FCT_SEND = FCT_SEND - 1;
 
                                                if(SEND_FCT_TX && FCT_SEND > 0)
                                                {
                                                        state_tx =  SEND_FCT_START;
                                                }
                                                else
                                                {
                                                        if(FCT_SEND == 0)
                                                                state_tx =  SEND_NULL;
                                                }
 
                                                //cout << enable_null << " " << enable_fct << endl;
                                        break;
                                        case SEND_NULL:
 
                                                if(COUNTER == 7)
                                                {
                                                        if(TICKIN_TX)
                                                        {
                                                                state_tx =  SEND_TIMEC;
                                                        }else if(FCT_SEND > 0)
                                                        {
                                                                state_tx =  SEND_FCT;
                                                        }else if(TXWRITE_TX && FCT_COUNTER  > 0)
                                                        {
                                                                state_tx =  SEND_NCHAR;
                                                        }else
                                                        {
                                                                state_tx =  SEND_NULL;
                                                        }
                                                }
                                                else
                                                {
                                                                enable_null      = true;
                                                                enable_fct       = false;
                                                                enable_time_code = false;
                                                                enable_n_char    = false;
                                                }
                                        break;
                                        case SEND_FCT:
                                                if(COUNTER == 3)
                                                {
 
                                                        FCT_SEND = FCT_SEND - 1;
 
                                                        if(TICKIN_TX)
                                                        {
                                                                state_tx =  SEND_TIMEC;
                                                        }else if(FCT_SEND > 0)
                                                        {
                                                                state_tx =  SEND_FCT;
                                                        }else if(TXWRITE_TX && FCT_COUNTER  > 0)
                                                        {
                                                                state_tx =  SEND_NCHAR;
                                                        }else
                                                        {
                                                                state_tx =  SEND_NULL;
                                                        }
                                                }
                                                else
                                                {
                                                        enable_null      = false;
                                                        enable_fct       = true;
                                                        enable_time_code = false;
                                                        enable_n_char    = false;
                                                }
                                        break;
                                        case SEND_NCHAR:
 
                                                if(TXDATA_FLAGCTRL_TX_AUX[8])
                                                {
                                                        if(COUNTER == 3)
                                                        {
                                                                FCT_COUNTER = FCT_COUNTER - 1;
 
                                                                if(TICKIN_TX)
                                                                {
                                                                        state_tx =  SEND_TIMEC;
                                                                }else if(TXWRITE_TX && FCT_COUNTER > 0)
                                                                {
                                                                        state_tx =  SEND_NCHAR;
                                                                }else
                                                                {
                                                                        state_tx =  SEND_NULL;
                                                                }
                                                        }
                                                }
                                                else
                                                {
                                                        if(COUNTER == 9)
                                                        {
                                                                FCT_COUNTER = FCT_COUNTER - 1;
 
                                                                if(TICKIN_TX)
                                                                {
                                                                        state_tx =  SEND_TIMEC;
                                                                }else if(TXWRITE_TX && FCT_COUNTER > 0)
                                                                {
                                                                        state_tx =  SEND_NCHAR;
                                                                }else
                                                                {
                                                                        state_tx =  SEND_NULL;
                                                                }
                                                        }
                                                }
 
                                                enable_null      = false;
                                                enable_fct       = false;
                                                enable_time_code = false;
                                                enable_n_char    = true;
                                        break;
                                        case SEND_TIMEC:
                                                if(COUNTER == 13)
                                                {
                                                        if(TICKIN_TX)
                                                        {
                                                                state_tx =  SEND_TIMEC;
                                                        }else if(FCT_SEND > 0)
                                                        {
                                                                state_tx =  SEND_FCT;
                                                        }else if(TXWRITE_TX && FCT_COUNTER > 0)
                                                        {
                                                                state_tx =  SEND_NCHAR;
                                                        }else
                                                        {
                                                                state_tx =  SEND_NULL;
                                                        }
                                                }
                                                else
                                                {
                                                        enable_null      = false;
                                                        enable_fct       = false;
                                                        enable_time_code = true;
                                                        enable_n_char    = false;
                                                }
                                        break;
                                }
                        }
        }
 
        /*SLOTS OPEN IN OTHER SIDE*/
        void FCT_COUNTER_M()
        {
                if(RESET_TX)
                {
                        FCT_COUNTER = 0;
                }
                else
                {
                         if(SEND_FCT_TX && GOTFCT_TX)
                         {
                                if(FCT_COUNTER < 49)
                                        FCT_COUNTER = FCT_COUNTER + 8;
                                else
                                        FCT_COUNTER = FCT_COUNTER + 7;
                                //cout << "DATA TO SEND" << " " << FCT_COUNTER <<endl;
                         }
                }
        }
 
        /*TAKE  FCT SEND FASE */
        void FCT_COUNTER_SEND()
        {
                        if(RESET_TX)
                                FCT_SEND=7;
                        else
                        {
                                if(SEND_FCT_NOW)
                                {
                                        FCT_SEND = FCT_SEND + 1;
                                        //cout << "DATA RECEIVED" <<endl;
                                }
                        }
        }
 
 
        void PROCESS_DATA()
        {
                if(RESET_TX)
                {
 
                        COUNTER = 0;
 
                        DOUT = 0;
                        SOUT = 0;
 
                        DOUT_LAST = 0;
 
                        NULL_TOKEN[7] = 0;
                        NULL_TOKEN[6] = 0;
                        NULL_TOKEN[5] = 1;
                        NULL_TOKEN[4] = 0;
                        NULL_TOKEN[3] = 1;
                        NULL_TOKEN[2] = 1;
                        NULL_TOKEN[1] = 1;
                        NULL_TOKEN[0] = 0;
 
                        FCT_TOKEN[3] = 0;
                        FCT_TOKEN[2] = 0;
                        FCT_TOKEN[1] = 1;
                        FCT_TOKEN[0] = 0;
 
                        DATA_TOKEN;
 
                        TIMEC_TOKEN[13] = 0;
                        TIMEC_TOKEN[12] = 0;
                        TIMEC_TOKEN[11] = 0;
                        TIMEC_TOKEN[10] = 0;
                        TIMEC_TOKEN[9]  = 0;
                        TIMEC_TOKEN[8]  = 0;
                        TIMEC_TOKEN[7]  = 0;
                        TIMEC_TOKEN[6]  = 0;
                        TIMEC_TOKEN[5]  = 0;
                        TIMEC_TOKEN[4]  = 0;
                        TIMEC_TOKEN[3]  = 1;
                        TIMEC_TOKEN[2]  = 1;
                        TIMEC_TOKEN[1]  = 1;
                        TIMEC_TOKEN[0]  = 0;
 
                }
                else
                {
 
                        READY_TX   = false;
                        READY_TICK = false;
                        EEP_EOP    = false;
 
                        if(SEND_NULL_TX)
                        {
 
                                //if(TXWRITE_TX && COUNTER == 0)
                                        TXDATA_FLAGCTRL_TX_AUX = TXDATA_FLAGCTRL_TX;
                                //else
                                //      TXDATA_FLAGCTRL_TX_AUX = TXDATA_FLAGCTRL_TX_AUX;
 
                                //if(TXWRITE_TX && COUNTER == 5)
                                //      READY_TX = true;                        
 
                                if(enable_null)
                                {
                                        ALL_TOKEN = (0,NULL_TOKEN);
                                }else if(enable_fct)
                                {
                                        ALL_TOKEN = (0,FCT_TOKEN);
                                }else if(enable_time_code)
                                {
                                        ALL_TOKEN = TIMEC_TOKEN;
                                }else if(enable_n_char)
                                {
                                        ALL_TOKEN = (0,TXDATA_FLAGCTRL_TX_AUX.range(7,0),TXDATA_FLAGCTRL_TX_AUX[8],0);
                                }
 
                                if(COUNTER == 0)
                                {
                                        if(last_type == TYPE_NULL || last_type == TYPE_FCT)
                                        {
                                                if(DOUT == !(ALL_TOKEN[1]^0))
                                                {
                                                        SOUT=!SOUT;
                                                }
                                                else
                                                {
                                                        SOUT=SOUT;
                                                }
 
                                                DOUT = !(ALL_TOKEN[1]^0);
 
                                        }else if(last_type == TYPE_NCHAR)
                                        {
 
                                                if(DOUT == !(ALL_TOKEN[1]^TXDATA_FLAGCTRL_TX_LAST[0]^TXDATA_FLAGCTRL_TX_LAST[1]^TXDATA_FLAGCTRL_TX_LAST[2]^TXDATA_FLAGCTRL_TX_LAST[3]^ TXDATA_FLAGCTRL_TX_LAST[4]^TXDATA_FLAGCTRL_TX_LAST[5]^TXDATA_FLAGCTRL_TX_LAST[6]^TXDATA_FLAGCTRL_TX_LAST[7]))
                                                {
                                                        SOUT=!SOUT;
                                                }
                                                else
                                                {
                                                        SOUT=SOUT;
                                                }
 
                                                DOUT = !(ALL_TOKEN[1]^TXDATA_FLAGCTRL_TX_LAST[0]^TXDATA_FLAGCTRL_TX_LAST[1]^TXDATA_FLAGCTRL_TX_LAST[2]^TXDATA_FLAGCTRL_TX_LAST[3]^ TXDATA_FLAGCTRL_TX_LAST[4]^TXDATA_FLAGCTRL_TX_LAST[5]^TXDATA_FLAGCTRL_TX_LAST[6]^TXDATA_FLAGCTRL_TX_LAST[7]);
                                        }
                                        else if(last_type == TYPE_EOP_EEP)
                                        {
 
                                                if(DOUT == !(ALL_TOKEN[1]^1))
                                                {
                                                        SOUT=!SOUT;
                                                }
                                                else
                                                {
                                                        SOUT=SOUT;
                                                }
 
                                                DOUT = !(ALL_TOKEN[1]^1);
                                        }else if(last_type == TYPE_TIMECODE)
                                        {
 
                                                if(DOUT == !(ALL_TOKEN[1]^LAST_TIMEIN_CONTROL_FLAG_TX[7]^LAST_TIMEIN_CONTROL_FLAG_TX[6]^LAST_TIMEIN_CONTROL_FLAG_TX[5]^LAST_TIMEIN_CONTROL_FLAG_TX[4]^LAST_TIMEIN_CONTROL_FLAG_TX[3]^LAST_TIMEIN_CONTROL_FLAG_TX[2]^LAST_TIMEIN_CONTROL_FLAG_TX[1]^LAST_TIMEIN_CONTROL_FLAG_TX[0]))
                                                {
                                                        SOUT=!SOUT;
                                                }
                                                else
                                                {
                                                        SOUT=SOUT;
                                                }
 
                                                DOUT = !(ALL_TOKEN[1]^LAST_TIMEIN_CONTROL_FLAG_TX[7]^LAST_TIMEIN_CONTROL_FLAG_TX[6]^LAST_TIMEIN_CONTROL_FLAG_TX[5]^LAST_TIMEIN_CONTROL_FLAG_TX[4]^LAST_TIMEIN_CONTROL_FLAG_TX[3]^LAST_TIMEIN_CONTROL_FLAG_TX[2]^LAST_TIMEIN_CONTROL_FLAG_TX[1]^LAST_TIMEIN_CONTROL_FLAG_TX[0]);
                                        }
 
                                        COUNTER++;
                                }
                                else
                                {
                                        if(enable_null)
                                        {
                                                if(DOUT == ALL_TOKEN[COUNTER])
                                                {
                                                        SOUT=!SOUT;
                                                }
                                                else
                                                {
                                                        SOUT=SOUT;
                                                }
 
                                                DOUT = ALL_TOKEN[COUNTER];
 
                                                if(COUNTER == 7)
                                                {
                                                        COUNTER = 0;
                                                        last_type = TYPE_NULL;
 
                                                        if(state_tx == SEND_NULL_START)
                                                                counter_first_time = counter_first_time + 1;
                                                }
                                                else
                                                {
                                                        COUNTER++;
                                                }
                                        }else if(enable_fct)
                                        {
 
                                                if(DOUT == ALL_TOKEN[COUNTER])
                                                {
                                                        SOUT=!SOUT;
                                                }
                                                else
                                                {
                                                        SOUT=SOUT;
                                                }
 
                                                DOUT = ALL_TOKEN[COUNTER];
 
                                                if(COUNTER == 3)
                                                {
                                                        COUNTER = 0;
                                                        last_type = TYPE_FCT;
                                                }
                                                else
                                                {
                                                        COUNTER++;
                                                }
                                        }else if(enable_time_code)
                                        {
                                                if(DOUT == ALL_TOKEN[COUNTER])
                                                {
                                                        SOUT=!SOUT;
                                                }
                                                else
                                                {
                                                        SOUT=SOUT;
                                                }
 
                                                DOUT = ALL_TOKEN[COUNTER];
 
                                                if(COUNTER == 13)
                                                {
                                                        COUNTER = 0;
                                                        READY_TICK = true;
                                                        last_type = TYPE_TIMECODE;
                                                        LAST_TIMEIN_CONTROL_FLAG_TX = TIMEIN_CONTROL_FLAG_TX;
                                                }
                                                else
                                                {
                                                        COUNTER++;
                                                }
                                        }else if(enable_n_char)
                                        {
 
                                                if(DOUT == ALL_TOKEN[COUNTER])
                                                {
                                                        SOUT=!SOUT;
                                                }
                                                else
                                                {
                                                        SOUT=SOUT;
                                                }
 
                                                DOUT = ALL_TOKEN[COUNTER];
 
                                                if(TXDATA_FLAGCTRL_TX_AUX[8])
                                                {
                                                        if(COUNTER == 3)
                                                        {
                                                                COUNTER = 0;
                                                                READY_TX = true;
                                                                TXDATA_FLAGCTRL_TX_LAST = TXDATA_FLAGCTRL_TX_AUX;
                                                                last_type = TYPE_EOP_EEP;
                                                        }
                                                        else
                                                        {
                                                                COUNTER++;
                                                        }
                                                }
                                                else
                                                {
                                                        if(COUNTER == 9)
                                                        {
                                                                COUNTER = 0;
                                                                READY_TX = true;
                                                                TXDATA_FLAGCTRL_TX_LAST = TXDATA_FLAGCTRL_TX_AUX;
                                                                last_type = TYPE_NCHAR;
                                                        }
                                                        else
                                                        {
                                                                COUNTER++;
                                                        }
                                                }
                                        }
                                }
                        }
                        else
                        {
                                DOUT = 0;
                                SOUT = 0;
                        }
                }
        }//END METHOD
 
        SC_CTOR(SPW_TX_SC)
        {
                SC_METHOD(FCT_COUNTER_SEND);
                sensitive << CLOCK_SYS.pos();
 
                SC_METHOD(FCT_COUNTER_M);
                sensitive << CLOCK_SYS.pos();
 
                //SC_METHOD(ALL_HERE);
                //sensitive << CLOCK_TX.pos();
 
                SC_METHOD(PROCESS_DATA);
                sensitive << CLOCK_TX.pos();
 
                SC_METHOD(TYPE_DATA_STATE);
                sensitive << CLOCK_TX.pos();
        }
};
#endif

Line No.	Rev	Author	Line
1	29	redbear	`#ifndef SPW_TX_T_H`
2			`#define SPW_TX_T_H`
3
4	40	redbear	`#define START 0`
5			`#define SEND_NULL_START 1`
6			`#define SEND_FCT_START 2`
7			`#define SEND_NULL 3`
8			`#define SEND_FCT 4`
9			`#define SEND_NCHAR 5`
10			`#define SEND_TIMEC 6`
11	29	redbear
12			`#define TYPE_TIMECODE 4`
13			`#define TYPE_FCT 5`
14	40	redbear	`#define TYPE_NCHAR 6`
15			`#define TYPE_EOP_EEP 7`
16			`#define TYPE_NULL 8`
17	29	redbear
18			`class SPW_TX_SC;`
19
20			`SC_MODULE(SPW_TX_SC)`
21			`{`
22			`//SIGNALS`
23			`sc_in<bool> CLOCK_TX;`
24			`sc_in<bool> RESET_TX;`
25
26			`sc_in<bool> CLOCK_SYS;`
27
28			`sc_in<bool> TICKIN_TX;`
29			`sc_in<sc_uint<8> > TIMEIN_CONTROL_FLAG_TX;`
30
31			`sc_in<bool> TXWRITE_TX;`
32			`sc_in<sc_uint<9> > TXDATA_FLAGCTRL_TX;`
33
34			`sc_in<bool> SEND_FCT_NOW;`
35
36			`sc_in<bool> ENABLE_TX;`
37			`sc_in<bool> SEND_NULL_TX;`
38			`sc_in<bool> SEND_FCT_TX;`
39			`sc_in<bool> SEND_NCHAR_TX;`
40			`sc_in<bool> SEND_TIME_CODE_TX;`
41			`sc_in<bool> GOTFCT_TX;`
42
43			`sc_out<bool> READY_TX;`
44			`sc_out<bool> READY_TICK;`
45			`sc_out<uint> DOUT;`
46			`sc_out<uint> SOUT;`
47			`sc_out<sc_uint<4> > FSM_TX;`
48
49			`//INTERNAL`
50			`sc_uint<9> TXDATA_FLAGCTRL_TX_AUX;`
51			`sc_uint<9> TXDATA_FLAGCTRL_TX_LAST;`
52
53			`sc_uint<8> LAST_TIMEIN_CONTROL_FLAG_TX;`
54
55	40	redbear	`sc_uint<8> NULL_TOKEN;`
56			`sc_uint<4> FCT_TOKEN;`
57			`sc_uint<9> DATA_TOKEN;`
58			`sc_uint<14> TIMEC_TOKEN;`
59
60			`sc_uint<14> ALL_TOKEN;`
61
62	29	redbear	`sc_uint<4> state_tx;`
63	40	redbear
64
65			`sc_signal<bool> enable_null;`
66			`sc_signal<bool> enable_fct;`
67			`sc_signal<bool> enable_time_code;`
68			`sc_signal<bool> enable_n_char;`
69
70	29	redbear	`bool first_time;`
71			`bool working;`
72
73			`unsigned int last_type;`
74			`unsigned int COUNTER;`
75			`unsigned int counter_first_time;`
76
77			`uint FCT_COUNTER;`
78
79			`uint FCT_SEND = 0;`
80
81			`sc_uint<4> ESC;`
82			`sc_uint<4> EOP;`
83			`sc_uint<4> EEP;`
84			`sc_uint<4> FCT;`
85
86			`sc_uint<8> NULL_S;`
87			`sc_uint<14> TIME_CODE;`
88
89			`uint DOUT_LAST;`
90			`uint SOUT_LAST;`
91
92			`//STATE MACHINE CONTROL`
93			`void TYPE_DATA_STATE()`
94			`{`
95			`//cout << "TYPE_DATA_STATE" << endl;`
96
97			`if(RESET_TX)`
98			`{`
99			`//cout << "RESETED" << " " << RESET_TX << endl;`
100			`state_tx = START;`
101			`DOUT_LAST = 0;`
102			`COUNTER = 0;`
103			`FCT_COUNTER = 0;`
104			`counter_first_time = 0;`
105			`//FCT_SEND = 0;`
106
107			`last_type = TYPE_NULL;`
108
109			`first_time = true;`
110			`enable_null = false;`
111			`enable_fct = false;`
112			`enable_time_code = false;`
113			`enable_n_char = false;`
114			`}`
115			`else`
116			`{`
117			`FSM_TX = state_tx;`
118			`//cout << "STATE TX: " << state_tx << endl;`
119			`switch(state_tx)`
120			`{`
121			`case START:`
122
123			`if(SEND_NULL_TX && ENABLE_TX)`
124			`{`
125	40	redbear	`enable_null = true;`
126			`enable_fct = false;`
127			`enable_time_code = false;`
128			`enable_n_char = false;`
129			`state_tx = SEND_NULL_START;`
130	29	redbear	`}`
131			`break;`
132	40	redbear	`case SEND_NULL_START:`
133
134			`enable_null = true;`
135			`enable_fct = false;`
136			`enable_time_code = false;`
137			`enable_n_char = false;`
138
139			`state_tx = SEND_NULL_START;`
140	29	redbear	`last_type = TYPE_NULL;`
141	40	redbear
142	29	redbear	`if(SEND_NULL_TX && SEND_FCT_TX && ENABLE_TX && counter_first_time > 0)`
143			`{`
144	40	redbear	`if(COUNTER == 7)`
145			`{`
146			`state_tx = SEND_FCT_START;`
147			`}`
148	29	redbear	`//cout << enable_fct << endl;`
149			`}`
150			`break;`
151	40	redbear	`case SEND_FCT_START:`
152	29	redbear
153	40	redbear	`enable_null = false;`
154			`enable_fct = true;`
155			`enable_time_code = false;`
156			`enable_n_char = false;`
157	29	redbear
158	40	redbear	`if(COUNTER == 3)`
159			`FCT_SEND = FCT_SEND - 1;`
160
161			`if(SEND_FCT_TX && FCT_SEND > 0)`
162	29	redbear	`{`
163	40	redbear	`state_tx = SEND_FCT_START;`
164			`}`
165			`else`
166	29	redbear	`{`
167	40	redbear	`if(FCT_SEND == 0)`
168			`state_tx = SEND_NULL;`
169			`}`
170
171			`//cout << enable_null << " " << enable_fct << endl;`
172			`break;`
173			`case SEND_NULL:`
174
175			`if(COUNTER == 7)`
176	29	redbear	`{`
177	40	redbear	`if(TICKIN_TX)`
178			`{`
179			`state_tx = SEND_TIMEC;`
180			`}else if(FCT_SEND > 0)`
181			`{`
182			`state_tx = SEND_FCT;`
183			`}else if(TXWRITE_TX && FCT_COUNTER > 0)`
184			`{`
185			`state_tx = SEND_NCHAR;`
186			`}else`
187			`{`
188			`state_tx = SEND_NULL;`
189			`}`
190	29	redbear	`}`
191	40	redbear	`else`
192			`{`
193			`enable_null = true;`
194			`enable_fct = false;`
195			`enable_time_code = false;`
196			`enable_n_char = false;`
197			`}`
198	29	redbear	`break;`
199	40	redbear	`case SEND_FCT:`
200			`if(COUNTER == 3)`
201	29	redbear	`{`
202	40	redbear
203			`FCT_SEND = FCT_SEND - 1;`
204
205			`if(TICKIN_TX)`
206			`{`
207			`state_tx = SEND_TIMEC;`
208			`}else if(FCT_SEND > 0)`
209			`{`
210			`state_tx = SEND_FCT;`
211			`}else if(TXWRITE_TX && FCT_COUNTER > 0)`
212			`{`
213			`state_tx = SEND_NCHAR;`
214			`}else`
215			`{`
216			`state_tx = SEND_NULL;`
217			`}`
218			`}`
219			`else`
220	29	redbear	`{`
221	40	redbear	`enable_null = false;`
222			`enable_fct = true;`
223			`enable_time_code = false;`
224			`enable_n_char = false;`
225			`}`
226			`break;`
227			`case SEND_NCHAR:`
228
229			`if(TXDATA_FLAGCTRL_TX_AUX[8])`
230	29	redbear	`{`
231	40	redbear	`if(COUNTER == 3)`
232			`{`
233			`FCT_COUNTER = FCT_COUNTER - 1;`
234
235			`if(TICKIN_TX)`
236			`{`
237			`state_tx = SEND_TIMEC;`
238			`}else if(TXWRITE_TX && FCT_COUNTER > 0)`
239			`{`
240			`state_tx = SEND_NCHAR;`
241			`}else`
242			`{`
243			`state_tx = SEND_NULL;`
244			`}`
245			`}`
246			`}`
247			`else`
248	29	redbear	`{`
249	40	redbear	`if(COUNTER == 9)`
250			`{`
251			`FCT_COUNTER = FCT_COUNTER - 1;`
252
253			`if(TICKIN_TX)`
254			`{`
255			`state_tx = SEND_TIMEC;`
256			`}else if(TXWRITE_TX && FCT_COUNTER > 0)`
257			`{`
258			`state_tx = SEND_NCHAR;`
259			`}else`
260			`{`
261			`state_tx = SEND_NULL;`
262			`}`
263			`}`
264	29	redbear	`}`
265	40	redbear
266			`enable_null = false;`
267			`enable_fct = false;`
268			`enable_time_code = false;`
269			`enable_n_char = true;`
270	29	redbear	`break;`
271	40	redbear	`case SEND_TIMEC:`
272			`if(COUNTER == 13)`
273			`{`
274			`if(TICKIN_TX)`
275			`{`
276			`state_tx = SEND_TIMEC;`
277			`}else if(FCT_SEND > 0)`
278			`{`
279			`state_tx = SEND_FCT;`
280			`}else if(TXWRITE_TX && FCT_COUNTER > 0)`
281			`{`
282			`state_tx = SEND_NCHAR;`
283			`}else`
284			`{`
285			`state_tx = SEND_NULL;`
286			`}`
287			`}`
288			`else`
289			`{`
290			`enable_null = false;`
291			`enable_fct = false;`
292			`enable_time_code = true;`
293			`enable_n_char = false;`
294			`}`
295			`break;`
296	29	redbear	`}`
297			`}`
298			`}`
299
300			`/SLOTS OPEN IN OTHER SIDE/`
301			`void FCT_COUNTER_M()`
302			`{`
303			`if(RESET_TX)`
304			`{`
305			`FCT_COUNTER = 0;`
306			`}`
307			`else`
308			`{`
309			`if(SEND_FCT_TX && GOTFCT_TX)`
310			`{`
311	40	redbear	`if(FCT_COUNTER < 49)`
312			`FCT_COUNTER = FCT_COUNTER + 8;`
313			`else`
314			`FCT_COUNTER = FCT_COUNTER + 7;`
315	29	redbear	`//cout << "DATA TO SEND" << " " << FCT_COUNTER <<endl;`
316			`}`
317			`}`
318			`}`
319
320			`/TAKE FCT SEND FASE /`
321			`void FCT_COUNTER_SEND()`
322			`{`
323			`if(RESET_TX)`
324			`FCT_SEND=7;`
325			`else`
326			`{`
327			`if(SEND_FCT_NOW)`
328			`{`
329			`FCT_SEND = FCT_SEND + 1;`
330			`//cout << "DATA RECEIVED" <<endl;`
331			`}`
332			`}`
333			`}`
334
335	40	redbear
336			`void PROCESS_DATA()`
337	29	redbear	`{`
338			`if(RESET_TX)`
339			`{`
340	40	redbear
341			`COUNTER = 0;`
342
343	29	redbear	`DOUT = 0;`
344			`SOUT = 0;`
345	40	redbear
346			`DOUT_LAST = 0;`
347
348			`NULL_TOKEN[7] = 0;`
349			`NULL_TOKEN[6] = 0;`
350			`NULL_TOKEN[5] = 1;`
351			`NULL_TOKEN[4] = 0;`
352			`NULL_TOKEN[3] = 1;`
353			`NULL_TOKEN[2] = 1;`
354			`NULL_TOKEN[1] = 1;`
355			`NULL_TOKEN[0] = 0;`
356
357			`FCT_TOKEN[3] = 0;`
358			`FCT_TOKEN[2] = 0;`
359			`FCT_TOKEN[1] = 1;`
360			`FCT_TOKEN[0] = 0;`
361
362			`DATA_TOKEN;`
363
364			`TIMEC_TOKEN[13] = 0;`
365			`TIMEC_TOKEN[12] = 0;`
366			`TIMEC_TOKEN[11] = 0;`
367			`TIMEC_TOKEN[10] = 0;`
368			`TIMEC_TOKEN[9] = 0;`
369			`TIMEC_TOKEN[8] = 0;`
370			`TIMEC_TOKEN[7] = 0;`
371			`TIMEC_TOKEN[6] = 0;`
372			`TIMEC_TOKEN[5] = 0;`
373			`TIMEC_TOKEN[4] = 0;`
374			`TIMEC_TOKEN[3] = 1;`
375			`TIMEC_TOKEN[2] = 1;`
376			`TIMEC_TOKEN[1] = 1;`
377			`TIMEC_TOKEN[0] = 0;`
378
379	29	redbear	`}`
380			`else`
381			`{`
382	40	redbear
383	29	redbear	`READY_TX = false;`
384			`READY_TICK = false;`
385			`EEP_EOP = false;`
386	40	redbear
387			`if(SEND_NULL_TX)`
388	29	redbear	`{`
389
390	40	redbear	`//if(TXWRITE_TX && COUNTER == 0)`
391			`TXDATA_FLAGCTRL_TX_AUX = TXDATA_FLAGCTRL_TX;`
392			`//else`
393			`// TXDATA_FLAGCTRL_TX_AUX = TXDATA_FLAGCTRL_TX_AUX;`
394	29	redbear
395	40	redbear	`//if(TXWRITE_TX && COUNTER == 5)`
396			`// READY_TX = true;`
397	29	redbear
398	40	redbear	`if(enable_null)`
399	29	redbear	`{`
400	40	redbear	`ALL_TOKEN = (0,NULL_TOKEN);`
401			`}else if(enable_fct)`
402	29	redbear	`{`
403	40	redbear	`ALL_TOKEN = (0,FCT_TOKEN);`
404			`}else if(enable_time_code)`
405	29	redbear	`{`
406	40	redbear	`ALL_TOKEN = TIMEC_TOKEN;`
407			`}else if(enable_n_char)`
408	29	redbear	`{`
409	40	redbear	`ALL_TOKEN = (0,TXDATA_FLAGCTRL_TX_AUX.range(7,0),TXDATA_FLAGCTRL_TX_AUX[8],0);`
410	29	redbear	`}`
411
412			`if(COUNTER == 0)`
413			`{`
414	40	redbear	`if(last_type == TYPE_NULL \|\| last_type == TYPE_FCT)`
415	29	redbear	`{`
416	40	redbear	`if(DOUT == !(ALL_TOKEN[1]^0))`
417	29	redbear	`{`
418			`SOUT=!SOUT;`
419			`}`
420			`else`
421			`{`
422			`SOUT=SOUT;`
423			`}`
424	40	redbear
425			`DOUT = !(ALL_TOKEN[1]^0);`
426
427			`}else if(last_type == TYPE_NCHAR)`
428	29	redbear	`{`
429	40	redbear
430			`if(DOUT == !(ALL_TOKEN[1]^TXDATA_FLAGCTRL_TX_LAST[0]^TXDATA_FLAGCTRL_TX_LAST[1]^TXDATA_FLAGCTRL_TX_LAST[2]^TXDATA_FLAGCTRL_TX_LAST[3]^ TXDATA_FLAGCTRL_TX_LAST[4]^TXDATA_FLAGCTRL_TX_LAST[5]^TXDATA_FLAGCTRL_TX_LAST[6]^TXDATA_FLAGCTRL_TX_LAST[7]))`
431	29	redbear	`{`
432			`SOUT=!SOUT;`
433			`}`
434			`else`
435			`{`
436			`SOUT=SOUT;`
437			`}`
438	40	redbear
439			`DOUT = !(ALL_TOKEN[1]^TXDATA_FLAGCTRL_TX_LAST[0]^TXDATA_FLAGCTRL_TX_LAST[1]^TXDATA_FLAGCTRL_TX_LAST[2]^TXDATA_FLAGCTRL_TX_LAST[3]^ TXDATA_FLAGCTRL_TX_LAST[4]^TXDATA_FLAGCTRL_TX_LAST[5]^TXDATA_FLAGCTRL_TX_LAST[6]^TXDATA_FLAGCTRL_TX_LAST[7]);`
440	29	redbear	`}`
441	40	redbear	`else if(last_type == TYPE_EOP_EEP)`
442	29	redbear	`{`
443
444	40	redbear	`if(DOUT == !(ALL_TOKEN[1]^1))`
445	29	redbear	`{`
446			`SOUT=!SOUT;`
447			`}`
448			`else`
449			`{`
450			`SOUT=SOUT;`
451			`}`
452	40	redbear
453			`DOUT = !(ALL_TOKEN[1]^1);`
454			`}else if(last_type == TYPE_TIMECODE)`
455	29	redbear	`{`
456	40	redbear
457			`if(DOUT == !(ALL_TOKEN[1]^LAST_TIMEIN_CONTROL_FLAG_TX[7]^LAST_TIMEIN_CONTROL_FLAG_TX[6]^LAST_TIMEIN_CONTROL_FLAG_TX[5]^LAST_TIMEIN_CONTROL_FLAG_TX[4]^LAST_TIMEIN_CONTROL_FLAG_TX[3]^LAST_TIMEIN_CONTROL_FLAG_TX[2]^LAST_TIMEIN_CONTROL_FLAG_TX[1]^LAST_TIMEIN_CONTROL_FLAG_TX[0]))`
458	29	redbear	`{`
459			`SOUT=!SOUT;`
460			`}`
461			`else`
462			`{`
463			`SOUT=SOUT;`
464			`}`
465
466	40	redbear	`DOUT = !(ALL_TOKEN[1]^LAST_TIMEIN_CONTROL_FLAG_TX[7]^LAST_TIMEIN_CONTROL_FLAG_TX[6]^LAST_TIMEIN_CONTROL_FLAG_TX[5]^LAST_TIMEIN_CONTROL_FLAG_TX[4]^LAST_TIMEIN_CONTROL_FLAG_TX[3]^LAST_TIMEIN_CONTROL_FLAG_TX[2]^LAST_TIMEIN_CONTROL_FLAG_TX[1]^LAST_TIMEIN_CONTROL_FLAG_TX[0]);`
467	29	redbear	`}`
468
469	40	redbear	`COUNTER++;`
470	29	redbear	`}`
471	40	redbear	`else`
472	29	redbear	`{`
473	40	redbear	`if(enable_null)`
474	29	redbear	`{`
475	40	redbear	`if(DOUT == ALL_TOKEN[COUNTER])`
476	29	redbear	`{`
477			`SOUT=!SOUT;`
478			`}`
479			`else`
480			`{`
481			`SOUT=SOUT;`
482			`}`
483	40	redbear
484			`DOUT = ALL_TOKEN[COUNTER];`
485
486			`if(COUNTER == 7)`
487	29	redbear	`{`
488	40	redbear	`COUNTER = 0;`
489			`last_type = TYPE_NULL;`
490
491			`if(state_tx == SEND_NULL_START)`
492			`counter_first_time = counter_first_time + 1;`
493	29	redbear	`}`
494			`else`
495			`{`
496	40	redbear	`COUNTER++;`
497	29	redbear	`}`
498	40	redbear	`}else if(enable_fct)`
499	29	redbear	`{`
500	40	redbear

Browse

Tools

Subversion Repositories spacewiresystemc

[/] [spacewiresystemc/] [trunk/] [systemC/] [tx_spw.h] - Blame information for rev 40