Vhdl 特定时间的高信号

我做了一个VHDL设计，它由两个模块组成。其中一个处理通信并以100 Mhz的频率运行（我不能改变这个）。另一个模块进行计算，由于时间原因，必须在45 Mhz下运行

第二个模块有一个名为“newPair”的输入管脚，我想在新数据准备就绪并可由第二个模块处理时将其设置为高。现在，我的第二个模块只在时钟的上升沿工作，所以我需要将该引脚设置为45 Mhz时钟周期高，然后将其拉低。这必须通过在45 Mhz下运行的模块完成。我怎样才能做到这一点？我曾想过为此目的创建一个DCM，但这似乎有点力不从心

谢谢

更新：

---

我正在研制Spartan-6（xc6slx150）

您的设计有两个时钟域，因此您需要同步器电路将信息从一个时钟域传输到另一个时钟域

第1部分-同步器

基本同步器由两个链式D-FF组成。该同步器可用于标记信号（这些信号不经常变化）。它不能用于选通信号（这些信号在1个周期内处于高电平），因为在目标时钟域上可能会丢失或双重看到选通信号

2 D-FF同步器：

genLoop : for i in Input'range generate
  signal Data_async : STD_LOGIC;
  signal Data_meta      : STD_LOGIC     := '0');
  signal Data_sync      : STD_LOGIC     := '0' ;
begin
  Data_async    <= Input(i);
  process(Clock)
  begin
    if rising_edge(Clock) then
      Data_meta <= Data_async;
      Data_sync     <= Data_meta;
    end if;
  end process;
  Output(i) <= Data_sync;
end generate;

资料来源：

第2部分-特殊合成器电路

我假设您还将数据从一个时钟域传输到另一个时钟域。因此，您需要一个多位同步器（建立在选通同步器之上）或一个支持交叉时钟的FIFO

---

我参与的PoC库也有多位/矢量同步器。请参见链接源文件夹中的其他模块。还有一个交叉时钟/独立时钟（ic）FIFO。

您不需要在特定的时间段内断言某些信号

如果第一个模块和第二个模块之间的数据交换很少发生，可以使用电平触发让第二个模块知道数据已准备就绪。（您可以阅读以了解“级别”和“边缘”触发之间的差异）

如果需要处理流数据，则需要使用异步FIFO。（可能会给你更多的信息）

---

作为建议，我不会将信号断言用于特定的周期数方法，因为它不是可重用代码的良好实践（它适用于这种特定的设计，但如果时钟周期因某种原因发生变化，您可能需要重新校准周期数）。

您的目标平台和设备是什么？我刚刚更新了它。对不起，非常感谢你的回答。我选择了另一个作为答案，但是你的回答也帮了我，谢谢：）真棒的答案。谢谢：）

entity sync_Strobe IS
  generic (
    BITS                                : POSITIVE      := 1;                                                       -- number of bit to be synchronized
    GATED_INPUT_BY_BUSY : BOOLEAN           := TRUE                                                 -- use gated input (by busy signal)
  );
  port (
    Clock1                          : in    STD_LOGIC;                                                          -- <Clock>  input clock domain
    Clock2                          : in    STD_LOGIC;                                                          -- <Clock>  output clock domain
    Input                               : in    STD_LOGIC_VECTOR(BITS - 1 downto 0);        -- @Clock1: input bits
    Output                          : out STD_LOGIC_VECTOR(BITS - 1 downto 0);      -- @Clock2: output bits
    Busy                                : out   STD_LOGIC_VECTOR(BITS - 1 downto 0)         -- @Clock1: busy bits
  );
end entity;

architecture rtl of sync_Strobe is
  attribute SHREG_EXTRACT                                       : STRING;

  signal syncClk1_In        : STD_LOGIC_VECTOR(BITS - 1 downto 0);
  signal syncClk1_Out       : STD_LOGIC_VECTOR(BITS - 1 downto 0);
  signal syncClk2_In        : STD_LOGIC_VECTOR(BITS - 1 downto 0);
  signal syncClk2_Out       : STD_LOGIC_VECTOR(BITS - 1 downto 0);
begin
  gen : for i in 0 to BITS - 1 generate
    signal D0                           : STD_LOGIC         := '0';
    signal T1                           : STD_LOGIC         := '0';
    signal D2                           : STD_LOGIC         := '0';

    signal Changed_Clk1     : STD_LOGIC;
    signal Changed_Clk2     : STD_LOGIC;
    signal Busy_i                   : STD_LOGIC;

    -- Prevent XST from translating two FFs into SRL plus FF
    attribute SHREG_EXTRACT OF D0   : signal is "NO";
    attribute SHREG_EXTRACT OF T1   : signal is "NO";
    attribute SHREG_EXTRACT OF D2   : signal is "NO";

  begin

    process(Clock1)
    begin
        if rising_edge(Clock1) then
            -- input delay for rising edge detection
            D0      <= Input(I);

            -- T-FF to converts a strobe to a flag signal
            if (GATED_INPUT_BY_BUSY = TRUE) then
                T1  <= (Changed_Clk1 and not Busy_i) xor T1;
            else
                T1  <= Changed_Clk1 xor T1;
            end if;
        end if;
    end process;

    -- D-FF for level change detection (both edges)
    D2  <= syncClk2_Out(I) when rising_edge(Clock2);

    -- assign syncClk*_In signals
    syncClk2_In(I)  <= T1;
    syncClk1_In(I)  <= syncClk2_Out(I); -- D2

    Changed_Clk1        <= not D0 and Input(I);             -- rising edge detection
    Changed_Clk2        <= syncClk2_Out(I) xor D2;      -- level change detection; restore strobe signal from flag
    Busy_i                  <= T1 xor syncClk1_Out(I);      -- calculate busy signal

    -- output signals
    Output(I)               <= Changed_Clk2;
    Busy(I)                 <= Busy_i;
  end generate;

  syncClk2 : entity PoC.sync_Bits
    generic map (
        BITS                => BITS                     -- number of bit to be synchronized
    )
    port map (
        Clock               => Clock2,              -- <Clock>  output clock domain
        Input               => syncClk2_In,     -- @async:  input bits
        Output          => syncClk2_Out     -- @Clock:  output bits
    );

  syncClk1 : entity PoC.sync_Bits
    generic map (
        BITS                => BITS                     -- number of bit to be synchronized
    )
    port map (
        Clock               => Clock1,              -- <Clock>  output clock domain
        Input               => syncClk1_In,     -- @async:  input bits
        Output          => syncClk1_Out     -- @Clock:  output bits
    );
end architecture;