Есть входной клок с duty cycle 50%. Нужно его грамотно поделить на 3 при сохранении 50% +/- 10% duty cycle. Как сделать ?

Набросав диаграммы на бумажке я прикинул генерация выходного клока может быть:
Подсчитывать кол-во фронтов и спадов входного клока, по каждому второму фронту генерировать фронт выходного клока, по каждому второму спаду - генерировать спад выходного клока.
Но тогда получается что вмешивается комбинаторная логика в схему генерации выходного клока, и это насколько я понял не есть "здоровая" практика.

Подскажите как сделать грамотно ? Вообще, какие есть грамотные пути деления клока в ПЛИСах (кроме наверно встроенных PLLей...)

Спасибо.

Если Вы работает на одном системном клоке, без разницы скважность этого клока. Потому что если это не DDR? работают по переднему фронту. Т.Е образно берется временной интервал в отсчетах этого клока и внужный временной момент делается выборка данных по этому клоку длительностью в один период этого системного клока. такой подход легко ложиться на поведенческое описание. А на выход выдаются только данные, сопровождающиеся clk_en длительностью в один период системного клока.
Подразумевается что следующий модуль тоже работает на системном клоке.
Все чисто и прозрачно. И никакго skew/ потому что этот системный клок идет по специализированному пути. Т.Е его задержка поступления на С входы регистров в любой точке кристалла меньше, чем задержка поступления данных по цепям входов выходов регистров.
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity RGB is
port (
DATA_IN : in std_logic_vector(7 downto 0);
XTAL_CLK : in std_logic;
nRST : in std_logic;
DATA_OUT : out std_logic_vector(23 downto 0);
INT_CPU : out std_logic
);
end RGB;

architecture RGB_arch of RGB is

signal cnt : std_logic_vector(1 downto 0);
signal clk_en_a, clk_en_b, clk_en_c : std_logic;
signal rg_a, rg_b : std_logic_vector(7 downto 0);

begin
process(XTAL_CLK)
begin
if XTAL_CLK'event and XTAL_CLK = '1' then
if nRST = '0' then
cnt <= (others => '0');
elsif cnt = "10" then
cnt <= (others => '0');
else
cnt <= cnt + 1;
end if;
if clk_en_a = '1' then
rg_a <= DATA_IN;
end if;
if clk_en_b = '1' then
rg_b <= DATA_IN;
end if;
if clk_en_c = '1' then
DATA_OUT <= DATA_IN & rg_b & rg_a;
end if;
INT_CPU <= clk_en_c;
end if;
end process;

clk_en_a <= '1' when (cnt = "00") else '0';
clk_en_b <= '1' when (cnt = "01") else '0';
clk_en_c <= '1' when (cnt = "10") else '0';

end RGB_arch;

Спасибо, но на выход нужно подавать именно тактовую с частотой в 3 раза меньше входной и требование к сважности след. модуля: 50% +/ 10%.
В приведенном коде насколько я понял выходная тактовая идет как clk_en_c а значит со скважностью примерно 30%, я ошибаюсь ?

Понимаете правильно.
Что касается нужно тактовую в 3 раза меньше, чтобы данные еще при этом ею сопровождать, да еще меандр, с этим можно поспорить. Вам кажется так легче. На самом деле намучаетесь. Или нужно частоту в два раза выше основной. Чтобы сначала на 3 поделить, а потом на 2 (для меандра).
Ну и главное. В сухую учиться трудно. Нужно смотреть в RTL просмотрщике, во что Ваше описание реализовалось. И моделировать обязательно.
В квартусе нормальный симулятор. Все входные воздействия в нем задаются в графическом виде.
( так как Вы еще не пишите тестбенчей, моделсим вам не очень подходит).
Что касается тестбенчей, на сайте xilinx есть документ, как быстро начать их писать.

Хмм, да, понимаю.
Я не имел ввиду что мне будет легче делить клок на 3 - согласен с вами что это не самый легкий вариант.
Но то к чему мой модуль будет подсоединяться требует конкретно 50% скважность (+/- 10%) и я не могу с этим спорить..
Посему даже если выходной буфер загружается 3мя байтами по его enable синхронно с входным клоком, выдавать наружу сию дату я обязан по входному клоку деленному на 3 и с 50% скважностью...

module DivThree(
input clk,
output reg div
);

reg A,B;
wire tmp;

assign tmp = ~( A | B );

always@(posedge clk) A <= tmp;
always@(negedge clk) B <= tmp;

always@(posedge tmp) div <= ~div;

endmodule

Спасибо, но я не знаком с синтаксисом Верилога, я на VHDLе.
Можно поросить вас описать алгоритм ? (я так понял из кода работаем и по фронту и по спаду + логика)

Где взял - не помню.

Кроме того, что клок поделить Вам еще нужно, чтобы фаза результирующего клока была вполне определенной - ее надо привязать к счетчику байт, так что приведенный вариант может не подойти.

Да, нужна фазовая синхронизация, не уверен что данная схема подойдет.
Видимо нужно менять положение выходного клока по каждой паре входных фронтов и входных спадов чередуя их. Т.е. по каждому второму спаду входного клока идет спад выходного, затем по каждому второму фронту входного идет фронт выходного и т.д. чередуясь...
Пока туго представляю как делать физически...

Сделайте два делителя на 6 - один по восходящему фронту, другой - по нисходящему (два триггера, на вход каждого из которых подается его инвертированный выход, разрешениями управляйте от счетчика байт), результат получится, если объединить выходы триггеров ячейкой XOR (или XNOR в зависимости от нужного фронта).

А все-таки, если не искать приключений на ровном месте и применить DCMы, что религия не позволяет? Или их катастрофически не хватает?

Сорри за my ignorance, что такое DCM ?

как правило они имеют ограничение на минимальную частоту входного сигнала

это продвинутые "встроенные PLLи" ))

Скорее DLLи.