daq_collector.vhd

Go to the documentation of this file.

----------------------------------------------------------------------------------
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
use IEEE.STD_LOGIC_ARITH.CONV_STD_LOGIC_VECTOR;

LIBRARY work;
use work.CMXpackage.all;
use work.CMX_flavor_package.all;


entity daq_collector is
  port (
    clk               : in std_logic;
    datai               : in arr_4Xword(max_jems-1 downto 0);
    energy_remote     : in std_logic_vector(26*4-1 downto 0);  
    energy_local      : in std_logic_vector(26*4-1 downto 0);
    energy_total      : in arr_ctr_15bit(5 downto 0);
    energy_ovflw      : in std_logic_vector(5 downto 0);
    energy_extra0     : in std_logic_vector(23 downto 0);
    energy_extra1     : in std_logic_vector(23 downto 0);
    data_in_daq       : out arr_96(19 downto 0);
    BCID_in     : in std_logic_vector(11 downto 0);
    BCID_delayed : out std_logic_vector(11 downto 0));  
end daq_collector;

architecture Behavioral of daq_collector is

  component parity_gen 
    GENERIC( 
      width : integer := 60
      );
    PORT( 
      din    : IN     std_logic_vector (width-1 downto 0) ;
      parity : OUT    std_logic 
      );
  end component;
  
-- signal declarations

  attribute keep : string;  
  
  signal datai_r          : arr_4Xword(max_jems-1 downto 0);
  signal energy_remote_r  : std_logic_vector(26*4-1 downto 0);   
  signal energy_remote_rr : std_logic_vector(26*4-1 downto 0);   
  signal energy_local_r   : std_logic_vector(26*4-1 downto 0);
  signal energy_local_rr  : std_logic_vector(26*4-1 downto 0);
  signal energy_total_r   : arr_ctr_15bit(5 downto 0);
  signal energy_total_rr  : arr_ctr_15bit(5 downto 0);
  signal energy_ovflw_r   : std_logic_vector(5 downto 0);
  signal energy_ovflw_rr  : std_logic_vector(5 downto 0);
  signal energy_extra0_r  : std_logic_vector(23 downto 0);
  signal energy_extra1_r  : std_logic_vector(23 downto 0);
  signal energy_extra0_rr : std_logic_vector(23 downto 0);
  signal energy_extra1_rr : std_logic_vector(23 downto 0);
  
  signal datai_corr       : arr_4Xword(max_jems-1 downto 0);
  signal calc_par         : calc_parity_type(max_jems-1 downto 0);
  signal par_err          : calc_parity_type(max_jems-1 downto 0);
  
  signal par_calc_cbla_mux0 : std_logic;
  signal par_calc_cbla_mux1 : std_logic;
  signal par_calc_cblb_mux0 : std_logic;
  signal par_calc_cblb_mux1 : std_logic;
  
  signal par_err_cbla_mux0 : std_logic;
  signal par_err_cbla_mux1 : std_logic;
  signal par_err_cblb_mux0 : std_logic;
  signal par_err_cblb_mux1 : std_logic;

  signal BCID_r : std_logic_vector(11 downto 0);

  
  attribute keep of datai_r, energy_remote_r, energy_local_r, energy_total_r, energy_ovflw_r, energy_extra0_r, energy_extra1_r  : signal is "TRUE";

  
