source: firmware/FAD/FACT_FAD_20MHz_VAR_PS/FACT_FAD_lib/hdl/w5300_modul.vhd @ 11173

Last change on this file since 11173 was 11173, checked in by neise, 8 years ago
this is v0206 --- v0205 had a bug: when sending 'enable busy' this was not even parsed in firmware. now enable/disable busy is being parsed. NEW BASE PORT = 31919 (this ist 0x7CAF :-)
File size: 54.0 KB
Line 
1-- Module Name:    w5300_modul - Behavioral
2library IEEE;
3use IEEE.STD_LOGIC_1164.ALL;
4use IEEE.STD_LOGIC_ARITH.ALL;
5use IEEE.STD_LOGIC_UNSIGNED.ALL;
6library FACT_FAD_lib;
7use FACT_FAD_lib.fad_definitions.ALL;
8
9ENTITY w5300_modul IS
10  generic(
11    RAM_ADDR_WIDTH : integer := 14
12  );
13   PORT( 
14      state          : OUT    std_logic_vector (7 DOWNTO 0);  -- state is encoded here ... useful for debugging.
15          debug_data_ram_empty : OUT    std_logic;
16          debug_data_valid : OUT    std_logic;
17          data_generator_idle_i : IN std_logic;
18          socket_tx_free_out : out std_logic_vector (16 DOWNTO 0);  -- 17bit value .. that's true
19     
20      clk            : IN     std_logic;
21      wiz_reset      : OUT    std_logic                     := '1';
22      addr           : OUT    std_logic_vector (9 DOWNTO 0);
23      data           : INOUT  std_logic_vector (15 DOWNTO 0);
24      cs             : OUT    std_logic                     := '1';
25      wr             : OUT    std_logic                     := '1';
26      led            : OUT    std_logic_vector (7 DOWNTO 0) := (OTHERS => '0');
27      rd             : OUT    std_logic                     := '1';
28      int            : IN     std_logic;
29      write_length   : IN     std_logic_vector (16 DOWNTO 0);
30      ram_start_addr : IN     std_logic_vector (RAM_ADDR_WIDTH-1 DOWNTO 0);
31      ram_data       : IN     std_logic_vector (15 DOWNTO 0);
32      ram_addr       : OUT    std_logic_vector (RAM_ADDR_WIDTH-1 DOWNTO 0);
33      data_valid     : IN     std_logic;
34      data_valid_ack : OUT    std_logic := '0';
35      busy           : OUT    std_logic                     := '1';
36      write_header_flag, write_end_flag : IN std_logic;
37      fifo_channels : IN std_logic_vector (3 downto 0);
38      -- softtrigger:
39      s_trigger : OUT std_logic := '0';
40      c_trigger_enable: out std_logic := '0';
41      c_trigger_mult: out std_logic_vector (15 DOWNTO 0) := conv_std_logic_vector(0 ,16); --subject to changes
42     
43     
44
45          -- FAD configuration signals:
46          ------------------------------------------------------------------------------
47                memory_manager_config_start_o   : out std_logic := '0';
48                memory_manager_config_valid_i   : in std_logic;
49               
50                spi_interface_config_start_o    : out std_logic := '0';
51                spi_interface_config_valid_i    : in std_logic;
52               
53                --data_generator_config_start_o : out std_logic := '0';
54                --data_generator_config_valid_i : in std_logic;
55               
56                dac_setting                                             : out dac_array_type := DEFAULT_DAC;            --<<-- default defined in fad_definitions.vhd
57                roi_setting                                             : out roi_array_type := DEFAULT_ROI;            --<<-- default defined in fad_definitions.vhd
58               
59                runnumber                                               : out std_logic_vector (31 DOWNTO 0) := conv_std_logic_vector(0 ,32); 
60                reset_trigger_id                                : out std_logic := '0';
61
62                data_ram_empty                                  : IN std_logic;
63               
64          ------------------------------------------------------------------------------
65     
66          -- MAC/IP calculation signals:
67          ------------------------------------------------------------------------------
68      MAC_jumper : in std_logic_vector (1 downto 0);
69      BoardID : in std_logic_vector (3 downto 0);
70      CrateID : in std_logic_vector (1 downto 0);
71          ------------------------------------------------------------------------------
72     
73          -- user controllable enable signals
74          ------------------------------------------------------------------------------
75          trigger_enable : out std_logic; 
76         
77      denable : out std_logic := '0'; -- default domino wave on. ... in case if REFCLK error ... REFCLK counter will override.
78      dwrite_enable : out std_logic := '1'; -- default DWRITE low.
79      sclk_enable : out std_logic := '1'; -- default DWRITE HIGH.
80      srclk_enable : out std_logic := '1'; -- default SRCLK on.
81      busy_enable : out std_logic := '1';
82          socket_send_mode_out : out std_logic;
83          ------------------------------------------------------------------------------
84         
85          -- ADC CLK generator, is able to shift phase with respect to X_50M
86          -- these signals control the behavior of the digital clock manager (DCM)
87          ------------------------------------------------------------------------------
88          ps_direction : out std_logic := '1'; -- default phase shift upwards
89      ps_do_phase_shift : out std_logic := '0'; --pulse this to phase shift once
90      ps_reset : out std_logic := '0'; -- pulse this to reset the variable phase shift
91      ps_ready : in std_logic;
92      ------------------------------------------------------------------------------
93         
94          -- signals used to control FAD LED bahavior:
95          -- one of the three LEDs is used for com-status info
96          ------------------------------------------------------------------------------
97      socks_waiting : out std_logic;
98      socks_connected: out std_logic
99          ------------------------------------------------------------------------------
100       
101       
102         
103   );
104END w5300_modul ;
105
106architecture Behavioral of w5300_modul is 
107
108type state_init_type is (
109        INTERRUPT, RESET, WRITE_REG, READ_REG, WRITE_DATA,
110        INIT, LOCATE, IM, MT, STX, STX1, STX2, STX3, SRX, SRX1, SRX2, SRX3, MAC, MAC1, MAC2, GW, GW1, SNM, SNM1, IP, IP1, 
111        TIMEOUT, 
112        --RETRY,
113        SI, SI1, SI1b, SI2, SI3, SI4, SI5, SI6, ESTABLISH, EST1, 
114       
115        CONFIG, WAIT_100NS, WAIT_UNTIL_DG_IDLE, 
116        CONFIG_MEMORY_MANAGER, WAIT_FOR_CONFIG_MEMORY_MANAGER,
117        CONFIG_DATA_GENERATOR, WAIT_FOR_CONFIG_DATA_GENERATOR,
118        CONFIG_DAC_ONLY, WAIT_FOR_CONFIG_DAC_ONLY,
119       
120        MAIN, MAIN1, MAIN2, MAIN3, CHK_RECEIVED, READ_DATA
121);
122type state_write_type is (
123        WR_START, 
124        WR_GET_EVT_ID_WAIT1, WR_GET_EVT_ID1, WR_GET_EVT_ID_WAIT2, WR_GET_EVT_ID2,
125        WR_MOD7_STARTED, WR_WAIT_FOR_MOD7,
126        WR_CHECK_FOR_FIFO_SPACE_01, WR_CHECK_FOR_FIFO_SPACE_02, WR_CHECK_FOR_FIFO_SPACE_03, WR_CHECK_FOR_FIFO_SPACE_04, 
127        WR_05, WR_05_PREPARE_LENGTH_INFO, WR_05_POSTPREPARE_LENGTH_INFO,
128        WORKAROUND_CHECK_FIFO_SPACE_01, WORKAROUND_CHECK_FIFO_SPACE_02, WORKAROUND_CHECK_FIFO_SPACE_03, WORKAROUND_CHECK_FIFO_SPACE_04,
129        WR_05a, WR_05b, WR_06, 
130        WAIT_BEFORE_SEND,    -- new state for serializing the 'send'
131        WR_07, 
132        WR_ACK, WR_WAIT_FOR_ACK, WAIT_FOR_DATA_VALID_HIGH_AGAIN,
133        WR_FIFO, WR_FIFO1, WR_ADC, WR_ADC1, WR_ADC2,
134        WR_ENDFLAG, WR_ENDFLAG1, WR_ENDFLAG2, WR_ENDFLAG3
135); 
136type state_interrupt_1_type is (IR1_01, IR1_02, IR1_03, IR1_04);
137type state_interrupt_2_type is (
138        IR2_01, IR2_02, IR2_03, IR2_04, IR2_05, 
139        IR2_CHECK_SOCKET_STATE, IR2_WAIT_FOR_SOCKETS_IN_CLOSED_STATE,
140        IR2_06);
141
142type state_read_data_type is (
143        RD_1, 
144        RD_2, 
145        RD_3, 
146        RD_4, 
147        RD_5,
148        WAIT_FOR_TRIGGER_ID_RESET_1, WAIT_FOR_TRIGGER_ID_RESET_2,
149        RD_6,
150        READ_COMMAND_DATA_SECTION,
151        PUT_COMMAND_DATA_SECTION,
152        EXECUTE,
153        RD_END
154);
155
156signal RST_TIME : std_logic_vector(19 downto 0) := X"7A120";
157
158signal par_addr : std_logic_vector (9 downto 0) := (OTHERS => '0');
159signal par_data : std_logic_vector (15 downto 0) := (OTHERS => '0');
160signal data_read : std_logic_vector (15 downto 0) := (OTHERS => '0');
161signal adc_data_addr : std_logic_vector (RAM_ADDR_WIDTH-1 DOWNTO 0);
162
163signal state_init, next_state , next_state_tmp : state_init_type := RESET;
164signal state_after_config : state_init_type := MAIN;
165signal count : std_logic_vector (2 downto 0) := "000";
166signal state_write : state_write_type := WR_START;
167signal state_interrupt_1 : state_interrupt_1_type := IR1_01;
168signal state_interrupt_2 : state_interrupt_2_type := IR2_01;
169signal state_read_data : state_read_data_type := RD_1;
170
171signal interrupt_ignore : std_logic := '1';
172signal int_flag : std_logic := '0';
173signal ram_access : std_logic := '0';
174
175signal zaehler : std_logic_vector (19 downto 0) := (OTHERS => '0');
176signal data_cnt : integer := 0;
177signal drs_cnt : integer :=0;
178signal channel_cnt : integer range 0 to 9 :=0;
179signal socket_cnt : std_logic_vector (2 downto 0) := "000";
180signal roi_max : std_logic_vector (10 downto 0);
181signal data_end : integer := 0;
182
183signal socket_tx_free : std_logic_vector (16 downto 0) := (others => '0');
184signal write_length_bytes : std_logic_vector (16 downto 0);
185
186signal socket_rx_received : std_logic_vector (16 downto 0) := (others => '0');
187signal chk_recv_cntr : integer range 0 to 10000 := 0;
188
189-- --
190signal wait_cntr : integer range 0 to 10000 := 0;
191-- --
192
193signal rx_packets_cnt : std_logic_vector (15 downto 0);
194
195signal update_of_rois : std_logic := '1';
196signal update_of_lessimportant : std_logic := '1';
197
198
199signal trigger_enable_sig : std_logic := '0';
200signal trigger_enable_storage_sig : std_logic;
201
202signal local_write_length   : std_logic_vector (16 DOWNTO 0);
203signal local_ram_start_addr : std_logic_vector (RAM_ADDR_WIDTH-1 DOWNTO 0);
204signal local_ram_addr       : std_logic_vector (RAM_ADDR_WIDTH-1 downto 0);
205signal local_socket_nr      : std_logic_vector (2 DOWNTO 0);
206signal local_write_header_flag, local_write_end_flag : std_logic;
207signal local_fifo_channels : std_logic_vector (3 downto 0);
208
209signal wait_100ns_sig : std_logic_vector (5 downto 0) := "000000";
210
211signal config_addr : integer range 0 to 47;
212type config_data_type is array (0 to 47) of std_logic_vector(15 downto 0); 
213signal config_setting : config_data_type := (
214--              X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A",                --<<-- ROIs = 10 TESTING ONLY
215--              X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A",                --<<-- ROIs = 10 TESTING ONLY
216--              X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A",                --<<-- ROIs = 10 TESTING ONLY
217--              X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A",                --<<-- ROIs = 10 TESTING ONLY
218
219                X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400",                --<<-- ROIs = 1024
220                X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400",                --<<-- ROIs = 1024
221                X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400",                --<<-- ROIs = 1024
222                X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400",                --<<-- ROIs = 1024
223
224                X"61A8", X"0000", X"0000", X"0000", X"7080", X"7080", X"7080", X"7080",                                  --<<-- DACs
225                X"0000",
226                X"0000", X"0000",  -- MSword // LSword
227                X"0000"                                         -- this is a dummy address; this address is used only, if the user sent an invalid address within a WRITE command
228                );
229               
230               
231
232-- signals used for MAC/IP calculation:
233-- these 2 synch in, the jumper state.
234signal FAD_in_cam : std_logic := '0';
235signal FAD_at_ETHZ : std_logic := '0';
236-- these 2 synch in the FMP lines encoding the FAD position in the cam.
237signal bid : std_logic_vector (3 downto 0);
238signal cid : std_logic_vector (1 downto 0);
239
240-- for 'send'-serialization
241signal FADid : integer range 0 to 39 := 0;    -- 39 = number of FADs in camera minus 1
242constant MICROSEC_TO_WAIT_BEFORE_SEND : integer := 25;
243signal wait_before_send_counter : integer range 0 to 50*39*MICROSEC_TO_WAIT_BEFORE_SEND := 0;
244signal wait_before_send_counter_goal : integer range 0 to 50*39*MICROSEC_TO_WAIT_BEFORE_SEND := 0;
245
246-- these are just used as local variables, to make reading easier.
247signal mac_loc : mac_type;
248signal ip_loc : ip_type;
249signal gateway_loc : ip_type;
250signal netmask_loc : ip_type;
251
252        -- signals for synching in asynchronous input signals
253                ------------------------------------------------------------------------------
254                signal w5300_interrupt_sr : std_logic_vector(1 downto 0) := "11";
255                 --?? not sure if this init value is good
256                 -- but should be no problem, because interrupt_ignore is not true during the first 2 clock cycles.
257                 -- I hope!
258                signal data_valid_sr : std_logic_vector(1 downto 0) := "00"; 
259                ------------------------------------------------------------------------------
260                -- synch in CONFIG inputs
261                signal memory_manager_config_valid_i_sr         : std_logic_vector(1 downto 0) := "00";
262                signal spi_interface_config_valid_i_sr          : std_logic_vector(1 downto 0) := "00";
263                --signal data_generator_config_valid_i_sr               : std_logic_vector(1 downto 0) := "00";
264                signal data_ram_empty_sr                                        : std_logic_vector(1 downto 0) := (OTHERS => '0');
265
266
267                signal data_generator_idle_sr : std_logic_vector(2 downto 0) := "000";
268
269-- only for debugging
270--signal error_cnt : std_logic_vector (7 downto 0) := (others => '0');
271--signal last_trigger_id : std_logic_vector (15 downto 0) := (others => '0');
272signal DG_run_mode_temp_storage_signal : std_logic;
273signal data_generator_run_mode_signal : std_logic := '1'; -- default triggers will be accepted
274-- signals for different socket modes: DN 04.01.11
275signal socket_send_mode : std_logic := '0'; -- if 0 data is send via socket 0; if 1 data is send via the other sockets.
276-- signals for Sockek Number calculation
277signal event_number : std_logic_vector(31 downto 0);
278signal mod7_start : std_logic := '0';
279signal mod7_started : std_logic;
280signal mod7_valid : std_logic;
281signal mod7_result : std_logic_vector(2 downto 0);
282
283
284signal state_sig : std_logic_vector(7 downto 0) := X"FF";
285
286signal number_of_words_written_to_fifo :  std_logic_vector(15 downto 0) := (others => '0');
287signal number_of_bytes_written_to_fifo :  std_logic_vector(16 downto 0) := (others => '0');
288
289
290
291signal wait_for_sockets_closed_counter_overflow : std_logic := '0';
292signal wait_for_sockets_closed_counter_enable : std_logic := '0';
293signal wfscc_1 : integer range 0 to 50000 := 0;
294signal wfscc_2 : integer range 0 to 20000 := 0;
295
296
297
298COMPONENT mod7
299         PORT (
300                        clk       : IN     std_logic;
301                        number    : IN     std_logic_vector (31 DOWNTO 0);
302                        start     : IN     std_logic;
303                        remainder : OUT    std_logic_vector (2 DOWNTO 0) := (others => '0');
304                        started   : OUT    std_logic                     := '0';
305                        valid     : OUT    std_logic                     := '0'
306         );
307         END COMPONENT;
308
309
310
311begin
312       
313        mod7_calculator : mod7
314        PORT MAP (
315                --locals => actuals
316                clk                     =>clk   ,
317                number          =>event_number  ,
318                start           =>mod7_start    ,
319                remainder       =>mod7_result   ,
320                started         =>mod7_started  ,
321                valid           =>mod7_valid
322        );
323
324
325  --synthesis translate_off
326  RST_TIME <= X"00120";
327  --synthesis translate_on
328 
329  -- concurrent statemnets
330 
331-- output config settings as DAC and ROI arrays.
332state <= state_sig;
333
334debug_data_valid <= interrupt_ignore;
335--debug_data_ram_empty <= data_ram_empty_sr(1);
336--debug_data_valid <= data_valid_sr(1);
337roi_mapping : for i in 0 to 35 generate
338        roi_setting(i) <= conv_integer(config_setting(i)) when (conv_integer(config_setting(i)) < 1025) else 1024;
339end generate roi_mapping;
340dac_mapping : for i in 0 to 7 generate
341        dac_setting(i) <= conv_integer(config_setting(i+36));
342end generate dac_mapping;
343c_trigger_mult <= config_setting(44);
344
345
346
347trigger_enable <= trigger_enable_sig;
348
349socket_send_mode_out <= socket_send_mode;
350
351        w5300_proc : process (clk)
352        begin
353                if rising_edge (clk) then
354                --socket_tx_free_out <= socket_tx_free;
355               
356               
357                -- synch asynchronous inputs in:
358                memory_manager_config_valid_i_sr        <= memory_manager_config_valid_i_sr(0)  & memory_manager_config_valid_i;
359                spi_interface_config_valid_i_sr         <= spi_interface_config_valid_i_sr(0)   & spi_interface_config_valid_i;
360                --data_generator_config_valid_i_sr      <=      data_generator_config_valid_i_sr(0)     & data_generator_config_valid_i;
361                data_ram_empty_sr                                       <= data_ram_empty_sr(0)                 & data_ram_empty;               
362                data_generator_idle_sr                          <= data_generator_idle_sr( 1 downto 0 ) & data_generator_idle_i;
363               
364                w5300_interrupt_sr <= w5300_interrupt_sr(0) & int;
365                data_valid_sr <= data_valid_sr(0) & data_valid;
366               
367                        -- interrupt is handled synchronously
368                        -- W5300 pulls low its interrpt line in case of:
369                        --      When Sockets time out and
370                        -- When sockets receive disconnection request.
371                       
372                        if (w5300_interrupt_sr(1) = '0') and (interrupt_ignore = '0') then
373                                case state_interrupt_1 is
374                                        when IR1_01 =>
375                                        state_sig <= X"FF";
376                                                int_flag <= '1';
377                                                busy <= '1';
378                                                state_interrupt_1 <= IR1_02;  --wait one cycle
379                                        when IR1_02 =>
380                                        state_sig <= X"FE";
381                                                state_interrupt_1 <= IR1_03;
382                                        when IR1_03 =>
383                                        state_sig <= X"FD";
384                                                state_init <= INTERRUPT;
385                                                socket_cnt <= "000";
386                                                ram_access <= '0';
387                                                zaehler <= X"00000";    --what is this zaehler counting?
388                                                count <= "000";                 --what is this count counting?
389                                                int_flag <= '0';
390                                                interrupt_ignore <= '1';
391                                                state_interrupt_1 <= IR1_04;  --this state is not existing? bad coding habit???
392                                        when others =>
393                                                state_sig <= X"FC";
394                                                null;
395                                end case;
396                        end if; -- int = '0'
397                       
398                        if int_flag = '0' then
399                                case state_init is
400                                        -- Interrupt
401                                        when INTERRUPT =>
402                                                case state_interrupt_2 is
403                                                        when IR2_01 =>
404                                                        state_sig <= X"FB";
405                                                                par_addr <= W5300_IR;
406                                                                state_init <= READ_REG;
407                                                                next_state <= INTERRUPT;
408                                                                state_interrupt_2 <= IR2_02;
409                                                               
410                                                        -- check if it was a Sx Interrupt of Socket n
411                                                        -- therfor: loop over all channel.
412                                                        -- if the loop ended but no Sx Interrupt was found --> IR2_06
413                                                        -- if an Sx Interrupt was found go to --> IR2_03 and check what happened.
414                                                        when IR2_02 => 
415                                                        state_sig <= X"FA";
416                                                                if (data_read (conv_integer(socket_cnt)) = '1') then -- Sx Interrupt
417                                                                        state_interrupt_2 <= IR2_03;
418                                                                else
419                                                                        socket_cnt <= socket_cnt + 1;
420                                                                        if (socket_cnt = 7) then
421                                                                                state_interrupt_2 <= IR2_05;
422                                                                        else
423                                                                                state_interrupt_2 <= IR2_02;  -- go on with loop
424                                                                        end if; 
425                                                                end if;
426                                                               
427                                                        -- check the Interrupt register of the Socket, which caused the Interrupt.
428                                                        when IR2_03 =>
429                                                        state_sig <= X"F9";
430                                                                par_addr <= W5300_S0_IR + socket_cnt * W5300_S_INC; -- Sx Interrupt Register
431                                                                state_init <= READ_REG;
432                                                                next_state <= INTERRUPT;
433                                                                state_interrupt_2 <= IR2_04;
434                                                        -- before checking what happened, clear the Interrupt register, so we can proceed.
435                                                        when IR2_04 =>
436                                                        state_sig <= X"F8";
437                                                                par_addr <= W5300_S0_IR + socket_cnt * W5300_S_INC;
438                                                                par_data <= data_read; -- clear Interrupts
439                                                                state_init <= WRITE_REG;
440                                                                next_state <= INTERRUPT;
441                                                                state_interrupt_2 <= IR2_05;
442                                                        -- send the command to close this socket
443                                                        -- then go back and read the main Interrupt register again,
444                                                        -- if this was not Socket 7 ... if it was Socket 7, we're done anyway.
445                                                        when IR2_05 =>
446                                                                state_sig <= X"F7";
447                                                                par_addr <= W5300_S0_CR + socket_cnt * W5300_S_INC;
448                                                                --par_data <= X"0010"; -- CLOSE
449                                                                par_data <= X"0008"; -- DISCON
450                                                                state_init <= WRITE_REG;
451                                                                next_state <= INTERRUPT;
452                                                                socket_cnt <= socket_cnt + 1;
453                                                                if (socket_cnt = 7) then
454                                                                        socket_cnt <= "000";
455                                                                        --state_interrupt_2 <= IR2_06;
456                                                                        state_interrupt_2 <= IR2_CHECK_SOCKET_STATE;
457                                                                else
458                                                                  state_interrupt_2 <= IR2_01;
459                                                                end if; 
460
461                                                        when IR2_CHECK_SOCKET_STATE =>
462                                                                wait_for_sockets_closed_counter_enable <= '1';
463                                                               
464                                                                par_addr <= W5300_S0_SSR + socket_cnt * W5300_S_INC; -- READ Socket Status Register
465                                                                state_init <= READ_REG;
466                                                                next_state <= INTERRUPT;
467                                                                state_interrupt_2 <= IR2_WAIT_FOR_SOCKETS_IN_CLOSED_STATE;
468                                                       
469                                                        when IR2_WAIT_FOR_SOCKETS_IN_CLOSED_STATE =>
470                                                                if ( wait_for_sockets_closed_counter_overflow = '1') then
471                                                                        wait_for_sockets_closed_counter_enable <= '0';
472                                                                        socket_cnt <= "000";
473                                                                        state_interrupt_2 <= IR2_06;
474                                                                else 
475                                                                        if ( data_read(7 downto 0) = SOCKET_CLOSED ) then
476                                                                                if ( socket_cnt = 7 ) then 
477                                                                                        socket_cnt <= "000";
478                                                                                        state_interrupt_2 <= IR2_06;
479                                                                                else
480                                                                                        socket_cnt <= socket_cnt + 1;
481                                                                                        state_interrupt_2 <= IR2_CHECK_SOCKET_STATE;
482                                                                                end if;
483                                                                        else 
484                                                                                state_interrupt_2 <= IR2_CHECK_SOCKET_STATE;
485                                                                        end if;
486                                                                end if;
487                                                               
488                                                               
489                                                               
490                                                               
491                                                               
492                                                        -- we go on and reset, the W5300 and this entire state machine.
493                                                        when IR2_06 =>
494                                                        state_sig <= X"F6";
495                                                                state_interrupt_1 <= IR1_01;
496                                                                state_interrupt_2 <= IR2_01;
497                                                                socket_cnt <= "000";
498                                                                state_init <= RESET;
499                                                        when others =>
500                                                                state_interrupt_1 <= IR1_01;
501                                                                state_interrupt_2 <= IR2_01;
502                                                                socket_cnt <= "000";
503                                                                state_init <= RESET;
504                                                end case;
505                                               
506                                        -- reset W5300
507                                        when RESET =>
508                                          state_sig <= X"01";
509                                                socket_send_mode <= '0';
510                                                busy <= '1';
511                                                zaehler <= zaehler + 1;
512                                                socks_waiting <= '0';
513                                                socks_connected <= '0';
514                                                wiz_reset <= '0';
515                                                --led <= X"FF";
516                                                if (zaehler >= X"00064") then -- wait 2µs
517                                                        wiz_reset <= '1';
518                                                end if; 
519                                                if (zaehler = RST_TIME) then -- wait 10ms
520                                                        zaehler <= X"00000";
521                                                        socket_cnt <= "000";
522                                                        count <= "000";
523                                                        ram_access <= '0';
524                                                        interrupt_ignore <= '0';
525                                                        rd <= '1';
526                                                        wr <= '1';
527                                                        cs <= '1';
528                                                        state_write <= WR_START;
529                                                        --state_init <= INIT;
530                                                       
531                                                        -- I do this early configuration here, in order to get rid of all events in RAM.
532                                                        -- in order to end up, with disabled trigger lines, I set trigger enable to 0.
533                                                        -- So busy should vanish, once we are here.
534                                                        trigger_enable_sig <= '0';
535                                                        state_init <= CONFIG;
536                                                        state_after_config <= INIT;
537                                                end if;
538                                               
539                                        -- Init
540                                        when INIT =>
541                                          state_sig <= X"02";
542                                                -- status of MAC jumpers is synched in
543                                                -- and Board- and CrateID are synched in
544                                                FAD_in_cam <= MAC_jumper(1); -- see position of jumpers in FACT logbook
545                                                FAD_at_ETHZ <= MAC_jumper(0); -- MAC_jumper(1) is where D_T(7) was; MAC_jumper(0) is where D_T(6) was;
546                                                bid <= BoardID;
547                                                cid <= CrateID;
548                                                par_addr <= W5300_MR;
549                                                par_data <= X"0000";
550                                                state_init <= WRITE_REG;
551                                                next_state <= LOCATE;
552                               
553                                        when LOCATE =>
554                                                state_sig <= X"03";                                       
555                                                state_init <= IM;
556                                               
557                                                -- calculate FADid for 'send'-ing serialization
558                                                FADid <= conv_integer(cid)*10+conv_integer(bid);
559
560                                                if (FAD_in_cam = '1') then
561                                                        if (bid = "1111" and cid="11") then
562                                                                -- if BID = "1111" and CID="11" then FAD is not really in cam
563                                                                -- I don't know what to do now.
564                                                                -- I could wait a long time, and then just assume, I was not in cam.
565                                                                -- this should never happen!!!!!
566                                                                -- impossible to find this out, if in cam
567                                                                gateway_loc <= ETHZ_GATEWAY;
568                                                                netmask_loc <= ETHZ_NETMASK;                                           
569                                                                mac_loc <= MAC_FAD2; 
570                                                                ip_loc <= IP_ETHZ_FAD2;
571                                                                --state_init <= INIT;
572                                                        else -- everything is fine
573                                                                -- IP & MAC are calculated from BID & CID
574                                                                -- code here
575                                                                gateway_loc <= CAM_GATEWAY;
576                                                                netmask_loc <= CAM_NETMASK;                                             
577                                                                mac_loc <= (CAM_MAC_prefix (0), CAM_MAC_prefix (1)  , conv_std_logic_vector ( conv_integer(cid)*10+conv_integer(bid)  , 16)   ); 
578                                                                ip_loc <= ( CAM_IP_PREFIX(0) , CAM_IP_PREFIX(1) , IP_offset + conv_integer(cid) , IP_offset + conv_integer(bid) );
579                                                        end if;
580                                                else -- FAD is tested, either at ETHZ or at TUDO AND either with FMP or without.
581                                                        if ( FAD_at_ETHZ = '0' ) then
582                                                                -- easy FAD is at TUDO -> only one choice.
583                                                                mac_loc <= MAC_FAD0;
584                                                                ip_loc <= IP_TUDO;
585                                                                gateway_loc <= TUDO_GATEWAY;
586                                                                netmask_loc <= TUDO_NETMASK;
587                                                        else -- FAD is at ETHZ but not in cam --> IP lookup table is needed.
588                                                                if (bid = "1111" and cid="11") then -- FAD is not in crate
589                                                                        mac_loc <= MAC_FAD0;
590                                                                        ip_loc <= IP_ETHZ_FAD0;
591                                                                        gateway_loc <= ETHZ_GATEWAY;
592                                                                        netmask_loc <= ETHZ_NETMASK;                                           
593                                                                else
594                                                                        -- FAD is at ETHZ and in crate:
595                                                                        -- crate ID is not of importance.
596                                                                        -- we only have 3 MACs and IPs so far, so only the first boardIDs are allowed.
597                                                                        if ( conv_integer(bid) < MAC_LIST'length) then
598                                                                                gateway_loc <= ETHZ_GATEWAY;
599                                                                                netmask_loc <= ETHZ_NETMASK;                                           
600                                                                                mac_loc <= MAC_LIST(conv_integer(bid));
601                                                                                ip_loc <= IP_LIST(conv_integer(bid));
602                                                                        end if; -- conv_integer
603                                                                end if; -- bid=1111 & cid=11
604                                                        end if; --FAD_at_ETHZ = 0
605                                                end if; --FAD_in_cam = 1
606                                               
607                                        -- Interrupt Mask
608                                        when IM =>
609                                          state_sig <= X"04";
610                                                par_addr <= W5300_IMR;
611                                                par_data <= X"00FF"; -- S0-S7 Interrupts
612                                                state_init <= WRITE_REG;
613                                                next_state <= MT;
614                                               
615                                        -- Memory Type
616                                        when MT =>
617                                          par_addr <=   W5300_MTYPER;
618                                          par_data <= X"7FFF"; -- 8K RX, 120K TX-Buffer
619                                          state_init <= WRITE_REG;
620                                          next_state <= STX;
621                                         
622                                        -- Socket TX Memory Size
623                                        when STX =>
624                                          par_data <= X"0F0F"; -- 15K TX
625
626                                                par_addr <= W5300_TMS01R;
627                                                state_init <=WRITE_REG;
628                                                next_state <= STX1;
629          when STX1 =>
630            par_addr <= W5300_TMS23R;
631            state_init <=WRITE_REG;
632            next_state <= STX2;
633          when STX2 =>
634            par_addr <= W5300_TMS45R;
635            state_init <=WRITE_REG;
636            next_state <= STX3;
637          when STX3 =>
638            par_addr <= W5300_TMS67R;
639            state_init <=WRITE_REG;
640            next_state <= SRX;
641                                       
642          -- Socket RX Memory Size
643          when SRX =>
644            par_data <= X"0101"; -- 1K RX
645             
646            par_addr <= W5300_RMS01R;
647            state_init <=WRITE_REG;
648            next_state <= SRX1;
649          when SRX1 =>
650            par_addr <= W5300_RMS23R;
651            state_init <=WRITE_REG;
652            next_state <= SRX2;
653          when SRX2 =>
654            par_addr <= W5300_RMS45R;
655            state_init <=WRITE_REG;
656            next_state <= SRX3;
657          when SRX3 =>
658            par_addr <= W5300_RMS67R;
659            state_init <=WRITE_REG;
660            next_state <= MAC;
661         
662                                        -- MAC
663                                        when MAC =>
664                                                par_addr <= W5300_SHAR;
665                                                par_data <= mac_loc(0);
666                                                state_init <= WRITE_REG;
667                                                next_state <= MAC1;
668                                        when MAC1 =>
669                                                par_addr <= W5300_SHAR + 2;
670                                                par_data <= mac_loc(1);
671                                                state_init <= WRITE_REG;
672                                                next_state <= MAC2;
673                                        when MAC2 =>
674                                                par_addr <= W5300_SHAR + 4;
675                                                par_data <= mac_loc(2);
676                                                state_init <= WRITE_REG;
677                                                next_state <= GW;
678                                               
679                                        -- Gateway
680                                        when GW =>
681                                                par_addr <= W5300_GAR;
682                                                par_data (15 downto 8) <= conv_std_logic_vector(gateway_loc(0),8);
683                                                par_data (7 downto 0) <= conv_std_logic_vector(gateway_loc(1),8);
684                                                state_init <= WRITE_REG;
685                                                next_state <= GW1;
686                                        when GW1 =>
687                                                par_addr <= W5300_GAR + 2;
688                                                par_data (15 downto 8) <= conv_std_logic_vector(gateway_loc(2),8);
689                                                par_data (7 downto 0) <= conv_std_logic_vector(gateway_loc(3),8);
690                                                state_init <= WRITE_REG;
691                                                next_state <= SNM;
692                                               
693                                        -- Subnet Mask
694                                        when SNM =>
695                                                par_addr <= W5300_SUBR;
696                                                par_data (15 downto 8) <= conv_std_logic_vector(netmask_loc(0),8);
697                                                par_data (7 downto 0) <= conv_std_logic_vector(netmask_loc(1),8);
698                                                state_init <= WRITE_REG;
699                                                next_state <= SNM1;
700                                        when SNM1 =>
701                                                par_addr <= W5300_SUBR + 2;
702                                                par_data (15 downto 8) <= conv_std_logic_vector(netmask_loc(2),8);
703                                                par_data (7 downto 0) <= conv_std_logic_vector(netmask_loc(3),8);
704                                                state_init <= WRITE_REG;
705                                                next_state <= IP;
706                                        -- Own IP-Address
707                                        when IP =>
708                                                par_addr <= W5300_SIPR;
709                                                par_data (15 downto 8) <= conv_std_logic_vector(ip_loc(0),8);
710                                                par_data (7 downto 0) <= conv_std_logic_vector(ip_loc(1),8);
711                                                state_init <= WRITE_REG;
712                                                next_state <= IP1;
713                                        when IP1 =>
714                                                par_addr <= W5300_SIPR + 2;
715                                                par_data (15 downto 8) <= conv_std_logic_vector(ip_loc(2),8);
716                                                par_data (7 downto 0) <= conv_std_logic_vector(ip_loc(3),8);
717                                                state_init <= WRITE_REG;
718                                                --next_state <= SI;
719                                                next_state <= TIMEOUT;
720                                        when TIMEOUT =>
721                                                par_addr <=     W5300_RTR;
722                                                --par_data <= X"07D0"; -- 0x07D0 = 200ms
723                                                par_data <= X"07D0"; -- unit is 100us, so 0x000A = 10 stnads for 1ms.
724                                                state_init <= WRITE_REG;
725                                                next_state <= SI;
726--          when RETRY =>
727--            par_addr <=       W5300_RCR;
728--            par_data <= X"0008";
729--            state_init <= WRITE_REG;
730--            next_state <= SI;
731--                                       
732
733                                        -- Socket Init
734                                        when SI =>
735                                          state_sig <= X"05";
736                                                par_addr <= W5300_S0_MR + socket_cnt * W5300_S_INC;
737                                                par_data <= X"0101"; -- ALIGN, TCP
738                                                state_init <= WRITE_REG;
739                                                next_state <= SI1;
740                                        -- Sx Interrupt Mask
741                                        when SI1 =>
742                                                par_addr <= W5300_S0_IMR + socket_cnt * W5300_S_INC;
743                                                par_data <= X"000A"; -- TIMEOUT, DISCON
744                                                state_init <= WRITE_REG;
745                                                next_state <= SI1b;
746                                        when SI1b =>
747                                                par_addr <= W5300_S0_KPALVTR + socket_cnt * W5300_S_INC;
748                                                par_data <= X"0200";                    -- send automatic KEEP ALIVE every 10s.
749                                                state_init <= WRITE_REG;
750                                                next_state <= SI2;                                             
751                                        when SI2 =>
752                                                par_addr <= W5300_S0_PORTR + socket_cnt * W5300_S_INC;
753                                                par_data <= conv_std_logic_vector(FIRST_PORT + unsigned (socket_cnt), 16);
754                                                state_init <= WRITE_REG;
755                                                next_state <= SI3;
756                                        when SI3 =>
757                                                par_addr <= W5300_S0_CR + socket_cnt * W5300_S_INC;
758                                                par_data <= X"0001"; -- OPEN
759                                                state_init <= WRITE_REG;
760                                                next_state <= SI4;
761                                        when SI4 =>
762                                                par_addr <= W5300_S0_SSR + socket_cnt * W5300_S_INC;
763                                                state_init <= READ_REG;
764                                                next_state <= SI5;
765                                        when SI5 =>
766                                                if (data_read (7 downto 0) = X"13") then -- is open?
767                                                        state_init <= SI6;
768                                                else
769                                                        state_init <= SI4;
770                                                end if;
771                                        when SI6 =>
772                                                par_addr <= W5300_S0_CR + socket_cnt * W5300_S_INC;
773                                                par_data <= X"0002"; -- LISTEN
774                                                state_init <= WRITE_REG;
775                                                socket_cnt <= socket_cnt + 1;
776                                                if (socket_cnt = 7) then
777                                                  socket_cnt <= "000";
778                                                  next_state <= ESTABLISH; -- All Sockets open
779                                                else
780                                                  next_state <= SI; -- Next Socket
781                                                end if;
782                                  -- End Socket Init
783                                               
784                                        when ESTABLISH =>
785                                                state_sig <= X"07";
786                                                socks_waiting <= '1';
787                                                socks_connected <= '0';
788                                                par_addr <= W5300_S0_SSR + socket_cnt * W5300_S_INC;
789                                                state_init <= READ_REG;
790                                                next_state <= EST1;
791                                        when EST1 =>
792                                                state_sig <= X"08";
793                                                case data_read (7 downto 0) is
794                                                        when X"17" => -- established
795                                                                if (socket_cnt = 7) then
796                                                                  socket_cnt <= "000";
797                                                                  busy <= '0';
798                                                                  state_init <= MAIN;
799                                                                  --state_init <= CONFIG_MEMORY_MANAGER;
800                                                                else
801                                                                  socket_cnt <= socket_cnt + 1;
802                                                                  state_init <= ESTABLISH;
803                                                                end if;
804                                                        when others =>
805                                                                state_init <= ESTABLISH;
806                                                end case;
807                                               
808                                        when CONFIG =>   -- Triggers are disabled here!
809                                          state_sig <= X"06";
810                                                trigger_enable_storage_sig <= trigger_enable_sig;                               -- store last value of this signal.
811                                                trigger_enable_sig <= '0';                                                                              --no triggers must occur, while configurating.
812                                                state_init <= WAIT_100NS;                                                                               
813                                               
814                                        when WAIT_100NS =>
815                                                state_sig <= X"15";
816                                                wait_100ns_sig <= wait_100ns_sig + 1;
817                                                if (wait_100ns_sig = "110010") then
818                                                        wait_100ns_sig <= "000000";
819                                                        state_init <= WAIT_UNTIL_DG_IDLE;       
820                                                end if;
821                                               
822                                        when WAIT_UNTIL_DG_IDLE =>
823                                                state_sig <= X"16";
824                                                if (data_generator_idle_sr = "111") then
825                                                        state_init <= CONFIG_MEMORY_MANAGER;
826                                                end if;
827                                       
828                                       
829                                        when CONFIG_MEMORY_MANAGER =>
830                                          state_sig <= X"18";
831                                                memory_manager_config_start_o <= '1';
832                                                if (memory_manager_config_valid_i_sr = "00") then
833                                                        state_init <= WAIT_FOR_CONFIG_MEMORY_MANAGER;
834                                                end if;
835                                       
836                                        when WAIT_FOR_CONFIG_MEMORY_MANAGER =>
837                                          state_sig <= X"19";
838                                                memory_manager_config_start_o <= '0';
839                                                if (memory_manager_config_valid_i_sr(1) = '1') then
840                                                        --state_init <= CONFIG_DATA_GENERATOR;
841                                                        trigger_enable_sig <= trigger_enable_storage_sig;
842                                                        state_init <= state_after_config;
843                                                        --state_init <= MAIN;
844                                                end if;
845                                               
846                                               
847                                                when CONFIG_DAC_ONLY =>
848                                                  state_sig <= X"1C";
849                                                        spi_interface_config_start_o <= '1';
850                                                        if (spi_interface_config_valid_i_sr ="00") then
851                                                                state_init <= WAIT_FOR_CONFIG_DAC_ONLY;
852                                                        end if;
853                                               
854                                                when WAIT_FOR_CONFIG_DAC_ONLY =>
855                                                  state_sig <= X"1D";
856                                                        spi_interface_config_start_o <= '0';
857                                                        if (spi_interface_config_valid_i_sr ="11") then
858                                                                state_init <= MAIN;
859                                                        end if;
860                                                       
861----------------------------------------------------------------------------------
862-- MAIN "loop" -------------------------------------------------------------------
863----------------------------------------------------------------------------------
864         
865                                        when MAIN =>
866                                        state_sig <= X"20";
867                                        socks_waiting <= '0';
868                                        socks_connected <= '1';
869                                        ps_do_phase_shift <= '0';
870                                        ps_reset <= '0';
871                                        data_valid_ack <= '0';
872                                       
873                                               
874                                                if (update_of_rois = '1') then
875                                                        update_of_rois <= '0';
876                                                       
877                                                        state_after_config <= MAIN;  --this needs to be set to main, in order to return here, after configuration
878                                                        state_init <= CONFIG;
879--                                                      if (trigger_enable_sig = '1') then
880--                                                              trigger_enable_storage_sig <= trigger_enable_sig;
881--                                                      end if;
882--                                                      trigger_enable_sig <= '0';
883--
884--                                                      update_of_rois <= '0';
885--                                                      state_init <= CONFIG_MEMORY_MANAGER;
886--                                                      if (data_ram_empty_sr(1) = '1') then
887--                                                              update_of_rois <= '0';
888--                                                              state_init <= CONFIG_MEMORY_MANAGER;
889--                                                      else
890--                                                              state_init <= MAIN2;
891--                                                      end if;
892                                                       
893                                                elsif (update_of_lessimportant = '1') then                             
894                                                        update_of_lessimportant <= '0';
895                                                        state_init <= CONFIG_DAC_ONLY;
896                                                else -- update_of_rois='0' and update_of_lessimportant='0'
897                                                        state_init <= MAIN1;
898                                                        --data_valid_int <= data_valid;
899                                                end if;
900                       
901                                        when MAIN1 =>
902                                          state_sig <= X"21";
903                                                if (chk_recv_cntr = 1000) then
904                                                        chk_recv_cntr <= 0;
905                                                        state_read_data <= RD_1;
906                                                        state_init <= READ_DATA;
907                                                        busy <= '1';
908                                                else
909                                                        chk_recv_cntr <= chk_recv_cntr + 1; 
910                                                        state_init <= MAIN2;
911                                                end if;
912                                        when MAIN2 =>
913                                          state_sig <= X"22";
914                                                busy <= '0';
915                                                --if (data_valid = '1') then
916                                                if (data_valid_sr(1) = '1') then
917                                                        --data_valid_int <= '0';
918                                                        busy <= '1';
919                                                        local_write_length <= write_length;
920                                                        local_ram_start_addr <= ram_start_addr;
921                                                        local_ram_addr <= (others => '0');
922                                                        local_write_header_flag <= write_header_flag;
923                                                        local_write_end_flag <= write_end_flag;
924                                                        local_fifo_channels <= fifo_channels;
925                                                        --                data_valid_ack <= '1';
926                                                        --                next_state <= MAIN;
927                                                        --                state_init <= WRITE_DATA;
928                                                        state_init <= MAIN3;
929                                                else
930                                                        state_init <= MAIN1; 
931                                                end if;
932                                        when MAIN3 =>
933                                                debug_data_ram_empty <= local_write_end_flag;
934                                          state_sig <= X"23";
935                                                -- needed for the check: if there is enough space in W5300 FIFO
936                                                write_length_bytes <= (local_write_length (15 downto 0) & '0')   ; -- shift left (*2)
937                                               
938                                                next_state <= MAIN;
939                                                state_init <= WRITE_DATA;
940                                               
941                                               
942----------------------------------------------------------------------------------
943-- END OF MAIN         -----------------------------------------------------------
944----------------------------------------------------------------------------------
945
946                                        -- read data from socket 0 
947                                        when READ_DATA =>
948                                                case state_read_data is
949                                                when RD_1 =>
950                                                  state_sig <= X"30";
951                                                        par_addr <= W5300_S0_RX_RSR;
952                                                        state_init <= READ_REG;
953                                                        next_state <= READ_DATA;
954                                                        state_read_data <= RD_2;
955                                                when RD_2 =>
956                                                  state_sig <= X"31";
957                                                        socket_rx_received (16) <= data_read(0);
958                                                        par_addr <= W5300_S0_RX_RSR + X"2";
959                                                        state_init <= READ_REG;
960                                                        next_state <= READ_DATA;
961                                                        state_read_data <= RD_3;
962                                                when RD_3 =>
963                                                  state_sig <= X"32";
964                                                        socket_rx_received (15 downto 0) <= data_read;
965                                                        state_read_data <= RD_4;
966                                                when RD_4 =>
967                                                  state_sig <= X"33";
968                                                        if (socket_rx_received (16 downto 0) > ('0' & X"000")) then
969                                                                rx_packets_cnt <= socket_rx_received (16 downto 1); -- socket_rx_received / 2
970                                                                state_read_data <= RD_5;
971                                                        else
972                                                                busy <= '0';
973                                                                state_init <= MAIN;
974                                                        end if;
975                                                when RD_5 =>
976                                                  state_sig <= X"34";
977                                                        s_trigger <= '0';
978                                                        ps_do_phase_shift <= '0';
979                                                        reset_trigger_id <= '0';
980                                                       
981                                                        if (rx_packets_cnt > 0) then
982                                                                rx_packets_cnt <= rx_packets_cnt - '1';
983                                                                par_addr <= W5300_S0_RX_FIFOR;
984                                                                state_init <= READ_REG;
985                                                                next_state <= READ_DATA;
986                                                                state_read_data <= RD_6;
987                                                        else
988                                                                state_read_data <= RD_END;
989                                                        end if;
990                                                       
991                                                when RD_6 =>
992                                                  state_sig <= X"35";
993                                                        -- The next 16bit word is assumed to contain a 'command' so it is
994                                                        -- beeing parsed in this state
995                                                        case data_read (15 downto 8) is
996                                                        when CMD_START =>
997                                                               
998                                                                state_read_data <= RD_5;
999                                                        when CMD_STOP => 
1000                                                               
1001                                                                state_read_data <= RD_5;
1002                                                        when CMD_MODE_ALL_SOCKETS =>  -- all data will be send via socket 1..7
1003                                                                socket_send_mode <= '1';
1004                                                                state_read_data <= RD_5;
1005                                                        when CMD_MODE_COMMAND => -- all data will be send via socket 0
1006                                                                socket_send_mode <= '0';
1007                                                                state_read_data <= RD_5;   
1008                                                        when CMD_TRIGGER =>
1009                                                                s_trigger <= '1';
1010                                                                state_read_data <= RD_5;
1011                                                        when CMD_DWRITE_RUN =>
1012                                                                dwrite_enable <= '1';
1013                                                                state_read_data <= RD_5;
1014                                                        when CMD_DWRITE_STOP =>
1015                                                                dwrite_enable <= '0';
1016                                                                state_read_data <= RD_5;
1017                                                        when CMD_SCLK_ON =>
1018                                                                sclk_enable <= '1';
1019                                                                state_read_data <= RD_5;
1020                                                        when CMD_SCLK_OFF =>
1021                                                                sclk_enable <= '0';
1022                                                                state_read_data <= RD_5;
1023                                                        when CMD_DENABLE =>
1024                                                                denable <= '1';
1025                                                                state_read_data <= RD_5;
1026                                                        when CMD_DDISABLE =>
1027                                                                denable <= '0';
1028                                                                state_read_data <= RD_5;
1029                                                               
1030                                                        when CMD_BUSY_ON =>
1031                                                                busy_enable <= '1';
1032                                                                state_read_data <= RD_5;
1033                                                        when CMD_BUSY_OFF =>
1034                                                                busy_enable <= '0';
1035                                                                state_read_data <= RD_5;
1036
1037                                                               
1038                                                        when CMD_TRIGGER_C =>
1039                                                                c_trigger_enable <= '1';
1040                                                                state_read_data <= RD_5;
1041                                                        when CMD_TRIGGER_S =>
1042                                                          c_trigger_enable <= '0';
1043                                                          state_read_data <= RD_5;
1044
1045                                                        -- phase shift commands here:
1046                                                        when CMD_PS_DO =>
1047                                                          ps_do_phase_shift <= '1';
1048                                                          state_read_data <= RD_5;
1049                                                        when CMD_PS_DIRINC =>
1050                                                          ps_direction <= '1';
1051                                                          state_read_data <= RD_5;
1052                                                        when CMD_PS_RESET =>
1053                                                          ps_reset <= '1';
1054                                                          state_read_data <= RD_5;
1055                                                        when CMD_SRCLK_ON =>
1056                                                          srclk_enable <= '1';
1057                                                          state_read_data <= RD_5;
1058                                                        when CMD_SRCLK_OFF =>
1059                                                          srclk_enable <= '0';
1060                                                          state_read_data <= RD_5;
1061                                                        when CMD_TRIGGERS_ON =>
1062                                                          trigger_enable_sig <= '1';
1063                                                          state_read_data <= RD_5;
1064                                                        when CMD_TRIGGERS_OFF =>
1065                                                          trigger_enable_sig <= '0';
1066                                                          state_read_data <= RD_5;
1067                                                        when CMD_PS_DIRDEC =>
1068                                                          ps_direction <= '0';
1069                                                          state_read_data <= RD_5;
1070                                                         
1071                                                        when CMD_RESET_TRIGGER_ID =>
1072                                                                reset_trigger_id <= '1';
1073                                                                state_read_data <= WAIT_FOR_TRIGGER_ID_RESET_1;
1074                                                               
1075                                                        when CMD_WRITE =>
1076                                                                if ( (conv_integer(data_read (7 downto 0)) >= 0) and (conv_integer(data_read (7 downto 0)) <= 46) ) then
1077                                                                        config_addr <= conv_integer(data_read (7 downto 0));
1078                                                                        state_read_data <= READ_COMMAND_DATA_SECTION;
1079                                                                else
1080                                                                        config_addr <= 47;
1081                                                                        state_read_data <= READ_COMMAND_DATA_SECTION;
1082                                                                end if;
1083                                                               
1084                                                        when CMD_EXECUTE =>
1085                                                                state_read_data <= EXECUTE;
1086                                                               
1087                                                        when others =>
1088                                                                state_read_data <= RD_5;
1089                                                        end case;
1090                -- read data
1091                               
1092                                                when WAIT_FOR_TRIGGER_ID_RESET_1 =>
1093                                                  state_sig <= X"36";
1094                                                        state_read_data <= WAIT_FOR_TRIGGER_ID_RESET_2;
1095                                                when WAIT_FOR_TRIGGER_ID_RESET_2 =>
1096                                                  state_sig <= X"37";
1097                                                        state_read_data <= RD_5;
1098                        -- these states are beeing processed, if the 'command' was a 'write command'
1099                        --      so it is assumed, that some data in config RAM changed, and we need full (re)config
1100                        when READ_COMMAND_DATA_SECTION =>
1101                          state_sig <= X"38";
1102                                if (rx_packets_cnt > 0) then
1103                                        rx_packets_cnt <= rx_packets_cnt - '1';
1104                                        par_addr <= W5300_S0_RX_FIFOR;
1105                                        state_init <= READ_REG;
1106                                        next_state <= READ_DATA;
1107                                        state_read_data <= PUT_COMMAND_DATA_SECTION;
1108                                else
1109                                        state_read_data <= RD_END;
1110                                end if;
1111                       
1112                        when PUT_COMMAND_DATA_SECTION =>
1113                          state_sig <= X"39";
1114                                config_setting(config_addr) <= data_read;
1115                               
1116--                              if (config_addr < 36) then
1117--                                      update_of_rois <= '1';
1118--                              else
1119--                                      if (config_addr < 45 ) then
1120--                                              update_of_lessimportant <= '1';
1121--                                      end if;
1122--                              end if;
1123                               
1124                                state_read_data <= RD_5;
1125                               
1126                        when EXECUTE =>
1127                                update_of_rois <= '1';
1128                                update_of_lessimportant <= '1';
1129                                runnumber <= config_setting(45) & config_setting(46);
1130                               
1131                                state_read_data <= RD_5;
1132
1133                        when RD_END =>
1134                          state_sig <= X"3A";
1135                                par_addr <= W5300_S0_CR;
1136                par_data <= X"0040"; -- RECV
1137                state_init <= WRITE_REG;
1138                                next_state <= MAIN;
1139                               
1140      when others =>
1141        state_sig <= X"3F";
1142     
1143            end case; -- state_data_read
1144               
1145   
1146
1147                                        when WRITE_DATA =>
1148                                                case state_write is
1149                                                       
1150                                                  when WR_START =>
1151                                                    state_sig <= X"40";
1152                                                    if (local_write_header_flag = '1') then
1153                                                                ram_addr <= local_ram_start_addr + 6; -- Address of HIGH word of Event ID
1154                                                                state_write <= WR_GET_EVT_ID_WAIT1;
1155                                                        else
1156                                                        state_write <= WR_CHECK_FOR_FIFO_SPACE_01;
1157                                                    end if;
1158                                                     
1159                                                  when WR_GET_EVT_ID_WAIT1 =>
1160                                                    state_sig <= X"41";
1161                                                    state_write <= WR_GET_EVT_ID1;
1162                                                  when WR_GET_EVT_ID1 =>
1163                                                    state_sig <= X"42";
1164                                                                event_number(31 downto 16) <= ram_data;
1165                                                                ram_addr <= local_ram_start_addr + 9; -- Address of LOW word of Event ID
1166                                                                state_write <= WR_GET_EVT_ID_WAIT2;
1167                                                        when WR_GET_EVT_ID_WAIT2 =>
1168                                                                state_write <= WR_GET_EVT_ID2;
1169                                                  when WR_GET_EVT_ID2 =>
1170                                                    state_sig <= X"43";
1171                                                                event_number(15 downto 0) <= ram_data;
1172                                                                mod7_start <= '1';
1173                                                                if (mod7_valid = '0') then
1174                                                                        state_write <= WR_MOD7_STARTED;
1175                                                                else
1176                                                                        state_write <= WR_GET_EVT_ID2;
1177                                                                end if;
1178                                                               
1179                                                        when WR_MOD7_STARTED =>
1180                                                          state_sig <= X"44";
1181                                                                if (mod7_started = '1') then
1182                                                                        mod7_start <= '0';
1183                                                                        state_write <= WR_WAIT_FOR_MOD7;
1184                                                                end if;
1185
1186                                                        when WR_WAIT_FOR_MOD7 =>
1187                                                          state_sig <= X"45";
1188                                                          next_state_tmp <= next_state;
1189                                                                if (mod7_valid = '1') then
1190                                                                        if (socket_send_mode = '1') then -- send via all sockets
1191                                                                                                local_socket_nr <= mod7_result + 1;
1192                                                                        else -- only send via socket 0\
1193                                                                                                local_socket_nr <= "000";
1194                                                                        end if;
1195                                                                       
1196                                                                        data_cnt <= 0;
1197                                                                        state_write <= WR_CHECK_FOR_FIFO_SPACE_01; 
1198                                                                else 
1199                                                                        state_write <= WR_WAIT_FOR_MOD7;
1200                                                                end if;
1201                                                               
1202                                                        -- Check FIFO Size
1203                                                        when WR_CHECK_FOR_FIFO_SPACE_01 =>
1204                                                          state_sig <= X"46";
1205                                                                par_addr <= W5300_S0_TX_FSR + local_socket_nr * W5300_S_INC;
1206                                                                state_init <= READ_REG;
1207                                                                next_state <= WRITE_DATA;
1208                                                                state_write <= WR_CHECK_FOR_FIFO_SPACE_02;
1209                                                        when WR_CHECK_FOR_FIFO_SPACE_02 =>
1210                                                          state_sig <= X"47";
1211                                                                socket_tx_free (16) <= data_read(0);
1212                                                                par_addr <= W5300_S0_TX_FSR + (local_socket_nr * W5300_S_INC) + X"2";
1213                                                                state_init <= READ_REG;
1214                                                                next_state <= WRITE_DATA;
1215                                                                state_write <= WR_CHECK_FOR_FIFO_SPACE_03;
1216                                                        when WR_CHECK_FOR_FIFO_SPACE_03 =>
1217                                                          state_sig <= X"48";
1218                                                                socket_tx_free (15 downto 0) <= data_read;
1219                                                                state_write <= WR_CHECK_FOR_FIFO_SPACE_04;
1220                                                        when WR_CHECK_FOR_FIFO_SPACE_04 =>
1221                                                          state_sig <= X"49";
1222                                                                socket_tx_free_out <= socket_tx_free;
1223--                                                              if (socket_tx_free (16 downto 0) < write_length_bytes) then
1224                                                                if (socket_tx_free (16 downto 0) < W5300_TX_FIFO_SIZE_8B) then
1225                                                               
1226                                                                        state_write <= WR_CHECK_FOR_FIFO_SPACE_01;
1227                                                                else
1228                                                                        if (local_write_header_flag = '1') then
1229                                                                                state_write <= WR_FIFO;
1230                                                                        else
1231                                                                                state_write <= WR_ADC;
1232                                                                        end if; 
1233                                                                end if;
1234                                                       
1235                                                        -- Fill FIFO
1236
1237                                                        -- Write Header
1238                                                        when WR_FIFO =>
1239                                                          state_sig <= X"4A";
1240                                                                ram_addr <= local_ram_start_addr + local_ram_addr;
1241                                                                state_write <= WR_FIFO1;
1242                                                        when WR_FIFO1 =>
1243                                                          state_sig <= X"4B";
1244                                                                data_cnt <= data_cnt + 1;
1245                                                                if (data_cnt < PACKAGE_HEADER_LENGTH) then --???
1246                                                                  local_ram_addr <= local_ram_addr + 1;
1247--                                                                if (data_cnt = 2 or data_cnt = 5 or data_cnt = 8 ) then -- skip empty words
1248--                                                                  local_ram_addr <= local_ram_addr + 2;
1249--                                                                end if;
1250--                                                                if (data_cnt = 9) then -- skip empty words
1251--                                                                  local_ram_addr <= local_ram_addr + 4;
1252--                                                                end if; 
1253                                                                        par_addr <= W5300_S0_TX_FIFOR + local_socket_nr * W5300_S_INC;
1254                                                                        ram_access <= '1';
1255                                                                        state_init <= WRITE_REG;
1256                                                                        number_of_words_written_to_fifo <= number_of_words_written_to_fifo + 1;
1257                                                                        next_state <= WRITE_DATA;
1258                                                                        state_write <= WR_FIFO;
1259                                                                else
1260                                                                        state_write <= WR_ADC;
1261                                                                end if;
1262                                                        -- End Write Header
1263                                                       
1264                                                        -- Write ADC-Data
1265                                                        ---- Start...
1266                                                        when WR_ADC =>
1267                                                          state_sig <= X"4C";
1268                                                                adc_data_addr <= local_ram_start_addr + local_ram_addr;
1269                                                                drs_cnt <= 0;
1270                                                                channel_cnt <= 1;
1271                                                                data_cnt <= 0;
1272                                                                roi_max <= (others => '0');
1273                                                                data_end <= POSITION_OF_ROI_IN_CHANNEL_HEADER;
1274                                                                state_write <= WR_ADC1;
1275
1276                                                        ---- Write Channel
1277                                                        when WR_ADC1 =>
1278                                                          state_sig <= X"4D";
1279                                                                -- read ROI and set end of Channel-Data
1280                                                                if (data_cnt = POSITION_OF_ROI_IN_CHANNEL_HEADER) then
1281                                                                        data_end <= conv_integer (ram_data) + CHANNEL_HEADER_SIZE;
1282                                                                        if (ram_data > roi_max) then
1283                                                                                roi_max <= ram_data (10 downto 0);
1284                                                                        end if;
1285                                                                end if;
1286                                                                ram_addr <= adc_data_addr + drs_cnt + (data_cnt * 4);
1287                                                                state_write <= WR_ADC2;
1288                                                        when WR_ADC2 =>
1289                                                       
1290                                                                if (data_cnt < data_end) then
1291                                                                        par_addr <= W5300_S0_TX_FIFOR + local_socket_nr * W5300_S_INC;
1292                                                                        ram_access <= '1';
1293                                                                        state_init <= WRITE_REG;
1294                                                                        number_of_words_written_to_fifo <= number_of_words_written_to_fifo + 1;
1295                                                                        next_state <= WRITE_DATA;
1296                                                                        data_cnt <= data_cnt + 1;
1297                                                                        state_write <= WR_ADC1;
1298                                                                else
1299                                                                        -- Next DRS
1300                                                                        if (drs_cnt < 3) then
1301                                                                                drs_cnt <= drs_cnt + 1;
1302                                                                                data_cnt <= 0;
1303                                                                                data_end <= POSITION_OF_ROI_IN_CHANNEL_HEADER;
1304                                                                                state_write <= WR_ADC1;
1305                                                                        else
1306                                                                                -- Next Channel
1307                                                                                if (channel_cnt < local_fifo_channels) then
1308                                                                                        channel_cnt <= channel_cnt + 1;
1309                                                                                        roi_max <= (others => '0');
1310                                                                                        drs_cnt <= 0;
1311                                                                                        data_cnt <= 0;
1312                                                                                        data_end <= POSITION_OF_ROI_IN_CHANNEL_HEADER;
1313                                                                                        adc_data_addr <= adc_data_addr + ((conv_integer(roi_max) + CHANNEL_HEADER_SIZE) * 4);
1314                                                                                        state_write <= WR_ADC1;
1315                                                                                else
1316                                                                                        -- Ready
1317                                                                                        if (local_write_end_flag = '1') then
1318                                                                                                state_write <= WR_ENDFLAG;
1319                                                                                        else
1320                                                                                                state_write <= WR_05a;
1321                                                                                        end if;
1322                                                                                end if;
1323                                                                        end if;   
1324                                                                end if;
1325                                                                -- End Write ADC-Data
1326
1327              -- Write End Package Flag
1328              when WR_ENDFLAG =>
1329                state_sig <= X"4F";
1330                ram_addr <= adc_data_addr + ((conv_integer(roi_max) + CHANNEL_HEADER_SIZE) * 4);
1331                state_write <= WR_ENDFLAG1;
1332              when WR_ENDFLAG1 =>
1333                par_addr <= W5300_S0_TX_FIFOR + local_socket_nr * W5300_S_INC;
1334                ram_access <= '1';
1335                state_init <= WRITE_REG;
1336                                number_of_words_written_to_fifo <= number_of_words_written_to_fifo + 1;
1337                next_state <= WRITE_DATA;
1338                state_write <= WR_ENDFLAG2;
1339              when WR_ENDFLAG2 =>
1340                ram_addr <= adc_data_addr + ((conv_integer(roi_max) + CHANNEL_HEADER_SIZE) * 4) + 1;
1341                state_write <= WR_ENDFLAG3;
1342              when WR_ENDFLAG3 =>
1343                state_init <= WRITE_REG;
1344                next_state <= WRITE_DATA;
1345                                number_of_words_written_to_fifo <= number_of_words_written_to_fifo + 1;
1346                state_write <= WR_05a;
1347             
1348              -- End Write End Package Flag
1349             
1350              -- Wait????
1351              when WR_05a =>
1352                                state_sig <= X"4E";
1353                if (wait_cntr < 10) then -- 3000 works???
1354                  wait_cntr <= wait_cntr + 1;
1355                else
1356                  wait_cntr <= 0;
1357                  state_write <= WR_05b;
1358                end if;
1359              when WR_05b =>
1360                state_write <= WR_05_PREPARE_LENGTH_INFO;
1361
1362              --Send FIFO       
1363                                                        when WR_05_PREPARE_LENGTH_INFO =>
1364                                                                --number_of_words_written_to_fifo <= number_of_words_written_to_fifo - 1;
1365                                                                state_init <= WRITE_DATA;
1366                                                                state_write <= WR_05_POSTPREPARE_LENGTH_INFO;
1367                                                               
1368                                                       
1369                                                        when WR_05_POSTPREPARE_LENGTH_INFO =>
1370                                                                number_of_bytes_written_to_fifo <= number_of_words_written_to_fifo(15 downto 0) & '0';   
1371                                                                state_init <= WRITE_DATA;
1372                                                                state_write <= WR_05;
1373                                                       
1374                                                       
1375                                                        when WORKAROUND_CHECK_FIFO_SPACE_01 =>
1376                                                                par_addr <= W5300_S0_TX_FSR + local_socket_nr * W5300_S_INC;
1377                                                                state_init <= READ_REG;
1378                                                                next_state <= WRITE_DATA;
1379                                                                state_write <= WORKAROUND_CHECK_FIFO_SPACE_02;
1380                                                        when WORKAROUND_CHECK_FIFO_SPACE_02 =>
1381                                                                socket_tx_free (16) <= data_read(0);
1382                                                                par_addr <= W5300_S0_TX_FSR + (local_socket_nr * W5300_S_INC) + X"2";
1383                                                                state_init <= READ_REG;
1384                                                                next_state <= WRITE_DATA;
1385                                                                state_write <= WORKAROUND_CHECK_FIFO_SPACE_03;
1386                                                        when WORKAROUND_CHECK_FIFO_SPACE_03 =>
1387                                                                socket_tx_free (15 downto 0) <= data_read;
1388                                                                state_write <= WORKAROUND_CHECK_FIFO_SPACE_04;
1389                                                        when WORKAROUND_CHECK_FIFO_SPACE_04 =>
1390                                                                write_length_bytes <= TX_FIFO_MAX_FREE - socket_tx_free;
1391                                                                state_write <= WR_05;
1392                                                       
1393                                                       
1394                                                        when WR_05 =>
1395                                                          ram_access <= '0';
1396                                                                state_sig <= X"50";
1397                                                                par_addr <= W5300_S0_TX_WRSR + local_socket_nr * W5300_S_INC;
1398                                                                par_data <= (0 => write_length_bytes (16), others => '0');
1399                                                                --par_data <= (0 => number_of_bytes_written_to_fifo(16), others => '0');
1400                                                                state_init <= WRITE_REG;
1401                                                                state_write <= WR_06;
1402                                                        when WR_06 =>
1403                                                                par_addr <= W5300_S0_TX_WRSR + (local_socket_nr * W5300_S_INC) + X"2";
1404                                                                par_data <= write_length_bytes (15 downto 0);
1405                                                                --par_data <= number_of_bytes_written_to_fifo(15 downto 0);
1406                                                               
1407                                                                -- prepare this value here, so I have it in the next state.
1408                                                                wait_before_send_counter_goal <= FADid*50*MICROSEC_TO_WAIT_BEFORE_SEND;
1409                                                               
1410                                                                state_init <= WRITE_REG;
1411                                                                state_write <= WR_07;
1412                                                               
1413                                                        when WAIT_BEFORE_SEND =>
1414                                                                state_init <= WRITE_DATA;
1415                                                                state_write <= WAIT_BEFORE_SEND;
1416                                                               
1417                                                                if (wait_before_send_counter = wait_before_send_counter_goal) then 
1418                                                                        wait_before_send_counter <= 0;
1419                                                                        state_write <= WR_07;
1420                                                                else
1421                                                                        wait_before_send_counter <= wait_before_send_counter + 1;
1422                                                                end if;
1423                                                               
1424                                                        when WR_07 =>
1425                                                                number_of_words_written_to_fifo <= (others => '0');
1426                                                                state_sig <= X"51";
1427                                                                par_addr <= W5300_S0_CR + local_socket_nr * W5300_S_INC;
1428                                                                par_data <= X"0020"; -- Send
1429                                                                state_init <= WRITE_REG;
1430                                                                state_write <= WR_ACK;
1431                                                        when WR_ACK =>                                                  -- handshake with MM
1432                                                                data_valid_ack <= '1';
1433                                                                state_write <= WR_WAIT_FOR_ACK;
1434                                                        when WR_WAIT_FOR_ACK =>                                 -- handshake ACK with MM
1435                                                                state_write <= WR_WAIT_FOR_ACK;
1436                                                                if (data_valid_sr(1) = '0') then
1437                                                                        data_valid_ack <= '0';
1438                                                                       
1439                                                                        if (local_write_end_flag = '1') then
1440                                                                                -- the last package was just written, and we can go back to the main state
1441                                                                                state_init <= MAIN;
1442                                                                                state_write <= WR_START;
1443                                                                        else
1444                                                                                -- we just wrote, a part of an event and should not go back to main, in order to avoid
1445                                                                                -- intermediate reconfiguration of the MM, in case an 'EXECUTE' command just arrived.
1446                                                                                -- but neither we should not go back to MAIN2, because data_valid is still low, as part of the MM-handshake.
1447                                                                                --      so we have to wait, until data_valid goes back high.
1448                                                                                --      if it never goes high, this can be a deadlock again, but it MUST go high,
1449                                                                                -- because we did not send away the entire event, yet.
1450                                                                                state_init <= WRITE_DATA;
1451                                                                                state_write <= WAIT_FOR_DATA_VALID_HIGH_AGAIN;
1452                                                                        end if;
1453                                                                       
1454                                                                       
1455                                                                end if;
1456                                                       
1457                                                        when WAIT_FOR_DATA_VALID_HIGH_AGAIN =>
1458                                                                if (data_valid_sr(1) = '1') then
1459                                                                        state_init <= MAIN2;
1460                                                                        state_write <= WR_START;
1461                                                                end if;
1462                                                       
1463                                                        when others =>
1464                                                                state_sig <= X"4F";
1465                                                end case;
1466                                                -- End WRITE_DATA
1467                                               
1468                                        when READ_REG =>
1469                                          --state_sig <= X"50";
1470                                                case count is
1471                                                        when "000" =>
1472                                                                cs <= '0';
1473                                                                rd <= '0';
1474                                                                wr <= '1';
1475                                                                data <= (others => 'Z'); -- !!!!!!!!!!
1476                                                                count <= "001";
1477                                                                addr <= par_addr;
1478                                                        when "001" =>
1479                                                                count <= "010";
1480                                                        when "010" =>
1481                                                                count <= "100";
1482                                                        when "100" =>
1483                                                                data_read <= data;
1484                                                                count <= "110";
1485                                                        when "110" =>
1486                                                                count <= "111";
1487                                                        when "111" =>
1488                                                                cs <= '1';
1489                                                                rd <= '1';
1490                                                                count <= "000";
1491                                                                state_init <= next_state;
1492                                                        when others =>
1493                                                                null;
1494                                                end case;
1495                                       
1496                                        when WRITE_REG =>
1497                                          --state_sig <= X"60";
1498                                                case count is
1499                                                        when "000" =>
1500                                                                cs <= '0';
1501                                                                wr <= '0';
1502                                                                rd <= '1';
1503                                                                addr <= par_addr; 
1504                                                                if (ram_access = '1') then
1505                                                                        data <= ram_data;
1506                                                                else
1507                                                                        data <= par_data;
1508                                                                end if;
1509                                                                count <= "100";
1510                                                        when "100" =>
1511                                                                count <= "101";
1512                                                        when "101" =>
1513                                                                count <= "110";
1514                                                        when "110" =>
1515                                                                cs <= '1';
1516                                                                wr <= '1';
1517                                                                state_init <= next_state;
1518                                                                count <= "000";
1519                                                        when others =>
1520                                                          state_sig <= X"E0";
1521                                                                null;
1522                                                end case;
1523                                       
1524                                        when others =>
1525                                          state_sig <= X"F0";
1526                                                null;
1527                                end case;
1528                        end if; -- int_flag = '0'
1529
1530                end if; -- rising_edge (clk)
1531
1532        end process w5300_proc;
1533       
1534       
1535       
1536        --signal wait_for_sockets_closed_counter_overflow : std_logic := '0';
1537        --signal wait_for_sockets_closed_counter_enable : std_logic := '0';
1538        --signal wfscc_1 : integer range 0 to 50000 := 0;
1539        --signal wfscc_2 : integer range 0 to 2000 := 0;
1540        counter_before_reset_proc : process (clk)
1541        begin
1542                if rising_edge (clk) then
1543                        if (wait_for_sockets_closed_counter_enable = '1') then
1544                                wait_for_sockets_closed_counter_overflow <= '0';
1545                                if (wfscc_1 = 50000) then
1546                                        if (wfscc_2 = 20000) then
1547                                                wait_for_sockets_closed_counter_overflow <= '1';
1548                                                wfscc_2 <= 20000;
1549                                                wfscc_1 <= 50000;
1550                                        else 
1551                                                wfscc_2 <= wfscc_2 + 1;
1552                                                wfscc_1 <= 0;
1553                                        end if;
1554                                else
1555                                        wfscc_1 <= wfscc_1 + 1;
1556                                end if;
1557                        else
1558                                wfscc_1 <= 0;
1559                                wfscc_2 <= 0;
1560                                wait_for_sockets_closed_counter_overflow <= '0';
1561                        end if;
1562               
1563                end if;
1564        end process counter_before_reset_proc;
1565       
1566       
1567
1568end Behavioral;
1569
Note: See TracBrowser for help on using the repository browser.