Schlüsselwörter: deassign, force, release

Die prozedurale kontinuierliche Zuweisung ist eine Art prozeduraler Zuweisung. Diese Zuweisungsanweisung kann alle anderen Zuweisungen an wire oder reg ersetzen und überschreibt den aktuellen Wert von Variablen vom Typ wire oder reg.

Im Gegensatz zur prozeduralen Zuweisung kann der Ausdruck einer prozeduralen kontinuierlichen Zuweisung kontinuierlich in Variablen vom Typ wire oder reg getrieben werden. Das heißt, wenn eine prozedurale kontinuierliche Zuweisung wirksam wird, führt jede Änderung eines Operanden des Ausdrucks auf der rechten Seite dazu, dass die Anweisung der prozeduralen kontinuierlichen Zuweisung erneut ausgeführt wird.

Es gibt hauptsächlich zwei Arten der prozeduralen kontinuierlichen Zuweisung: assign-deassign und force-release.

assign, deassign

assign (prozedurale Zuweisungsoperation) und deassign (prozedurale Zuweisungsoperation abbrechen) repräsentieren den ersten Typ der prozeduralen kontinuierlichen Zuweisungsanweisung. Das Zuweisungsziel kann nur ein Register oder ein Registerarray sein, keine Variable vom Typ wire.

Während des Zuweisungsvorgangs wird dem Register kontinuierlich zugewiesen, und der Wert im Register bleibt erhalten, bis ihm erneut zugewiesen wird.

Beispielsweise kann ein D-Flipflop mit einem Reset-Anschluss mit dem folgenden Code beschrieben werden:

Beispiel

module dff_normal(
    input       rstn,
    input       clk,
    input       D,
    output reg  Q
 );

    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin   //Q = 0 nach wirksamem Reset
            Q <= 1'b0 ;
        end
        else begin
            Q <= D ;       //Q = D bei steigender Taktflanke
        end
    end

endmodule  

Im Folgenden wird es mit assign und deassign umgeschrieben, um dieselbe Funktionalität zu erreichen.

Das heißt, wenn das Reset-Signal 0 ist, wird der Q-Anschluss durch die assign-Anweisung zugewiesen und gibt immer 0 aus.

Wenn das Reset-Signal 1 ist, wird die Zuweisung des Q-Anschlusses durch die deassign-Anweisung aufgehoben und er wird bei der steigenden Flanke des Takts neu zugewiesen.

Beispiel

module dff_assign(
    input       rstn,
    input       clk,
    input       D,
    output reg  Q
 );
 
    always @(posedge clk) begin
        Q <= D ;       //Q = D bei steigender Taktflanke
    end
 
    always @(negedge rstn) begin
        if(!rstn) begin
            assign Q = 1'b0 ; //Q-Wert ändern, wenn Reset wirksam ist
        end
        else begin        //Q-Wert-Überlagerung aufheben,
            deassign Q ;  //und Q behält den 0-Wert bis zum Eintreffen der steigenden Taktflanke
        end
    end
 
endmodule

force, release

force (erzwungene Zuweisungsoperation) und release (Aufheben der erzwungenen Zuweisung) stellen den zweiten Typ der prozeduralen kontinuierlichen Zuweisungsanweisung dar.

Die Verwendung und Wirkung sind ähnlich wie bei assign und deassign, aber das Zuweisungsziel kann entweder eine Variable vom Typ reg oder eine Variable vom Typ wire sein.

Da es sich um eine unbedingte erzwungene Zuweisung handelt, wird sie im Allgemeinen in interaktiven Debugging-Prozessen verwendet und sollte nicht in Designmodulen verwendet werden.

Wenn force auf ein Register angewendet wird, wird der aktuelle Wert des Registers überschrieben; bei release behält der Registerwert weiterhin den Wert aus der erzwungenen Zuweisung. Danach kann der Registerwert durch die ursprünglichen prozeduralen Zuweisungsanweisungen geändert werden.

Wenn force auf ein net angewendet wird, wird der net-Wert ebenfalls zwangsweise zugewiesen. Sobald die net-Variable jedoch freigegeben wird, nimmt ihr Wert sofort wieder den ursprünglichen getriebenen Wert an.

Um den Unterschied der erzwungenen Zuweisung zwischen den beiden Variablentypen anschaulich zu beobachten, verwenden Sie den Zähler counter10 aus dem ersten Abschnitt als Entwurfsmodul, und die Testbench wird wie folgt entworfen.

Beispiel

`timescale 1ns/1ns
 
module test ;
    reg          rstn ;
    reg          clk ;
    reg [3:0]    cnt ;
    wire         cout ;
 
    counter10 u_counter (
        .rstn    (rstn),
        .clk     (clk),
        .cnt     (cnt),
        .cout    (cout));
 
    initial begin
        clk       = 0 ;
        rstn      = 0 ;
        #10 ;
        rstn      = 1'b1 ;
        wait (test.u_counter.cnt_temp == 4'd4) ;
        @(negedge clk) ;
        force     test.u_counter.cnt_temp = 4'd6 ;
        force     test.u_counter.cout     = 1'b1 ;
        #40 ;
        @(negedge clk) ;
        release   test.u_counter.cnt_temp ;
        release   test.u_counter.cout ;
    end
 
    initial begin
        clk = 0 ;
        forever #10 clk = ~ clk ;
    end
 
    //Simulation beenden
    always begin
        #1000;
        if ($time >= 1000) $finish ;
    end
 
endmodule // test

Die Simulationsergebnisse sind wie folgt.

Wie aus der Abbildung ersichtlich ist, wird, wenn cnt_temp gleich 4 (80ns) ist, cnt_temp auf 6 gezwungen und cout auf 1 gezwungen.

Beim release (120ns) ist cnt_temp ein Registertyp und behält seinen ursprünglichen Wert unverändert bei; erst wenn die steigende Taktflanke eine Additionszuweisung darauf ausführt, wird der Wert 7.

Bei 120ns kann jedoch, da cout eine Variable vom Net-Typ ist, sein Wert nicht gespeichert werden. Im ursprünglichen counter10-Modell gibt es eine Treiberanweisung:assign cout = (cnt_temp==4'd9), sodass der Wert von cout 0 wird.

Quellcode-Download

Herunterladen