module ad9613_rx #
(
   parameter   DIFF_TERM = "FALSE" // Parameter to enable internal differential termination
)
(
   // Данные
    input [ADC_WIDTH - 1 : 0] in_data_p,
    input [ADC_WIDTH - 1 : 0] in_data_n,
   // Синхронизация
    input in_dco_p,
    input in_dco_n,
    input in_adc_or_p,
    input in_adc_or_n,
    
    // Выходы
    output out_dclk,
    output reg [ADC_WIDTH - 1 : 0] out_data_0,
    output reg [ADC_WIDTH - 1 : 0] out_data_1
);

localparam ADC_WIDTH = 12;

wire w_dco_p;
wire w_dco_n;

wire w_dco_bufg_p;
wire w_dco_bufg_n;

wire [ADC_WIDTH - 1 : 0] w_rx_data_in;
wire [ADC_WIDTH - 1 : 0] w_rx_data_in_fix;

wire [ADC_WIDTH - 1 : 0] w_rx_data_0;
wire [ADC_WIDTH - 1 : 0] w_rx_data_1;

// Выходной клок
assign out_dclk = w_dco_bufg_p;

parameter     [ADC_WIDTH - 1 : 0] RX_SWAP_MASK = 12'h0000;    // pinswap mask for input bits (0 = no swap (default), 1 = swap). Allows inputs to be connected the wrong way round to ease PCB routing.

genvar     i;

// Входной буфер для клока (формирует дифференциальные сигналы
IBUFGDS_DIFF_OUT IBUFGDS_DIFF_OUT_ADC_DCO (
   .O(w_dco_p),   // Buffer diff_p output
   .OB(w_dco_n),  // Buffer diff_n output
   .I(in_dco_p),  // Diff_p buffer input (connect directly to top-level port)
   .IB(in_dco_n)  // Diff_n buffer input (connect directly to top-level port)
);

// Заводим в глобальную шину синхронизации
BUFG BUFG_ADC_DCO_P (
   .O(w_dco_bufg_p),   // 1-bit output: Clock buffer output
   .I(w_dco_p)    // 1-bit input: Clock buffer input
);

BUFG BUFG_ADC_DCO_N (
   .O(w_dco_bufg_n),   // 1-bit output: Clock buffer output
   .I(w_dco_n)    // 1-bit input: Clock buffer input
);

