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