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

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