source: firmware/FAD/FACT_FAD_20MHz_VAR_PS/FACT_FAD_lib/hdl/drs_pulser.vhd @ 10174

Last change on this file since 10174 was 10174, checked in by neise, 9 years ago
File size: 8.6 KB
Line 
1library IEEE;
2use IEEE.STD_LOGIC_1164.ALL;
3use IEEE.STD_LOGIC_ARITH.ALL;
4use IEEE.std_logic_signed.all;
5
6library fact_fad_lib;
7use fact_fad_lib.fad_definitions.all;
8
9
10ENTITY drs_pulser is
11port (
12        -- input CLK; RSRLOAD and SRCLK are derived from this signal
13        CLK : in std_logic;
14        -- async reset;
15        reset : in std_logic;
16
17        start_endless_mode : in std_logic;
18        start_read_stop_pos_mode : in std_logic;
19
20        SROUT_in_0 : in std_logic;
21        SROUT_in_1 : in std_logic;
22        SROUT_in_2 : in std_logic;
23        SROUT_in_3 : in std_logic;
24
25        stop_pos : out drs_s_cell_array_type;
26        stop_pos_valid : out std_logic;
27
28        RSRLOAD : out std_logic;
29        SRCLK : out std_logic;
30        busy :out std_logic
31);
32end drs_pulser;
33
34
35ARCHITECTURE behavior of drs_pulser IS
36
37type states is (idle, started_endless, started_read_stop_pos , waiting_e, waiting_r, running_e, running_r);
38signal current_state : states := idle;
39signal next_state : states := idle;
40signal CEN,LEN : std_logic;
41
42
43signal local_roi : std_logic_vector (9 downto 0):= (others => '0');
44
45signal flag_read_stop_pos : std_logic := '0';
46
47signal cell_cntr : std_logic_vector (9 downto 0);
48signal cc_en : std_logic;
49signal cc_reset : std_logic;
50
51signal wait_cntr : std_logic_vector (2 downto 0);
52signal wc_en : std_logic;
53signal wc_reset : std_logic;
54
55signal int_stop_pos_0 : std_logic_vector(9 downto 0) := (others => '0');
56signal int_stop_pos_1 : std_logic_vector(9 downto 0) := (others => '0');
57signal int_stop_pos_2 : std_logic_vector(9 downto 0) := (others => '0');
58signal int_stop_pos_3 : std_logic_vector(9 downto 0) := (others => '0');
59
60begin
61     RSRLOAD <= (LEN and CLK);
62     SRCLK <= (CEN and CLK);
63     stop_pos(0) <= int_stop_pos_0;
64     stop_pos(1) <= int_stop_pos_1;
65     stop_pos(2) <= int_stop_pos_2;
66     stop_pos(3) <= int_stop_pos_3;
67     
68
69               
70     state_register: process(clk, reset)
71     begin
72         IF reset = '1' THEN
73           current_state <= idle ;
74         ELSIF clk = '0' and clk'event THEN  -- ! falling edge !
75            current_state <= next_state ;
76         END IF;
77     end process state_register;
78
79    --Folgezustandsberechnung asynchron
80     transition: process(current_state,
81                         start_endless_mode,
82                         start_read_stop_pos_mode,
83                         wait_cntr,
84                         cell_cntr,
85                         local_roi)
86         begin
87             CASE current_state IS
88                 WHEN idle =>           
89                     if start_endless_mode = '1' then
90                         next_state <= started_endless ;                                             
91                     elsif start_read_stop_pos_mode = '1' then
92                         next_state <= started_read_stop_pos ;
93                     end if;
94                     
95                   WHEN started_endless =>
96                     if cell_cntr = conv_std_logic_vector(1,10) then 
97                       next_state <= waiting_e;
98                     end if;
99                     
100                                                                       
101                                     
102                 WHEN started_read_stop_pos =>       
103                     if cell_cntr = conv_std_logic_vector(1,10) then 
104                       next_state <= waiting_r;
105                     end if;
106                     
107                 WHEN waiting_e =>       
108                     if wait_cntr = conv_std_logic_vector(0,3) then
109                       next_state <= running_e;
110                     else 
111                       next_state <= waiting_e;
112                     end if;
113
114                 WHEN waiting_r =>       
115                     if wait_cntr = conv_std_logic_vector(0,3) then
116                       next_state <= running_r;
117                     end if;
118
119                     
120                   WHEN running_e =>
121                      IF (start_endless_mode = '0') THEN
122                        next_state <= idle;
123                      END IF;
124                 
125                  WHEN running_r =>
126                    if cell_cntr >= local_roi THEN
127                     next_state <= idle;
128                  end if;                           
129     END CASE;
130     end process transition;
131
132     output_proc: process(current_state) --Ausgangsberechnung synchron, da current_state sich nur synchron aendert
133         begin
134             case current_state is
135
136                 when idle =>
137                    local_roi <= (others => '0');
138                    flag_read_stop_pos <= '0';
139                    stop_pos_valid <= '1'; 
140                    LEN <= '0'; CEN <= '0';
141                    busy <= '0';
142                    cc_en <= '0'; cc_reset <= '1';
143                    wc_en <= '0'; wc_reset <= '0';
144
145                 when started_endless =>
146                     local_roi <= "0111111111";
147                     flag_read_stop_pos <= '0';
148                     stop_pos_valid <= '0';
149                     LEN <= '1'; CEN <= '0';
150                     busy <= '1';
151                     cc_en <= '1'; cc_reset <= '0';
152                     wc_en <= '0'; wc_reset <= '1';
153
154                 when started_read_stop_pos =>
155                     local_roi <= conv_std_logic_vector(11,10);
156                     flag_read_stop_pos <= '1';
157                     stop_pos_valid <= '0';
158                     LEN <= '1'; CEN <= '0';
159                     busy <= '1';
160                     cc_en <= '1'; cc_reset <= '0';
161                     wc_en <= '0'; wc_reset <= '1';
162 
163                 when waiting_e | waiting_r =>
164                     local_roi <= local_roi;
165                     stop_pos_valid <= '0'; 
166                     busy <= '1';
167                     LEN <= '0'; CEN <= '0';
168                     cc_en <= '0'; cc_reset <= '0';
169                     wc_en <= '1'; wc_reset <= '0';
170 
171                 when running_e =>
172                     flag_read_stop_pos <= '0';
173                     stop_pos_valid <= '0'; 
174                     LEN <= '0'; CEN <= '1';
175                     cc_en <= '1'; cc_reset <= '0';
176                     wc_en <= '0'; wc_reset <= '0';
177                     busy <= '1';
178
179              when running_r =>
180                    flag_read_stop_pos <= '1';
181                     stop_pos_valid <= '0'; 
182                     LEN <= '0'; CEN <= '1';
183                     cc_en <= '1'; cc_reset <= '0';
184                     wc_en <= '0'; wc_reset <= '0';
185                     busy <= '1';
186             end case;
187     end process output_proc;
188
189
190     cellcounter: process (clk, cc_reset) begin
191
192         if (cc_reset = '1') then
193           cell_cntr <= (others=>'0');
194         elsif (rising_edge(clk)) then
195           if (cc_en = '1') then
196             cell_cntr <= cell_cntr + 1;
197           end if;
198         end if;
199
200     end process cellcounter;
201
202
203     waitcounter: process (clk, wc_reset) begin
204         if (wc_reset = '1') then
205           wait_cntr <= "011"; -- RSRLOAD -> warte 3 -> SRCLK
206         elsif (rising_edge(clk)) then
207           if (wc_en = '1') then
208             wait_cntr <= wait_cntr - 1;
209           end if;
210         end if;
211     end process waitcounter;
212
213  -- laut DRS4_rev09.pdf Seite 13 Figure 15
214  -- funktioniert das auslesen der Stop bzw. Startadresse so:
215  -- Sende 1x RSRLOAD- und mind. 9 SRCLK- pulse und sample SROUT zur
216  -- steigenden Flanke von SRCLK.
217  -- MSB first LSB last, kommen dann die 10 bits,
218  -- die die Stopposition darstellen.
219  --
220  -- diese Architecture liefert immer dann eine steigende Flanke
221  -- auf RSRCLK, wenn CLK eine steigende Flanke hat und CEN='1' ist.
222  -- Die an SROUT zur steigenden Flanke anliegenden Werte werden wie in einem Schieberegister
223  -- Schritt fuer Schritt in die stop_pos_x vectoren geschoben.
224  --
225  -- wenn sie 10 schritte weit reingschoben wurden, ist der process fertig.
226  -- es gibt keinen eigenen counter fuer die 10 schritte, der cell counter kann hier
227  -- missbraucht werden.
228  --
229  -- da der process eine steigende flanke auf SRCLK braucht um SROUT zu sampeln
230  -- wird im Prinzip ein Puls aud SRCLK *zuviel* erzeugt, das ist aber egal...
231  --
232  stop_pos_reader: process (CEN, clk, flag_read_stop_pos)
233  begin
234    IF (flag_read_stop_pos = '1') THEN -- nur wenn ich im read_stop_mode bin, laeuft dieser process
235      IF (CEN = '1') THEN -- nur wenn CEN='1' ist kommen SRCLK pulse raus.
236        IF (rising_edge(CLK)) THEN -- wenn steigende Flanke, dann SROUT samplen.
237          int_stop_pos_0 <= int_stop_pos_0(8 downto 0) & SROUT_in_0;   
238          int_stop_pos_1 <= int_stop_pos_1(8 downto 0) & SROUT_in_1;   
239          int_stop_pos_2 <= int_stop_pos_2(8 downto 0) & SROUT_in_2;   
240          int_stop_pos_3 <= int_stop_pos_3(8 downto 0) & SROUT_in_3;   
241         
242        END IF; -- rising edge CLK
243      END IF; -- CEN ='1'
244    END IF; -- flag_read_stop_pos = '1'
245  end process stop_pos_reader; 
246 
247end behavior;
Note: See TracBrowser for help on using the repository browser.