VHDL: создание очень медленных тактовых импульсов на основе очень быстрых тактовых импульсов

Если вам просто нужны часы для управления другой частью вашей логики в ПЛИС, простой ответ - использовать включение часов.

То есть запускайте свою медленную логику на тех же (быстрых) часах, что и все остальное, но используйте для нее медленное включение. Пример:

signal clk_enable_200kHz  : std_logic;
signal clk_enable_counter : std_logic_vector(9 downto 0);

--Create the clock enable:
process(clk_200MHz)
begin
  if(rising_edge(clk_200MHz)) then
    clk_enable_counter <= clk_enable_counter + 1;
    if(clk_enable_counter = 0) then
      clk_enable_200kHz <= '1';
    else
      clk_enable_200kHz <= '0';
    end if;
  end if;
end process;


--Slow process:
process(clk_200MHz)
begin
  if(rising_edge(clk_200MHz)) then
    if(reset = '1') then
      --Do reset
    elsif(clk_enable_200kHz = '1') then
      --Do stuff
    end if;
  end if;
end process;

Тем не менее, 200 кГц являются приблизительными, но указанное выше может быть расширено практически до любой частоты включения тактовой частоты, которая вам нужна. Кроме того, он должен поддерживаться напрямую аппаратным обеспечением FPGA в большинстве FPGA (по крайней мере, в частях Xilinx).

Стробированные часы - это почти всегда плохая идея, поскольку люди часто забывают, что они создают новые домены часов, и поэтому не принимают необходимых мер предосторожности при сопряжении сигналов между ними. Он также использует больше линий синхронизации внутри FPGA, поэтому вы можете быстро использовать все доступные линии, если у вас много стробированных часов.

Часы не лишены этих недостатков. Все работает в одном и том же тактовом домене (хотя и с разной скоростью), поэтому вы можете легко использовать одни и те же сигналы без каких-либо синхронизаторов или подобных.

Обратите внимание, что в этом примере работает эта строка,

сигнал clk_enable_counter: std_logic_vector (от 9 до 0);

должен быть изменен на

signal clk_enable_counter: беззнаковый (от 9 до 0);

и вам нужно будет включить эту библиотеку,

библиотека ieee; используйте ieee.numeric_std.all;

Оба сэмпла создают сигнал, один из которых переключается с медленной скоростью, а другой - с «медленным» импульсом узким импульсом. Если оба этих сигнала поступят на тактовые входы других триггеров, я бы ожидал предупреждений о неоптимальной маршрутизации тактовых импульсов.

Я не уверен, почему вы получаете предупреждение о закрытых часах, которое обычно появляется, когда вы это делаете:

gated_clock <= clock when en = '1' else '0';

Вот полный пример кода:

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

ENTITY Test123 IS

    GENERIC (
        clk_1_freq_generic : unsigned(31 DOWNTO 0) := to_unsigned(0, 32); -- Presented in Hz
        clk_in1_freq_generic : unsigned(31 DOWNTO 0) := to_unsigned(0, 32) -- Presented in Hz, Also
    );

    PORT (
        clk_in1 : IN std_logic := '0';
        rst1 : IN std_logic := '0';
        en1 : IN std_logic := '0';
        clk_1 : OUT std_logic := '0'
    );

END ENTITY Test123;

ARCHITECTURE Test123_Arch OF Test123 IS
    --
    SIGNAL clk_en_en : std_logic := '0';
    SIGNAL clk_en_cntr1 : unsigned(31 DOWNTO 0) := (OTHERS => '0');
    --
    SIGNAL clk_1_buffer : std_logic := '0';
    SIGNAL clk_1_freq : unsigned(31 DOWNTO 0) := (OTHERS => '0'); -- Presented in Hz, Also
    SIGNAL clk_in1_freq : unsigned(31 DOWNTO 0) := (OTHERS => '0'); -- Presented in Hz
    --
    SIGNAL clk_prescaler1 : unsigned(31 DOWNTO 0) := (OTHERS => '0'); -- Presented in Cycles (Relative To The Input Clk.)
    SIGNAL clk_prescaler1_halved : unsigned(31 DOWNTO 0) := (OTHERS => '0');
    --

BEGIN
    clk_en_gen : PROCESS (clk_in1)
    BEGIN
        IF (clk_en_en = '1') THEN

            IF (rising_edge(clk_in1)) THEN
                clk_en_cntr1 <= clk_en_cntr1 + 1;

                IF ((clk_en_cntr1 + 1) = clk_prescaler1_halved) THEN   -- a Register's (F/F) Output Only Updates Upon a Clock-Edge : That's Why This Comparison Is Done This Way !

                    clk_1_buffer <= NOT clk_1_buffer;
                    clk_1 <= clk_1_buffer;
                    clk_en_cntr1 <= (OTHERS => '0');

                END IF;

            END IF;

        ELSIF (clk_en_en = '0') THEN

            clk_1_buffer <= '0';
            clk_1 <= clk_1_buffer;
            clk_en_cntr1 <= (OTHERS => '0'); -- Clear Counter 'clk_en_cntr1'

        END IF;

    END PROCESS;

    update_clk_prescalers : PROCESS (clk_in1_freq, clk_1_freq)
    BEGIN
        clk_prescaler1 <= (OTHERS => '0');
        clk_prescaler1_halved <= (OTHERS => '0');
        clk_en_en <= '0';

        IF ((clk_in1_freq > 0) AND (clk_1_freq > 0)) THEN

            clk_prescaler1 <= (clk_in1_freq / clk_1_freq); -- a Register's (F/F) Output Only Updates Upon a Clock-Edge : That's Why This Assignment Is Done This Way !
            clk_prescaler1_halved <= ((clk_in1_freq / clk_1_freq) / 2); -- (Same Thing Here)

            IF (((clk_in1_freq / clk_1_freq) / 2) > 0) THEN -- (Same Thing Here, Too)
                clk_en_en <= '1';
            END IF;

        ELSE
            NULL;
        END IF;

    END PROCESS;

    clk_1_freq <= clk_1_freq_generic;
    clk_in1_freq <= clk_in1_freq_generic;

END ARCHITECTURE Test123_Arch;