DFFE ff_all[3:0] (.d(Din), .ena(ena), .clk(clk_GN), .q(iDin));

always_ff@(posedge adc_mclk_mux or negedge rst_i) begin 27,648 MHz
    if (!rst_i) counter<='0;
    else if (!TRIG3_stb && TRIG3_rg_n)   counter<=32'd0; //start condition
    else counter<=counter+1'b1;
end

always_ff@(negedge adc_mclk_mux or negedge rst_i) begin
    if (!rst_i) cnt_rg_HADC<='0;
        else if (!ff_hold) cnt_rg_HADC<=counter;
end

always_ff@(posedge clk_i or negedge rst_i) begin
    if (!rst_i) fHold_value<='0;
        else if (!IOMS && !LRD) begin
                  if         (LA==pIOMS_ADC_CTRL_CNTR_L)    fHold_value<='0; //LSB      
                  else if    (LA==pIOMS_PXI_MUX_CNTR_H)      fHold_value<='1; //MSB        
        end                                         
end


always_ff@(negedge adc_mclk_mux or negedge rst_i) begin//posedge
if (!rst_i)  ff_hold<='0;
else if ( fHold_value && IOMS)  ff_hold<='1;
else if (!fHold_value && IOMS)  ff_hold<='0;

end

reg [3:0] dffe_rg = 4'h0;

always @(posedge clk_GN)
begin
if (ena)        dffe_rg  <= Din
end

module lc(input in, output out);
  LCELL l (.in(in), .out(out));
endmodule

wire [7:0] p, q;
lc lcq[7:0] (p, q);

always_ff @ (posedge clk)
    if (ena) iDin <= Din;

library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;

entity FIFO is
generic (Addr_Size : natural := 3; -- Разрядность адреса (глубина FIFO)
Data_Size : natural := 32); -- Разрядность данных
port (RST : in std_logic; -- Сброс
CLK_WR : in std_logic; -- Тактовый сигнал для записи
WE : in std_logic; -- Разрешение записи (Write Enable)
Data_WR : in std_logic_vector(Data_Size - 1 downto 0); -- Данные, записываемые в буфер
CLK_RD : in std_logic; -- Тактовый сигнал для чтения
RE : in std_logic; -- Разрешение чтения (Read Enable)
Data_RD : out std_logic_vector(Data_Size - 1 downto 0); -- Данные, читаемые из буфера
Full : out std_logic; -- Флаг того, что буфер полон
Empty : out std_logic); -- Флаг того, что буфер пуст
end entity FIFO;


architecture RTL of FIFO is

type FIFO_RAM_Type is array (0 to 2**Addr_Size - 1) of std_logic_vector(Data_Size - 1 downto 0);
signal FIFO_RAM : FIFO_RAM_Type;

