VHDL-Zustand-Maschine testbench

Beschreibung:

Ich versuche, generieren Sie ein test-bench für ein 5-state sequential state-Maschine, die erkennt, 110 oder jede Kombination von (2) 1 und (1) 0. Ich habe bereits geschrieben, der code. siehe unten. Ich habe ein Problem mit dem Prüfstand, das ist falsch. Ich möchte zum testen für alle möglichen Sequenzen sowie Eingabe-Kombinationen, die aus-Sequenz.

Bitte geben Sie mir Beispiele für eine gute Prüfstand zu erreichen, was brauche ich für einen mealy-Maschine.

vhdl-code:

library IEEE;
use IEEE.STD_LOGIC_1164.all;

entity state is
port( clk, x : in std_logic;
      z : out std_logic
      );
end entity;

architecture behavioral of state is
type state_type is (s0,s1,s2,s3,s4);
signal state,next_s: state_type;

------------------------------------------------------------------------------

begin
process (state,x)
begin
if clk='1' and clk'event then

case state is
 when s0 =>
   if(x ='0') then
     z <= '0';
     next_s <= s4;
   else
     z <= '0';
     next_s <= s1;
   end if;

 when s1 => --when current state is "s1"
   if(x ='0') then
     z <= '0';
     next_s <= s3;
   else
     z <= '0';
     next_s <= s2;
   end if;

 when s2 =>  --when current state is "s2"
   if(x ='0') then
     z <= '1';
     next_s <= s0;
   else
     z <= '0';
     next_s <= s0;
   end if;

 when s3 =>  --when current state is "s3"
   if(x ='0') then
     z <= '0';
     next_s <= s0;
   else
     z <= '1';
     next_s <= s0;
   end if;

 when s4 => --when current state is s4
   if (x = '0') then
     z <= '0';
     next_s <= s0;
   else
     z <= '0';
     next_s <= s3;
   end if;
end case;
end if;

end process;
end behavioral;

Prüfstand-code:

library ieee;
use ieee.std_logic_1164.all;

-- Add your library and packages declaration here ...

entity state_tb is
end state_tb;

architecture TB_ARCHITECTURE of state_tb is
-- Component declaration of the tested unit
component state
port(
    clk : in STD_LOGIC;
    x : in STD_LOGIC;
    z : out STD_LOGIC );
end component;

-- Stimulus signals - signals mapped to the input and inout ports of tested entity
signal clk : STD_LOGIC;
signal x : STD_LOGIC;
-- Observed signals - signals mapped to the output ports of tested entity
signal z : STD_LOGIC;

-- Add your code here ...

begin

-- Unit Under Test port map
UUT : state
    port map (
        clk => clk,
        x => x,
        z => z
    );

-- CLOCK STIMULI
CLOCK: process
begin
CLK <= not clk after 20 ns;
wait for 40 ns;
end process; 

-- X input STIMULI
X_Stimuli: process
begin
X <= not x after 40 ns;
wait for 80 ns;
end process;

end TB_ARCHITECTURE;

configuration TESTBENCH_FOR_state of state_tb is
for TB_ARCHITECTURE
    for UUT : state
        use entity work.state(behavioral);
    end for;
end for;
end TESTBENCH_FOR_state;

In welcher Weise ist der TB falsch? Was passiert, wenn Sie das problem beheben?
Ich glaube, mein Reiz ist falsch, weil, wenn ich mein Grundstück waveform ich nicht alle möglichen Kombinationen von (2) 1 und (1) 0. hätten Sie einen Vorschlag für einen besseren Reiz? Und ich bin nicht sicher, was du meinst, wenn du das problem beheben?

InformationsquelleAutor user2444074 | 2014-02-27

2

Diese sind einige Probleme mit der FSM-Kodex und der testbench-code in Ihrem Beispiel, aber das Hauptproblem ist, dass der test eines FSM, die Sie brauchen t anwenden Sequenz von input-Werte und überprüfen Sie die Ausgänge. Man kann nicht einfach wechseln Sie Ihre Eingangs-signal zwischen 1 und 0. So, hier einige Tipps:
- Zuerst müssen Sie entscheiden, ob Sie eine generische FSM erkennt, dass jede Eingabe-Sequenz, oder eine
  FSM erkennt, dass nur eine einzige Sequenz (dein code zeigt die zweite option)