begin

  --first register all data locally, and everything except data_i doublr reg
  --data_i_r will have parity error added synchroneously below
  process(clk)
  begin
    if rising_edge(clk) then

      BCID_delayed<=BCID_r;
      BCID_r<=BCID_in;

      datai_r         <= datai;       
      energy_remote_r <= energy_remote;
      energy_local_r  <= energy_local;
      energy_total_r  <= energy_total; 
      energy_ovflw_r  <= energy_ovflw;
      energy_extra0_r <= energy_extra0; 
      energy_extra1_r <= energy_extra1;


      energy_remote_rr <= energy_remote_r;
      energy_local_rr  <= energy_local_r;
      energy_total_rr  <= energy_total_r;
      energy_ovflw_rr  <= energy_ovflw_r;
      energy_extra0_rr <= energy_extra0_r; 
      energy_extra1_rr <= energy_extra1_r;
      
    end if;
  end process;

  
  par_err_i: for i in 0 to max_jems-1 generate
    par_err_j: for j in 0 to 3 generate
      
      calc_par_i : parity_gen
        generic map (
          width  => 23
          )
        port map (
          din  => datai_r (i)((24*j)+22 downto 24*j),
          parity  => calc_par(i)(j)
          );

      par_err(i)(j) <= calc_par(i)(j) xor datai_r(i)((24*j)+23);   -- parity error 

      
      process(clk)
      begin
        if rising_edge(clk) then
          datai_corr(i)((24*j)+23 downto 24*j) <=  par_err(i)(j) & datai_r(i)((24*j)+22 downto 24*j);
        end if;
      end process;

      
    end generate;
  end generate; 
  
  
  calc_par_cbla_mux0 : parity_gen     -- parity bit calc. (cbla,mux0)
    generic map (
      width  => 25
      )
    
    
    port map (
      din  => energy_remote_r(24 downto 0),
      parity  => par_calc_cbla_mux0
      );

  calc_par_cbla_mux1 : parity_gen     -- parity bit calc. (cbla,mux1)
    generic map (
      width  => 25
      )
    port map (
      din  => energy_remote_r(50 downto 26),
      parity  => par_calc_cbla_mux1
      );

  -- overflow bit added by Pawel Plucinski 2015-08-21
  calc_par_cblb_mux0 : parity_gen     -- parity bit calc. (cblb,mux0)
    generic map (
      width  => 23 
      )
    port map (
      din  => energy_remote_r(74) & -- overflow YR    
               energy_remote_r(73) & -- overflow XR
                 energy_remote_r(72) & -- overflow Y
                 energy_remote_r(71) & -- overflow X
               energy_remote_r(70 downto 52),
      parity  => par_calc_cblb_mux0    
      );

  -- overflow bit added by Pawel Plucinski 2015-08-21
  calc_par_cblb_mux1 : parity_gen     -- parity bit calc. (cblb,mux1)
    generic map (
      width  => 21
      )
    port map (
      din  => energy_remote_r(98) & -- overflow TR
               energy_remote_r(97) & -- overflow T 
               energy_remote_r(96 downto 78),
      parity  => par_calc_cblb_mux1    
      );

  process(clk)
  begin
    if rising_edge(clk) then
      par_err_cbla_mux0 <=  par_calc_cbla_mux0 xor energy_remote_r(25);   -- parity error (cbla,mux0)
      par_err_cbla_mux1 <=  par_calc_cbla_mux1 xor energy_remote_r(51);   -- parity error (cbla,mux1)

      par_err_cblb_mux0 <=  par_calc_cblb_mux0 xor energy_remote_r(77);   -- parity error (cblb,mux0)
      par_err_cblb_mux1 <=  par_calc_cblb_mux1 xor energy_remote_r(103);   -- parity error (cblb,mux1)
    end if;
  end process;

--
-- backplane data
--

  gen_daq_data: for i_source in 0 to max_jems-1 generate
    data_in_daq(i_source)<=datai_corr(i_source);
  end generate gen_daq_data;
  
--
-- remote energy  
--
  data_in_daq(16)(14 downto 0)  <= energy_remote_rr(14 downto 0);   -- Ex(15b) 
  data_in_daq(16)(15)           <= par_err_cbla_mux0;               -- parity error, cbla, mux0
  data_in_daq(16)(30 downto 16) <= energy_remote_rr(40 downto 26);  -- Ex(restricted eta range,15b)
  data_in_daq(16)(31)           <= par_err_cbla_mux1;               -- parity error (cbla,mux1)
  data_in_daq(16)(32)           <= energy_remote_rr(71);            -- overflow Ex

  data_in_daq(16)(47 downto 33) <= energy_remote_rr(66 downto 52);  -- Ey(15b)
  data_in_daq(16)(48)           <= par_err_cblb_mux0;               -- parity error, cblb, mux0 
  data_in_daq(16)(63 downto 49) <= energy_remote_rr(92 downto 78);  -- Ey(restricted eta range,15b)  
  data_in_daq(16)(64)           <= par_err_cblb_mux1;               -- parity error (cblb,mux1)
  data_in_daq(16)(65)           <= energy_remote_rr(72);            -- Overflow Ey
  
  data_in_daq(16)(75 downto 66) <= energy_remote_rr(24 downto 15);  -- Et(10b)
  data_in_daq(16)(79 downto 76) <= energy_remote_rr(70 downto 67);  -- Et(4b)
  data_in_daq(16)(80)           <= '0';                             -- zero
  data_in_daq(16)(90 downto 81) <= energy_remote_rr(50 downto 41);  -- Et(weighted,10b)
  data_in_daq(16)(94 downto 91) <= energy_remote_rr(96 downto 93);  -- Et(weighted,4b) 
  data_in_daq(16)(95)           <= energy_remote_rr(97);            -- Overflow Et