--================================================================================
================================================--
-- Функция преобразования из двоичного кода в код Грея: --
--================================================================================
================================================--
function Bin_to_Gray (D: unsigned) return unsigned is
variable Q : unsigned(D'range);
begin
Q := ('0' & D(D'high downto 1)) xor D;
return Q;
end function Bin_to_Gray;
--================================================================================
================================================--


--================================================================================
================================================--
-- Функция преобразования кода Грея в двоичный код: --
--================================================================================
================================================--
function Gray_to_Bin (D: in unsigned) return unsigned is
variable Q: unsigned(D'high downto D'low);
begin
Q(D'high) := D(D'high);
for i in D'high - 1 downto D'low loop
Q(i) := D(i) xor Q(i + 1);
end loop;
return Q;
end function;
--================================================================================
================================================--

signal Addr_Write_Gray : unsigned(Addr_Size downto 0); -- Адрес записи данных в буфер в коде Грея
signal Addr_Write_Gray_Next : unsigned(Addr_Size downto 0); -- Следующий адрес записи данных в буфер в коде Грея
signal Addr_Read_Gray : unsigned(Addr_Size downto 0); -- Адрес чтения данных из буфера в коде Грея

signal Addr_Write_Bin : unsigned(Addr_Size downto 0); -- Адрес записи данных в буфер в двоичном коде
signal Addr_Write_Bin_Next : unsigned(Addr_Size downto 0); -- Следующий адрес записи данных в буфер в двоичном коде
signal Addr_Read_Bin : unsigned(Addr_Size downto 0); -- Адрес чтения данных из буфера в двоичном коде

signal WE_Allow : std_logic; -- Разрешение записи данных в FIFO-буфер
signal RE_Allow : std_logic; -- Разрешение чтения данных из FIFO-буфера

signal Full_Match : std_logic; -- Сравнение адресов записи и чтения для флага того, что буфер полон
signal Empty_Match : std_logic; -- Сравнение адресов записи и чтения для флага того, что буфер пуст
begin

-- Адрес записи данных в буфер в двоичном коде: --
process(RST, CLK_WR)
begin
if (RST = '1') then
Addr_Write_Bin <= (others => '0');
elsif (Rising_Edge(CLK_WR)) then
if(WE_Allow = '1') then
Addr_Write_Bin <= Addr_Write_Bin + 1;
end if;
end if;
end process;

-- Следующий адрес записи данных в буфер в двоичном коде: --
process(RST, CLK_WR)
begin
if (RST = '1') then
Addr_Write_Bin_Next <= TO_UNSIGNED(1, Addr_Size + 1);
elsif (Rising_Edge(CLK_WR)) then
if(WE_Allow = '1') then
Addr_Write_Bin_Next <= Addr_Write_Bin_Next + 1;
end if;
end if;
end process;

-- Адрес записи данных в FIFO-буфер в коде Грея: --
Addr_Write_Gray <= Bin_to_Gray(Addr_Write_Bin);

-- Следующий адрес записи данных в буфер в коде Грея: --
Addr_Write_Gray_Next <= Bin_to_Gray(Addr_Write_Bin_Next);

-- Адрес чтения данных из буфера в двоичном коде: --
process(RST, CLK_RD)
begin
if (RST = '1') then
Addr_Read_Bin <= (others => '0');
elsif (Rising_Edge(CLK_RD)) then
if(RE_Allow = '1') then
Addr_Read_Bin <= Addr_Read_Bin + 1;
end if;
end if;
end process;

-- Адрес чтения данных из FIFO-буфера: --
Addr_Read_Gray <= Bin_to_Gray(Addr_Read_Bin);

-- Запись данных в FIFO-буфер: --
process
begin
wait until (rising_edge(CLK_WR));
if(WE_Allow = '1') then
FIFO_RAM(TO_INTEGER(Addr_Write_Gray(Addr_Size - 1 downto 0))) <= Data_WR;
end if;
end process;

-- Чтение данных из FIFO-буфера: --
process
begin
wait until (rising_edge(CLK_RD));
if(RE_Allow = '1') then
Data_RD <= FIFO_RAM(TO_INTEGER(Addr_Read_Gray(Addr_Size - 1 downto 0)));
end if;
end process;

-- Разрешение записи данных в FIFO-буфер: --
WE_Allow <= '1' when (WE = '1' and Full_Match = '0') else '0';

-- Разрешение чтения данных из FIFO-буфера: --
RE_Allow <= '1' when (RE = '1' and Empty_Match = '0') else '0';

-- Сравнение адресов записи и чтения для флага того, что буфер полон: --
Full_Match <= '1' when (Addr_Write_Bin(Addr_Size - 1 downto 0) = Addr_Read_Bin(Addr_Size - 1 downto 0) and Addr_Write_Bin(Addr_Size) /= Addr_Read_Bin(Addr_Size) and (RE = '0' or (RE = '1' and WE = '1'))) else '0';

-- Флаг того, что буфер полон: --
Full <= '1' when (Full_Match = '1' or (Addr_Write_Bin_Next(Addr_Size - 1 downto 0) = Addr_Read_Bin(Addr_Size - 1 downto 0) and Addr_Write_Bin_Next(Addr_Size) /= Addr_Read_Bin(Addr_Size) and (RE = '0' and WE = '1'))) else '0';

-- Сравнение адресов записи и чтения для флага того, что буфер пуст: --
Empty_Match <= '1' when (Addr_Write_Bin = Addr_Read_Bin and (WE = '0' or (RE = '1' and WE = '1'))) else '0';

-- Флаг того, что буфер пуст: --
Empty <= Empty_Match;
end architecture RTL;