Есть входной клок с 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и.

Ага, теперь более понятно. Я эту тему упомянул в первоначальном посте ветки.
Я, как новичок, практически не знаком пока с темой встроенных PLLей. Знаю что они есть и видимо их несколько, но не в курсе как они программируются как функция от входной тактовой, да и не знаю какой их фазоый сдвиг относительно входного клока.
Хотя это тоже может быть вариант...

entity del3 is
Port ( clk : in STD_LOGIC;
del_3 : out STD_LOGIC);
end del3;

architecture Behavioral of del3 is


signal first_step : std_logic := '0';
signal sek_step : std_logic := '0';
signal clk_cnt : integer range 0 to 2 := 0;
begin

process (Clk )
begin
if (Clk'event and Clk = '1')
then

if clk_cnt = 2 then clk_cnt <= 0;
else clk_cnt <= clk_cnt + 1;
end if;

if clk_cnt = 2 then first_step <= '1';
elsif clk_cnt = 1 then first_step <= '0';
end if;

end if;
end process ;

process (Clk )
begin
if (Clk'event and Clk = '0')
then

if first_step = '0' then sek_step <= '0';
elsif first_step = '1' then sek_step <= '1';
end if;

end if;
end process ;

del_3 <= first_step and sek_step ;

end Behavioral;

что то типа того

Нажмите для просмотра прикрепленного файла

Взяли скорее всего у Ксайлинкса. В их журнале была статья "необычные счетчики" - о счетчиках на 1,5 на 3 на 6...

Если вам требуется точная фаза, то делитель- не лучший вариант.

что такое точная фаза??? он авсёравно с допуском - лучше уж не точная - но всегда сдвинутая в одну сторону.

Больше спасибо.
Имплементировал кодом VHDLя - работает как часы ! , синхроннно по входному клоку.

Я бы в первую очередь познакомился - классная штука. Без геморроя может частоту и поделить и умножить. Главное что она 50-на-50 сохраняет без проблем, а фазовый сдвиг задается любой - 0-90-180-270.
По крайней мере в Xilinxe в EDK используется Wrapper который без проблемм этот DCM подключает.
Кстати не забывайте, что (по крайней мере в Xilinxe) если я правильно понял доку в ПЛИСине есть специальные линии - они называются BUFG, которые специально предназначены для клоков. Без них нормального SKEW и HOLD TIME не добиться.

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

ВНИМАНИЕ скорость переключения триггера по входу CLK и RST может отличаться в несколько раз!!!!!! никогда не пользуюсь асинхронными установками

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

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

Мне кажется что если входная частота не опускаеться ниже скажем
25 MHz (это в случае Xilinx) то надо использовать DCM и не мучиться.
В противном случае надо использовать другой клок,скажем 50 MHz,
сгенерить с помощью DCM максимально возможный клок, типа 400 MHz.
Далее с его помощью сэмплировать входной клок, сгенерить поделенный на 3
клок и пропустить через BUFG. Если требование на скважность 10% то должно
работать до 20 MHz (если помучиться то наверное до 40)

Зачем такие сложные решения? Не проще ли, взять два триггера - один с переключением по переднему фронту, другой - по заднему и три небольших комбинационных схемы?

Что подобное и реализовал на основе схемы предоставленной в ветке (спасибо тому кто кинул схемку). Только там 3 DFFа, из них 2 идет на счетчик modulo 3 считающий спады входного клока. Реализовал кодом - работает как часы.

Выложили же ПДФку с делением на 1,5 - потом ещё Т-триггера на выход и вот вам 50% duty и частота в трое меньше.

Выложили и возможно более простое/"чистое" решение с счетчиком то 3 (2 DFFа) и еще один DFF.
Оказалось весьма просто и легко реализуемо кодом.

Все эти выложенные схемы конечно работают. Но толку от них мало.
Опмсание на вентильном уровне. Gate клоки. И все равно присутсвует понятие удвоенной частоты.
Поттому что работает на обих фронтах клока.
Вам же не делительнужен. Вам данные надо этим Вашим gate клоком сопровождать. И что?
Передний фронт этого gate клока попадет в "центр" данных?
Ведь чего проще. На таких частотах. Иметь свой кварцованный генератор. Перевести данные в э
тот домен и в разах этого своего клока поведенчески лепить что угодно: и данные и выходной клок.
причем на выходе будет только регистровая структура.

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

Кому нужны в стандартном случае работа по обоим фронтам. Тем более, что клок сформированный pll не даст такой возможности. Да и не надо.
Все те схемы, которые приведены были это порождение работы в графических редакторах, оперируя готовыми примитивами. Не задумываясь при этом о структуре кристалла.
Что касается FiFo Зачем двуклоковое. когда можно обойтись одноклоковым. Это ресурсы и латентность.
Поведенческое языковое описание, параметризуемость легко ложиться на одноклоковое описание.
Зачем огород городить.

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity RGB_a is
port (
DATA_FIFO_OUT : in std_logic_vector(7 downto 0);
CLK_x2 : in std_logic;
nRST : in std_logic;
clk_out : out std_logic;
DATA_OUT : out std_logic_vector(23 downto 0)
);
end RGB_a;

architecture RGB_arch of RGB_a is

signal cnt : std_logic_vector(2 downto 0);
signal temp : std_logic;
signal rg_a, rg_b : std_logic_vector(7 downto 0);

begin
process(CLK_x2)
begin
if CLK_x2'event and CLK_x2 = '1' then
if nRST = '0' then cnt <= (others => '0');
elsif cnt = "101" then cnt <= (others => '0');
else cnt <= cnt + 1;
end if;
if cnt = "001" then rg_a <= DATA_FIFO_OUT;
end if;
if cnt = "011" then rg_b <= DATA_FIFO_OUT;
end if;
if cnt = "101" then DATA_OUT <= DATA_FIFO_OUT & rg_b & rg_a;
end if;
if nRST = '0' then temp <= '1';
elsif cnt = "010" then temp <= '1';
elsif cnt = "101" then temp <= '0';
end if;
end if;
end process;

clk_out <= temp;

end RGB_arch;

Честно говоря не понял.
Данные приходя со своим клоком, не вижу серьезного резона добавлять в систему еще один кварц. Подгонка фронтов выходного (деленного на 3) клока под выходные данные - очень проста. На выходе и так регистровая структура (и данных и выходной клок). Честно говоря не вижу проблемы и надобности системно осложнять.

Либо я не понял в точности вас.

Я просто привел альтернативный пример делителя на 3. (Я же не вкурсе Вашего TЗ)
И тему вроде бы закрыли.
Насчет простой подгонки - можно поспорить.
Попробуйте полученный клок простробировать входным клоком. неужели тоже самое получите?

Прочитал ваш код - теперь понятен ход ваших мыслей. Вполне тоже может быть вариантом, может быть хотя-бы ради интереса я его тоже прогоню в коде/симуляторе, кстати, не уверен получается ли в вашем варинате 50% duty cycle. Будет неплохой вариант и для самообучения...