VHDL-Simulationsfehler: "Delta-Zählerüberlauf"

Question

run 50 ns
#KERNEL: stopped at delta: 5000 at time 10 ns.
#KERNEL: Error: KERNEL_0160 Delta count overflow. Increase the iteration limit using -i argument for asim or the matching entry in simulation preferences.
#Error: Fatal error occurred during simulation.

Wo liege ich falsch?

library IEEE; 
use IEEE.STD_LOGIC_1164.all; 
entity funct is 
    port(x: in std_logic_vector (2 downto 1); 
    y: out std_logic); 
end funct; 

architecture funct of funct is 
    signal r, s, q : std_logic_vector(2 downto 0) := "000"; 
begin 
    process 
    begin 
     wait on x, q; 
     r(2) <= not(q(0)) or (not(q(1)) and x(2) and not(x(1))); 
     r(1) <= q(2) and not(x(2)); 
     r(0) <= not(q(1)) and q(0) and x(1); 
     s(2) <= q(1) and x(2); 
     s(1) <= not(q(2)) and q(0) and not(x(2)); 
     s(0) <= not(q(2)) and not(q(1)) and not(q(0)) and x(2); 
    end process; 

    y <= q(2) and not(q(1)) and q(0); 

    process 
    begin 
     wait on r, s; 
     q(0) <= s(0) or (not(r(0)) and q(0)); 
     q(1) <= s(1) or (not(r(1)) and q(1)); 
     q(2) <= s(2) or (not(r(2)) and q(2)); 
    end process; 
end funct; 

Answer 1

die beiden Prozesse löst sich in einer kreisförmigen Art und Weise:

• Wenn x anfänglich ändert, löst er den ersten Prozess,
• r und s werden durch den ersten Prozess erzeugten,
• Diese werden in der wait für den zweiten Prozess verwendet,
• , die dann generiertVerwendung in der wait des ersten Prozesses,
• was

Eine so die Ausführung des ersten, zweiten, ersten, ... Prozesse weiterhin ohne Zeitinkrement, aber mit Inkrement des Delta-Zähler, bis das Delta-Zähler-Limit erreicht ist, und Sie erhalten den Fehler, den Sie sehen.

Um dies zu beheben, müssen Sie die kombinatorische Logik korrigieren, um die interne Schleife zu vermeiden.

Auch der Prozess mit Warten auf Signale ähnlich wie:

process is 
begin 
    ... 
    wait on {signals}; 
end process; 

in der Regel wie geschrieben steht:

process ({signals}) is 
begin 
    ... 
end process; 

Wenn rein kombinatorische Logik in den Prozess geschrieben wird, dann kann man tatsächlich überspringen machen ein Prozess, so kann Ihr Code geschrieben werden wie:

r(2) <= not(q(0)) or (not(q(1)) and x(2) and not(x(1))); 
r(1) <= q(2) and not(x(2)); 
r(0) <= not(q(1)) and q(0) and x(1); 
s(2) <= q(1) and x(2); 
s(1) <= not(q(2)) and q(0) and not(x(2)); 
s(0) <= not(q(2)) and not(q(1)) and not(q(0)) and x(2); 

y <= q(2) and not(q(1)) and q(0); 

q(0) <= s(0) or (not(r(0)) and q(0)); 
q(1) <= s(1) or (not(r(1)) and q(1)); 
q(2) <= s(2) or (not(r(2)) and q(2)); 

Und schreiben Sie den Code th Auf diese Art und Weise offenbart sich eindeutig die kombinatorische Schleife von q(0) zu r(0) zu q(0).