- Müssen Sie berücksichtigen die Zeit-dimension in Ihrem test. Ihr befindet Euch auf einer getakteten Schaltung, was bedeutet, dass jeder test dauert mehrere Taktzyklen.
- Zu testen Sie jede mögliche Eingabesequenz, schlage ich vor, daß Sie erstellen Sie eine Prozedur nimmt als Argumente:
  - Eine Sequenz von 4 Eingangs-Werte der FSM (könnte ein std_logic_vector)
  - Eine Sequenz von 4 output-Werte, die Sie erwarten, um zu sehen,
  - (Optional) eine Folge von der 4 Staaten, Sie erwarten, dass die FSM wird durch
Prozedur könnte wie folgt Aussehen:
```
    procedure test_sequence(
        input_sequence: std_logic_vector;
        expected_output_sequence: std_logic_vector
    ) is begin
        for i in input_sequence'range loop
            x <= input_sequence(i);
            wait until rising_edge(clk);
            assert z = expected_output_sequence(i);
        end loop;
    end;
```
Dann, in Ihrem Haupt-tests Prozess, können Sie testen, eine Sequenz mit:
```
test_sequence(
    input_sequence => "110",
    expected_output_sequence => "001"
);
```
Einige andere Vorschläge:
- Sollten Sie ein reset-signal, um das testen zu erleichtern und um zu verhindern, dass mismatchs zwischen simulation und Synthese
- Es gibt keine Notwendigkeit für eine Konfiguration in Ihrem Fall, entfernen Sie es aus dem code
- FSM-code ist unvollständig, weil Sie nie aktualisieren Sie Ihren aktuellen Status
- In einer testbench wie die, die Sie verwenden, müssen Sie zur Initialisierung der Signale verwendet, die als Eingabe für das DUT (x und clk)
Beachten Sie, dass die oben beschriebene Prozedur muss in einen Prozess " deklarative region. So etwas wie:
```
main_test_process: process is

    procedure test_sequence(
        input_sequence: std_logic_vector;
        expected_output_sequence: std_logic_vector
    ) is begin
        for i in input_sequence'range loop
            x <= input_sequence(i);
            wait until rising_edge(clk);
            assert z = expected_output_sequence(i);
        end loop;
    end;

begin

    test_sequence( input_sequence => "000", expected_output_sequence => "000");
    test_sequence( input_sequence => "001", expected_output_sequence => "000");
    --  (add any other input sequences here...)
    test_sequence( input_sequence => "110", expected_output_sequence => "001");

    std.env.finish;

end process;
```
funktionieren sollte.

InformationsquelleAutor rick
1

Deine statemachine hat die folgenden möglichen Zyklen mit 2 oder 3 Schritte, bevor Sie zurück zu s0 und richtig erkennt Sequenzen von zwei 1s.
```
Case (x1,x2,x3) States  (z1,z2,z3)
  0    0,0,0     4,0,... 0,0,...   (starts again at s0)             
  1    0,0,1     4,0,... 0,0,...   (starts again at s0)             
  2    0,1,0     4,3,0   0,0,0     (covered by your TB)         
  3    0,1,1     4,3,0   0,0,1              
  4    1,0,0     1,3,0   0,0,0              
  5    1,0,1     1,3,0   0,0,1     (covered by your TB)         
  6    1,1,0     1,2,0   0,0,1              
  7    1,1,1     1,2,0   0,0,0              
```
Wie ich es sehe Ihr erstellen Sie Reize wie folgt
```
          __    __    __    __    __
clk    __|  |__|  |__|  |__|  |__|  |__...
             _____       _____       _____ 
x      _____|     |_____|     |_____|     |...
```
I. e. weil in jedem Abschnitt mit x=1 genau eine steigende clock-und deshalb bist du auch nur ein Test-Sequenzen mit einer 0101010... Muster, wo deine statemachine gehen würde auf einem der beiden Wege markiert in der Tabelle oben. Dies bedeutet, dass die anderen 6 möglichen Pfade werden niemals ausgeführt, in Ihrer testbench.

Da diese statemachine hat eine kleine und begrenzte Anzahl von Pfaden würde ich empfehlen, eine erschöpfende test, bei dem Sie im Grunde Zyklus durch die 8 möglichen Fällen, die oben aufgeführt sind; dies könnte leicht implementiert werden mit einer 3bit-Zähler. So würden Sie eine Sequenz erstellen, in der form
```
reset
test-case 0 (sequence 0,0,0)
reset
test-case 1 (and so on)
```
Erfordern würde, dass Sie einen reset auf die Person state. Alternativ können Sie auch ändern Sie Ihre statemachine zu bleiben, in s0 mit einer null-Eingabe; dann könnten Sie wieder mit einer Sequenz von 0,0,0 jederzeit.

InformationsquelleAutor mbschenkel

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.