--
-- energy local  
--

  data_in_daq(17)(14 downto 0)  <= energy_local_rr(14 downto 0);   -- Ex(15b) 
  data_in_daq(17)(15)           <= '0';
  data_in_daq(17)(30 downto 16) <= energy_local_rr(40 downto 26);  -- Ex(restricted eta range,15b)
  data_in_daq(17)(31)           <= '0';
  data_in_daq(17)(32)           <= energy_local_rr(71);            -- overflow Ex
              
  data_in_daq(17)(47 downto 33) <= energy_local_rr(66 downto 52);  -- Ey(15b)
  data_in_daq(17)(48)           <= '0';
  data_in_daq(17)(63 downto 49) <= energy_local_rr(92 downto 78);  -- Ey(restricted eta range,15b)  
  data_in_daq(17)(64)           <= '0';
  data_in_daq(17)(65)           <= energy_local_rr(72);            -- Overflow Ey
              
  data_in_daq(17)(75 downto 66) <= energy_local_rr(24 downto 15);  -- Et(10b)
  data_in_daq(17)(79 downto 76) <= energy_local_rr(70 downto 67);  -- Et(4b)
  data_in_daq(17)(80)           <= '0';                             -- zero
  data_in_daq(17)(90 downto 81) <= energy_local_rr(50 downto 41);  -- Et(weighted,10b)
  data_in_daq(17)(94 downto 91) <= energy_local_rr(96 downto 93);  -- Et(weighted,4b) 
  data_in_daq(17)(95)           <= energy_local_rr(97);            -- Overflow Et

--
-- energy global  
--
-- 0 - sum ex ; 1 - sum ey, 2 -  sum et 
-- 3 - res sum ex ; 4 - res sum ey, 5 - res sum et

  data_in_daq(18)(14 downto 0)  <= std_logic_vector(energy_total_rr(0)); -- Ex(15b) 
  data_in_daq(18)(15)           <= '0';         
  data_in_daq(18)(30 downto 16) <= std_logic_vector(energy_total_rr(3)); -- Ex(Res,15b)
  data_in_daq(18)(31)           <= '0';  
  data_in_daq(18)(32)           <= energy_ovflw_rr(0);                   -- Overflow Ex

  data_in_daq(18)(47 downto 33) <= std_logic_vector(energy_total_rr(1)); -- Ey
  data_in_daq(18)(48)           <= '0';
  data_in_daq(18)(63 downto 49) <= std_logic_vector(energy_total_rr(4)); -- Ey(Res,15b)  
  data_in_daq(18)(64)           <= energy_ovflw_rr(2);                   -- Overflow Et;
  data_in_daq(18)(65)           <= energy_ovflw_rr(1);                   -- Overflow Ey
  
  data_in_daq(18)(80 downto 66) <= std_logic_vector(energy_total_rr(2)); -- Et(15b)
  data_in_daq(18)(95 downto 81) <= std_logic_vector(energy_total_rr(5)); -- Et(Res,15b)
  
--
-- energy extra and results
--
  
  data_in_daq(19)(12 downto 0)  <= (others =>'0');   
  data_in_daq(19)(36 downto 13) <= energy_extra0_rr(23 downto 0);   
  data_in_daq(19)(52 downto 37) <= energy_extra1_rr(15 downto 0);       
  data_in_daq(19)(95 downto 53) <= (others =>'0');
  
  
end Behavioral;