Mots-clés : deassign, force, release

L'affectation continue procédurale est un type d'affectation procédurale. Cette instruction d'affectation peut remplacer toutes les autres affectations à wire ou reg, en écrasant la valeur actuelle des variables de type wire ou reg.

Contrairement à l'affectation procédurale, l'expression d'une affectation continue procédurale peut être pilotée en continu dans des variables de type wire ou reg. C'est-à-dire que lorsqu'une affectation continue procédurale prend effet, toute modification d'un opérande de l'expression de droite entraîne la réexécution de l'instruction d'affectation continue procédurale.

Il existe principalement deux types d'affectation continue procédurale : assign-deassign et force-release.

assign, deassign

assign (opération d'affectation procédurale) et deassign (annulation de l'opération d'affectation procédurale) représentent le premier type d'instruction d'affectation continue procédurale. La cible d'affectation ne peut être qu'un registre ou un tableau de registres, et non une variable de type wire.

Pendant le processus d'affectation, le registre est affecté en continu, et la valeur du registre est conservée jusqu'à ce qu'il soit réaffecté.

Par exemple, une bascule D avec une borne de réinitialisation peut être décrite avec le code suivant :

Exemple

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

    always @(posedge clk or negedge rstn) begin
        if(!rstn) begin   //Q = 0 après reset effectif
            Q <= 1'b0 ;
        end
        else begin
            Q <= D ;       //Q = D sur front montant de l'horloge
        end
    end

endmodule  

Dans ce qui suit, réécrivez-le avec assign et deassign pour obtenir la même fonctionnalité.

Autrement dit, lorsque le signal de reset est 0, la borne Q est assignée par l'instruction assign et délivre toujours 0.

Lorsque le signal de reset est 1, la borne Q est désassignée par l'instruction deassign et est réassignée au front montant de l'horloge.

Exemple

module dff_assign(
    input       rstn,
    input       clk,
    input       D,
    output reg  Q
 );
 
    always @(posedge clk) begin
        Q <= D ;       //Q = D sur front montant de l'horloge
    end
 
    always @(negedge rstn) begin
        if(!rstn) begin
            assign Q = 1'b0 ; //changer la valeur de Q lorsque le reset est effectif
        end
        else begin        //annule la superposition de valeur de Q,
            deassign Q ;  //et Q reste à 0 jusqu'à l'arrivée du front montant de l'horloge
        end
    end
 
endmodule

force, release

force (opération d'affectation forcée) et release (libération d'affectation forcée) représentent le deuxième type d'instruction d'affectation continue procédurale.

L'utilisation et les effets sont similaires à assign et deassign, mais la cible d'affectation peut être soit une variable de type reg, soit une variable de type wire.

Comme il s'agit d'une affectation forcée inconditionnelle, son utilisation est généralement réservée aux processus de débogage interactif et ne doit pas être utilisée dans les modules de conception.

Lorsque force est appliqué à un registre, la valeur actuelle du registre est écrasée ; lors du release, la valeur du registre continuera de conserver la valeur issue de l'affectation forcée. Ensuite, la valeur du registre peut être modifiée par les instructions d'affectation procédurales d'origine.

Lorsque force est appliqué à un net, la valeur du net est également affectée de force. Cependant, une fois la variable net libérée, sa valeur devient immédiatement la valeur pilotée d'origine.

Pour observer intuitivement la différence d'affectation forcée entre les deux types de variables, utilisez le compteur counter10 de la première section comme module de conception, et le banc de test est conçu comme suit.

Exemple

`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
 
    //terminer la simulation
    always begin
        #1000;
        if ($time >= 1000) $finish ;
    end
 
endmodule // test

Les résultats de la simulation sont les suivants.

Comme on peut le voir sur la figure, lorsque cnt_temp est égal à 4 (80ns), cnt_temp est forcé à 6, et cout est forcé à 1.

Lors du release (120ns), cnt_temp est de type registre, conservant toujours sa valeur d'origine inchangée ; ce n'est que lorsque le front montant de l'horloge effectue une affectation d'addition sur celui-ci que la valeur devient 7.

À 120ns, cependant, comme cout est une variable de type net, sa valeur ne peut pas être sauvegardée. Dans le modèle counter10 d'origine, il y a une instruction de pilotage :assign cout = (cnt_temp==4'd9), donc la valeur de cout devient 0.

Téléchargement du code source

Téléchargement