VHDL - 该信号锁存吗？

Question

我有一个带有

D_IN_VAL std_logic_vector(n-1 downto 0)

输入端口和内部

signal CUR_MAX_S : std_logic_vector(n-1 downto 0)

的模块。我希望仅使用部分

D_IN_VAL

数据（例如 20 位信号中的 4 位），因此我想将

D_IN_VAL

“保存”在

CUR_MAX_S

中，然后使用部分

CUR_MAX_S

。我已经将

D_IN_VAL

同步分配给

CUR_MAX_S

if RISING_EDGE(CLK) then

并且在某些条件下

if D_SEND = '1' AND WHAT_STATE = 0 then

。

但是当

D_IN_VAL

的值发生变化时会发生什么？

CUR_MAX_S

的值也会改变吗？或者 Quartus 是否生成一个锁存器，它会记住我分配给 CUR_MAX_S 的内容？根据模拟，它“记住”了该值，但我已经学会了不要 100% 相信模拟。它是一个信号而不是变量，所以我不确定。

编辑：添加示例代码，更改相关变量的名称以匹配代码

library IEEE;
use IEEE.STD_LOGIC_1164.all;
use ieee.numeric_std.all;

entity MYMUX1 is
    generic (
    -- dlugosc rejestru jako potega 2-ki, nie mniej niz 3
    -- 2^2 = 4, 2^3 = 8, 2^4 = 16, 2^5 = 32, 2^6 = 64, 2^7 = 128, 2^8 = 256, 
        M : INTEGER := 4;
    -- szerokosc we/wy rejestru (w bitach)
        N : INTEGER := 5
    );
    port(
    -- wartosc maksimum
        D_IN_VAL    :   in STD_LOGIC_VECTOR(2*N+M-1 downto 0);
    -- pozycja maksimum
        D_IN_POS :  in STD_LOGIC_VECTOR(M+1 downto 0);
    -- wyslij nastepne dane
        D_SEND :        in STD_LOGIC;
    -- zegar, duh.
        CLK :       in STD_LOGIC;
    -- resET
        RST :           in STD_LOGIC;

    -- dane wyjsciowe, do UARTu
        D_OUT :     out STD_LOGIC_VECTOR(7 downto 0);
    -- dane gotowe
        D_RDY :         out STD_LOGIC;

    -- testowe
        test1 :     out STD_LOGIC_VECTOR(11 downto 0);
        test2 :     out STD_LOGIC_VECTOR(11 downto 0);
        test3 :     out STD_LOGIC_VECTOR(11 downto 0);
        test4 :     out STD_LOGIC_VECTOR(11 downto 0);
        test5 :     out STD_LOGIC_VECTOR(3 downto 0);
        test_state : out STD_LOGIC_VECTOR(3 downto 0);
        test_neg :  out STD_LOGIC_VECTOR(2*N+M-1 downto 0)
    );
end MYMUX1;

architecture AMYMUX1 of MYMUX1 is

    signal CUR_MAX_S : STD_LOGIC_VECTOR(2*N+M-1+4 downto 0);
    signal WHERE_MAX_S : STD_LOGIC_VECTOR(M+1+4 downto 0);

    begin

    process(CLK)
    -- ile bajtow na wartosc? maks 4mln, 2^32. na przyklad n=12 bajtow, 2^m, m=8, 256 razy
    variable COUNT1 :       INTEGER range 0 to 7; 
    -- ile bajtow na pozycje? maks 65k, 2^16
    variable COUNT2 :       INTEGER range 0 to 3;
    variable COUNT_MAIN :   INTEGER range 0 to 11;
    variable CUR_MAX :      INTEGER range -(2**(2*N+M)) to (2**(2*N+M)-1);
    variable WHERE_MAX :    INTEGER range 0 to (2*2**M-1);
    variable WHAT_STATE :   INTEGER range 0 to 6; -- albo 6



    begin
--  if(RISING_EDGE(CLK)) then
        if(((2*N+M) mod 4)>0) then
            COUNT1 := ((2*N+M)/4)+1;
        else
            COUNT1 := (2*N+M)/4;
        end if;

        if(((M+1+1) mod 4)>0) then
            COUNT2 := ((M+1+1)/4)+1;
        else
            COUNT2 := (M+1+1)/4;
        end if; 

    if(RISING_EDGE(CLK)) then
        if(RST = '1') then
            WHAT_STATE := 0;
            test_state <= STD_LOGIC_VECTOR(to_signed(0,4));
        else

        -- state 0 - jesli wartosc > od zera, zapisz, jesli mniejsza, odwroc i zapisz, wyslij ! jako znak poczatku paczki
            if(D_SEND = '1' AND WHAT_STATE = 0) then
                if(to_integer(signed(D_IN_VAL))>=0) then
                --  CUR_MAX := to_integer(signed(D_IN_VAL));
                    CUR_MAX_S <= "0000" & STD_LOGIC_VECTOR((signed(D_IN_VAL)));
                -- skocz od razu do wysylania danych
                    WHAT_STATE := 2;

                else
                --  CUR_MAX := -to_integer(signed(D_IN_VAL));
                    CUR_MAX_S <= "0000" & STD_LOGIC_VECTOR((-signed(D_IN_VAL)));
                -- wyslij znak a dopiero potem dane
                    WHAT_STATE := 1;

                end if;

                WHERE_MAX_S <= "0000" & D_IN_POS;

                test_neg <= STD_LOGIC_VECTOR(-signed(D_IN_VAL));
                WHERE_MAX := to_integer(signed(D_IN_POS));

                COUNT_MAIN := COUNT1;

                D_OUT <= STD_LOGIC_VECTOR(to_unsigned(33,8));

                test1 <= STD_LOGIC_VECTOR(to_signed(CUR_MAX,12));
                test2 <= STD_LOGIC_VECTOR(to_signed(WHERE_MAX,12));
                test3 <= STD_LOGIC_VECTOR(to_signed(COUNT_MAIN,12));
                test4 <= STD_LOGIC_VECTOR(to_signed(WHAT_STATE,12));
                test_state <= STD_LOGIC_VECTOR(to_signed(0,4));

            -- oba teoretycznie dzialaja, ale ktore jest poprawne...?
            --  CUR_MAX_S <= STD_LOGIC_VECTOR(to_unsigned(CUR_MAX,14));
            --  CUR_MAX_S <= D_IN_VAL;

        -- state 1 - wyslij minus, jesli liczba jest ujemna
            elsif(WHAT_STATE = 1) then
-- and so on, and so forth... the rest of the code goes here.

Answer 1

根据您的描述而不是您的长代码：

• CUR_MAX_S

  将被合成为 n 位寄存器，其中

  CLK

  信号路由到组合逻辑的时钟输入和输出

  D_SEND = '1' AND WHAT_STATE = 0

  路由到每个位的使能输入。
• 当且仅当使能信号为高电平时，输出才会在时钟信号的上升沿后发生变化，而不是当输入值发生变化时。

这就是寄存器的全部思想：在需要时存储数据，而不是在输入更改时存储数据。