library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

library UNISIM;
use UNISIM.VComponents.all;

entity Sort_Four is
generic(
wigth : natural := 16);
Port (
clk : in std_logic;
in_word : in std_logic_vector((4*wigth - 1) downto 0);
----
out_index : out std_logic_vector(1 downto 0);
out_data : out std_logic_vector((wigth - 1) downto 0));
end Sort_Four;

architecture Behavioral of Sort_Four is

-----------------------------------------------------------
-----------------------------------------------------------
attribute syn_hier : string;
attribute syn_hier of Behavioral : architecture is "hard";

attribute syn_keep : boolean;
-----------------------------------------------------------
-----------------------------------------------------------
type word_type is array (0 to 3) of std_logic_vector((wigth - 1) downto 0);
signal word, word_1d : word_type;

signal sub_0f : std_logic_vector(1 downto 0);
signal word_mux_st, word_mux_ml : std_logic_vector((wigth - 1) downto 0);
signal sub_1f : std_logic;
signal sub_general : std_logic_vector(2 downto 0);

-- signal data_1d, data : std_logic_vector((order - 1) downto 0);

-----------------------------------------------------------
-----------------------------------------------------------

begin


-----------------------------------------------------------
-----------------------------------------------------------
process (clk)
begin
if (clk = '1' and clk'event) then
for i in 0 to 3 loop
word_1d(i) <= in_word(((i + 1)*wigth - 1) downto i*wigth);
word(i) <= word_1d(i);
end loop;
end if;
end process;

-----------------------------------------------------------
-----------------------------------------------------------
process (word)
variable sub_w32_temp, sub_w10_temp : std_logic_vector((wigth - 1) downto 0);
begin
sub_w32_temp := (word(3) + (not word(2)) + 1);
sub_w10_temp := (word(1) + (not word(0)) + 1);
sub_0f <= (sub_w32_temp(wigth - 1)&sub_w10_temp(wigth - 1));
end process;

word_mux_st <= word(3) when sub_0f(1) = '1' else word(2);
word_mux_ml <= (not word(1)) when sub_0f(0) = '1' else (not word(0));

-----------------------------------------------------------
-----------------------------------------------------------
process (word_mux_st, word_mux_ml)
variable word_mux_temp : std_logic_vector((wigth - 1) downto 0);
begin
word_mux_temp := (word_mux_st + word_mux_ml + 1);
sub_1f <= word_mux_temp(wigth - 1);
end process;


-----------------------------------------------------------
-----------------------------------------------------------
-- process (clk)
-- begin
-- if (clk = '1' and clk'event) then
-- if sub_1f = '1' then
-- if sub_0f(1) = '1' then
-- data_1d <= word(3);
-- else
-- data_1d <= word(2);
-- end if;
-- else
-- if sub_0f(0) = '1' then
-- data_1d <= word(1);
-- else
-- data_1d <= word(0);
-- end if;
-- end if;
-- data <= data_1d;
-- end if;
-- end process;

-- out_data <= data;
-----------------------------------------------------------
-----------------------------------------------------------
sub_general <= (sub_1f&sub_0f);
process (sub_general, word)
begin
case sub_general is
when "000" => out_data <= word(0);
out_index <= "00";
when "001" => out_data <= word(0);
out_index <= "00";
when "010" => out_data <= word(1);
out_index <= "01";
when "011" => out_data <= word(1);
out_index <= "01";
when "100" => out_data <= word(2);
out_index <= "10";
when "101" => out_data <= word(2);
out_index <= "10";
when "110" => out_data <= word(3);
out_index <= "11";
when "111" => out_data <= word(3);
out_index <= "11";
when others => null;
end case;
end process;


end Behavioral;

// next all
...

// calculate
...

Process (all)
begin
if rst = '1' then
reg_cnt <= (OTHERS => '0');  
elsif clk='1' and clk'event then
if reg_cnt =  std_logic_vector(to_unsigned(0, cnt 'length))) then
   reg_cnt <= load_cnt;  
  else
   reg_cnt <= reg_cnt -  std_logic_vector(to_unsigned(1, cnt 'length)));
end if;
end if;
end process;

reg [7:0] cnt;

always@(posedge iclk) begin
  if (rst)               cnt <= '0;
  else if (~&cnt)    cnt <= cnt + 1'b1;
end

always_comb begin
  strb0 = cnt == 10;
  strb1 = cnt == 12;
  ...
end

`define LENTH 28
`define VAR5

`ifdef VAR1
`define TIM1
`elsif VAR2
`define TIM1
`elsif VAR3
`define TIM1
`else
`define TIM2
`endif

module Timer_m
`ifdef TIM1
(
(* chip_pin = "91",
altera_attribute = "-name global_signal on; -name io_standard lvds" *)
input bit clk, // high-speed clock
input bit [`LENTH-1:0] rld, // reload data
output bit pls // timer overload pulse
);
`endif

`ifdef VAR1
bit [`LENTH:0] cnt;
always_ff @(posedge clk) begin
if (cnt[`LENTH]) cnt <= {1'b0, rld};
else cnt <= cnt - 1;
end
assign pls = cnt[`LENTH];

`elsif VAR2
bit [`LENTH-1:0] cnt;
always_ff @(posedge clk) begin
if (cnt[`LENTH-1]) cnt <= rld;
else cnt <= cnt - 1;
end
assign pls = cnt[`LENTH-1];

`elsif VAR3
bit [`LENTH-1:0] cnt;
always_ff @(posedge clk) begin
if (cnt[`LENTH-1]) cnt <= rld;
else cnt <= cnt[`LENTH-2:0] - 1;
end
assign pls = cnt[`LENTH-1];
`endif

`ifdef TIM2
(
(* chip_pin = "91",
altera_attribute = "-name global_signal on; -name io_standard lvds" *)
input bit clk, // high-speed clock
input bit [`LENTH-1:0] rld, // reload data
input bit ldp, // load pulse
output bit pls // timer overload pulse
);
`endif

`ifdef VAR4
bit [`LENTH:0] cnt;
always_ff @(posedge clk) begin
if (cnt[`LENTH]) cnt <= {ldp, rld};
else cnt <= cnt[`LENTH-1:0] - 1;
end
assign pls = cnt[`LENTH];
`endif

`ifdef VAR5
bit [`LENTH-1:0] cnt;
always_ff @(posedge clk) begin
if (pls) {pls, cnt} <= {ldp, rld};
else {pls, cnt} <= cnt - 1;
end
`endif

endmodule : Timer_m

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.NUMERIC_STD.ALL;

ENTITY KAA_COUNTER_ENA_SCLR IS
GENERIC
(
DIRECTION : STRING := "UP"; -- UP / DOWN Направление счета
MAX_VALUE : INTEGER := 127 -- До скольки считает счетчик(от нуля до MAX_VALUE)
);
PORT
(
CLK : IN STD_LOGIC;
ENA : IN STD_LOGIC;
SCLR : IN STD_LOGIC;
DATA_OUT : OUT INTEGER RANGE 0 TO MAX_VALUE
);
END ENTITY;

ARCHITECTURE RTL OF KAA_COUNTER_ENA_SCLR IS
--=====================================================================
-- Функция определения разрядности шины - логарифм по основанию 2
--=====================================================================
FUNCTION LOG2 (MAX_VALUE : INTEGER) RETURN INTEGER IS -- Функция вычесления логарифма по основанию 2 для определения разрядности
VARIABLE CNT : INTEGER := 0; -- Счетчик для подсчета количества делений на 2
VARIABLE TEMP : INTEGER := MAX_VALUE + 1; -- Делимое - это максимальное количество СОСТОЯНИЙ счетчика
BEGIN
WHILE (TEMP > 1) LOOP -- Пока делимое больше 1 совершаем цикл деления на 2
CNT := CNT + 1 ; -- Считаем количество циклов деления
TEMP := TEMP/2; -- Делим число на 2 каждый цикл
END LOOP;
RETURN CNT; -- Значение счетчика и есть логарифм
END LOG2;

SIGNAL COUNTER_INTEGER : INTEGER RANGE 0 TO MAX_VALUE := 0; -- Счетчик обнуляемый условием максимального счета
SIGNAL COUNTER_UNSIGNED : UNSIGNED(LOG2(MAX_VALUE)-1 DOWNTO 0) := (others => '0'); -- Счетчик с автомватическим обнулением при переполнении
BEGIN

--================================================================================
==========================
-- Если максимальное значение счетчика переведенное в двоичное число не состоит из одних только единиц
-- Значит у нас счетчик обнуляется значением максимального счета т.е до наступления переполнения разрядов
--================================================================================
==========================
COUNTER_INTEGER_GEN : IF ( TO_UNSIGNED(MAX_VALUE,LOG2(MAX_VALUE) ) /= ( LOG2(MAX_VALUE)-1 DOWNTO 0 => '1' ) ) GENERATE
CNT_PROC : PROCESS
(
CLK
)
BEGIN
IF (RISING_EDGE(CLK)) THEN
--==========================================================================
-- Генерируем суммирующий счетчик обнуляющийся максимальным значением счета
--==========================================================================
IF (DIRECTION = "UP") THEN -- Если направление счета "вверх" генерируется суммирующий счетчик
IF (ENA = '1') THEN -- При активном сигнале разрешения раблоты
IF (COUNTER_INTEGER = MAX_VALUE) THEN -- При наступлении максимального значения счетчика
COUNTER_INTEGER <= 0; -- Обнулим его
ELSE
COUNTER_INTEGER <= COUNTER_INTEGER + 1; -- Иначе будем его инкрементировать
END IF;
END IF;
IF (SCLR = '1') THEN -- При активном синхронном сбросе
COUNTER_INTEGER <= 0; -- Сбросим счетчик в ноль
END IF;
END IF;
--==========================================================================
-- Генерируем вычитающий счетчик обнуляющийся максимальным значением счета
--==========================================================================
IF (DIRECTION = "DOWN") THEN -- Если направление счета "вниз" то генерируется вычитающий счетчик
IF (ENA = '1') THEN -- При активном сигнале разрешения раблоты
IF (COUNTER_INTEGER = 0) THEN -- При наступлении максимального значения счетчика
COUNTER_INTEGER <= MAX_VALUE; -- Обнулим его
ELSE
COUNTER_INTEGER <= COUNTER_INTEGER - 1; -- Иначе будем его декрементировать
END IF;
END IF;
IF (SCLR = '1') THEN -- При активном синхронном сбросе
COUNTER_INTEGER <= MAX_VALUE; -- Сбросим счетчик в максимальное значение
END IF;
END IF;
END IF;
END PROCESS;
DATA_OUT <= COUNTER_INTEGER; -- Выдадим значение счетчика на выходные порты модуля
END GENERATE;

--================================================================================
==========================
-- Если максимальное значение счетчика это (2**N - 1)
-- Значит у нас полный счетчик, который обнуляется переполнением разрядов
--================================================================================
==========================
COUNTER_UNSIGNED_GEN : IF ( TO_UNSIGNED(MAX_VALUE,LOG2(MAX_VALUE) ) = ( LOG2(MAX_VALUE)-1 DOWNTO 0 => '1' ) ) GENERATE
CNT_PROC : PROCESS
(
CLK
)
BEGIN
IF (RISING_EDGE(CLK)) THEN
--==========================================================================
-- Генерируем суммирующий счетчик обнуляющийся переполнением разрядов
--==========================================================================
IF (DIRECTION = "UP") THEN -- Если направление счета "вверх" генерируется суммирующий счетчик
IF (ENA = '1') THEN -- При активном сигнале разрешения раблоты
COUNTER_UNSIGNED <= COUNTER_UNSIGNED + "1"; -- Инкрементируем его каждый такт
END IF;
IF (SCLR = '1') THEN -- При активном синхронном сбросе
COUNTER_UNSIGNED <= (OTHERS => '0'); -- Сбросим счетчик в ноль
END IF;
END IF;
--==========================================================================
-- Генерируем вычитающий счетчик обнуляющийся переполнением разрядов
--==========================================================================
IF (DIRECTION = "DOWN") THEN -- Если направление счета "вниз" то генерируется вычитающий счетчик
IF (ENA = '1') THEN -- При активном сигнале разрешения раблоты
COUNTER_UNSIGNED <= COUNTER_UNSIGNED - "1"; -- Декрементируем его каждый такт
END IF;
IF (SCLR = '1') THEN -- При активном синхронном сбросе
COUNTER_UNSIGNED <= TO_UNSIGNED(MAX_VALUE,LOG2(MAX_VALUE) ); -- Сбросим счетчик в единицы
END IF;
END IF;
END IF;
END PROCESS;
DATA_OUT <= TO_INTEGER(COUNTER_UNSIGNED); -- Выдадим значение счетчика на выходные порты модуля
END GENERATE;
END ARCHITECTURE;

x and (x - 1) = 0