Schlüsselwörter: sequenzieller Block, paralleler Block, verschachtelter Block, benannter Block, disable

Verilog-Anweisungsblöcke bieten einen Mechanismus, um zwei oder mehr Anweisungen zu einer Struktur zusammenzufassen, die syntaktisch einer einzelnen Anweisung entspricht. Es gibt hauptsächlich zwei Typen: sequenzielle Blöcke und parallele Blöcke.

Sequenzieller Block

Ein sequenzieller Block wird durch die Schlüsselwörter begin und end dargestellt.

Anweisungen in einem sequenziellen Block werden nacheinander ausgeführt. Nicht-blockierende Zuweisungen sind natürlich eine Ausnahme.

Die Verzögerung jeder Anweisung in einem sequenziellen Block hängt immer mit der Ausführungszeit der vorangehenden Anweisung zusammen.

In den Simulationen vor diesem Abschnitt sind die blockierenden Zuweisungen in initial-Blöcken alle Instanzen sequenzieller Blöcke.

Paralleler Block

Ein paralleler Block wird durch die Schlüsselwörter fork und join dargestellt.

Anweisungen in einem parallelen Block werden parallel ausgeführt, auch wenn es sich um blockierende Zuweisungen handelt.

Die Verzögerung jeder Anweisung in einem parallelen Block bezieht sich auf den Zeitpunkt, an dem die Ausführung der Blockanweisung beginnt.

Der Unterschied zwischen sequenziellen Blöcken und parallelen Blöcken ist offensichtlich; die folgende Simulation veranschaulicht dies.

Der Simulationscode lautet wie folgt:

Beispiel

`timescale 1ns/1ns
 
module test ;
    reg [3:0]   ai_sequen, bi_sequen ;
    reg [3:0]   ai_paral,  bi_paral ;
    reg [3:0]   ai_nonblk, bi_nonblk ;
 
 //============================================================//
    //(1)Sequenzblock
    initial begin
        #5 ai_sequen         = 4'd5 ;    //bei 5ns
        #5 bi_sequen         = 4'd8 ;    //bei 10ns
    end
    //(2)Fork-Block
    initial fork
        #5 ai_paral          = 4'd5 ;    //bei 5ns
        #5 bi_paral          = 4'd8 ;    //bei 5ns
    join
    //(3) Nicht blockierender Block
    initial fork
        #5 ai_nonblk         <= 4'd5 ;    //bei 5ns
        #5 bi_nonblk         <= 4'd8 ;    //bei 5ns
    join
 
endmodule

Die Simulationsergebnisse sind wie folgt:

Wie in der Abbildung gezeigt, wird der sequenzielle Block sequenziell ausgeführt, und bei 10ns wird dem Signal bi_sequen nur der Wert 8 zugewiesen.

Im parallelen Block werden die Zuweisungen von ai_paral und bi_paral gleichzeitig ausgeführt, daher werden beide bei 5ns zugewiesen.

Nicht blockierende Zuweisungen können auch denselben Zuweisungseffekt wie ein paralleler Block erzielen.

Verschachtelter Block

Sequenzielle Blöcke und parallele Blöcke können ebenfalls verschachtelt werden.

Der Simulationscode lautet wie folgt:

Beispiel

`timescale      1ns/1ns
 
module test ;
 
    reg [3:0]   ai_sequen2, bi_sequen2 ;
    reg [3:0]   ai_paral2,  bi_paral2 ;
    initial begin
        ai_sequen2         = 4'd5 ;    //bei 0ns
        fork
            #10 ai_paral2          = 4'd5 ;    //bei 10ns
            #15 bi_paral2          = 4'd8 ;    //bei 15ns
        join
        #20 bi_sequen2      = 4'd8 ;    //bei 35ns
    end
 
endmodule

Die Simulationsergebnisse sind wie folgt:

Anweisungen innerhalb des parallelen Blocks werden parallel ausgeführt, sodass die Signale ai_paral2 bzw. bi_paral2 bei 10ns bzw. 15ns zugewiesen werden. Die längste Ausführungszeit im parallelen Block beträgt 15ns, sodass das Signal bi_sequen2 im sequenziellen Block bei 35ns zugewiesen wird.

Benannter Block

Wir können Blockanweisungsstrukturen benennen.

In einem benannten Block können lokale Variablen deklariert werden, und auf Variablen kann über hierarchische Namensreferenzen zugegriffen werden.

Der Simulationscode lautet wie folgt:

Beispiel

`timescale 1ns/1ns
 
module test;
 
    initial begin: example   //Benennen Sie den benannten Block example; das Semikolon darf nicht weggelassen werden
        integer    i ;       //Diese Variable kann von anderen Modulen über test.example.i verwendet werden
        i = 0 ;
        forever begin
            #10 i = i + 10 ;      
        end
    end
 
    reg stop_flag ;
    initial stop_flag = 1'b0 ;
    always begin : detect_stop
        if ( test.example.i == 100) begin //i wird 10-mal inkrementiert, d. h., die Simulation stoppt bei 100ns
            $display("Jetzt kannst du die Simulation stoppen!!!");
            stop_flag = 1'b1 ;
        end
        #10 ;
    end
 
endmodule

Die Simulationsergebnisse sind wie folgt:

Ein benannter Block kann auch deaktiviert werden, dargestellt durch das Schlüsselwort disable.

disable kann die Ausführung eines benannten Blocks beenden und kann verwendet werden, um eine Schleife zu verlassen, Fehler zu behandeln usw.

Es ähnelt break in der Sprache C, aber break kann nur die aktuelle Schleife verlassen, während disable jeden benannten Block im Design deaktivieren kann.

Der Simulationscode lautet wie folgt:

Beispiel

`timescale 1ns/1ns
 
module test;
 
    initial begin: example_d //Benenne den benannten Block example_d
        integer    i_d ;
        i_d = 0 ;
        while(i_d<=100) begin: example_d2
            # 10 ;
            if (i_d >= 50) begin       //Nach 5 Inkrementen das Inkrementieren stoppen
                disable example_d3.clk_gen ;//Externen Block stoppen: clk_gen
                disable example_d2 ;       //Aktuellen Block stoppen: example_d2
            end
            i_d = i_d + 10 ;
        end
    end
 
    reg clk ;
    initial begin: example_d3
        while (1) begin: clk_gen  //Taktgenerierungsmodul
            clk=1 ;      #10 ;
            clk=0 ;      #10 ;
        end
    end
 
endmodule

Die Simulationsergebnisse sind wie folgt:

Wie aus der Abbildung ersichtlich ist, stoppt das Signal i_d das Inkrementieren, nachdem es 50 erreicht hat, und der clk-Takt wird danach nicht mehr erzeugt.

Es ist zu sehen, dass disable den aktuellen while-Block verlässt.

Es sollte beachtet werden, dass disable, wenn es in einem always- oder forever-Block verwendet wird, nur die aktuelle Iteration verlassen kann; beim nächsten Mal wird die Anweisung weiterhin im always- oder forever-Block ausgeführt. Da always-Blöcke und forever-Blöcke kontinuierlich ausgeführt werden, ist disable an dieser Stelle gewissermaßen ähnlich wie die continue-Funktion in der Sprache C.

Quellcode-Download

Herunterladen