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
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
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
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
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