// Генерация входных буферов
generate
for (i = 0; i < ADC_WIDTH; i = i + 1)
begin : loop0

  
   // Входной дифф. буфер
   IBUFDS #(
      .DIFF_TERM         (DIFF_TERM))
   data_in (
      .I                (in_data_p[i]),
      .IB               (in_data_n[i]),
      .O                 (w_rx_data_in[i])
      );
      
   // При необходимости проводим инверсию данных  
   assign w_rx_data_in_fix[i] = w_rx_data_in[i] ^ RX_SWAP_MASK[i]; // Invert data signals as required
  
   // DDR
   IDDR2 #(
      .DDR_ALIGNMENT("C0")          // Sets output alignment to "NONE", "C0" or "C1"      
   ) IDDR2_D0D1 (
      .Q0 ( w_rx_data_0[i] ),       // 1-bit output captured with C0 clock
      .Q1 ( w_rx_data_1[i] ),       // 1-bit output captured with C1 clock
      .C0 ( w_dco_p),               // 1-bit clock input
      .C1 ( w_dco_n),               // 1-bit clock input
      .CE (1'b1),                   // 1-bit clock enable input
      .D  (w_rx_data_in_fix[i]),    // 1-bit DDR data input
      .R  (1'b0),                   // 1-bit reset input
      .S  (1'b0)                    // 1-bit set input
   );
  
end
endgenerate

// Защелкиваем выходные данные
always @(posedge out_dclk)
begin
   out_data_0 <= w_rx_data_0;
   out_data_1 <= w_rx_data_1;
end

endmodule

module bin_correlator #
(
   parameter SPS        = 40,
   parameter CODE       = 11'b11100010010,
   parameter CODE_WIDTH = 11,
   parameter TRESHOLD   = SPS*CODE_WIDTH - 2*CODE_WIDTH
)
(
    input in_clk,
    input in_data,
    input in_reset,
    input in_enable,
    output reg out_threshold,
    output reg out_peak,
    output reg [CODE_WIDTH - 1 : 0] out_data
);

// Ширина регистра с задержанными данными
localparam D_WIDTH   = SPS*(CODE_WIDTH + 1);
localparam SUM_WIDTH = 8;
localparam MUL_WIDTH = 10;

// Буфер для сохранения задержанных двоичных данных
reg [D_WIDTH - 1 : 0] delayed_buf;

// Буфер с суммами на отсчет
reg signed [SUM_WIDTH - 1 : 0] sum_buf [CODE_WIDTH-1 : 0];

// Буфер с корреляционными произведениями
reg signed [SUM_WIDTH - 1 : 0] corr_mul_buf [CODE_WIDTH-1 : 0];

// Буфер, хранящий значения вычисленных ВКФ
reg signed [MUL_WIDTH - 1 : 0] sum_mul;

// Буфер с добавками к сумме
reg signed [2 : 0] add_buf [CODE_WIDTH-1 : 0];

// Буфер с кодом свертки
reg [CODE_WIDTH-1 : 0] code = CODE;

reg _is_old_threshold;
reg signed [MUL_WIDTH - 1 : 0] _old_corr_func;  //
reg signed [MUL_WIDTH - 1 : 0] _corr_func;      //
wire _is_threshold = (_corr_func >= TRESHOLD);

integer i;

initial
begin
   reset_task();
end

    
always @(posedge in_clk)
begin
   if(in_reset)
   begin
      reset_task();
   end
   else
   begin
      process_task();
   end
end

// Процесс обработки данных
task process_task;
   begin
      // Сдвиг данных в регистр
     delayed_buf <= {delayed_buf[D_WIDTH - 2 : 0], in_data};
      
     sum_mul = 0;
    
     // Вычисление сумм на символ
     for(i = 0; i < CODE_WIDTH; i = i + 1)
     begin
        
         // Вычисление добавки к символу
         add_buf[i] <= $signed({delayed_buf[i*SPS], 1'b1}) - $signed({delayed_buf[(i + 1)*SPS], 1'b1});
        
         // Вычисление суммы на символ
         sum_buf[i] <= sum_buf[i] + add_buf[i];
        
         // Вычисление значений символа
         out_data[i] <= $signed(sum_buf[i]) < $signed(0);
        
         // Вычисление корреляционных произведений
         corr_mul_buf[i] <= code[i] ? -sum_buf[i] : sum_buf[i];
        
         // Выисление суммы корреляционных произведений
         sum_mul    = sum_mul + corr_mul_buf[i];
     end
      
      //
      _corr_func     <= sum_mul;
      
      //
      out_threshold <= (sum_mul >= TRESHOLD);
      
      // Save old Function State
      _old_corr_func     <= _corr_func;
      
      // Save old threshold state
      _is_old_threshold <= _is_threshold;
      
      // Correlation Peak
     out_peak   <= (_is_old_threshold) & (_corr_func < _old_corr_func);

end
endtask

// Процесс сброса
task reset_task;
   begin
      code <= CODE;
      for(i = 0; i < SPS*CODE_WIDTH + 1; i = i + 1)
      begin
         delayed_buf[i] <= 1'b0;
      end;
      for(i = 0; i < CODE_WIDTH; i = i + 1)
      begin
         sum_buf[i] <= SPS - 1;
         add_buf[i] <= 0;
         out_data   <= 0;
      end
   end
endtask



endmodule

# ADC DCO
NET "ADC_DCO_P" TNM_NET = "ADC_DCO";
NET "ADC_DCO_N" TNM_NET = "ADC_DCO";
TIMESPEC TS_ADC_DCO = PERIOD "ADC_DCO" 120 MHz HIGH 50 %;

#PIN "ADC_D_*" TNM =  "GRP_ADC_DATA";
#TIMEGRP "GRP_ADC_DATA" OFFSET = IN 3 ns BEFORE "ADC_DCO" RISING;
#TIMEGRP "GRP_ADC_DATA" OFFSET = IN 3 ns BEFORE "ADC_DCO" FALLING;