Déclaration d'affectation Verilog

Signaux de type wire ou un fil de fer similaire comme type de données nécessite l'affectation continue d'une valeur. Par exemple, considérons un fil électrique utilisé pour connecter des pièces sur une planche à pain. Tant que la batterie + 5V est appliquée à une extrémité du fil, le composant connecté à l'autre extrémité du fil obtiendra la tension requise.

Dans Verilog, ce concept est réalisé par le assign instruction où tout wire ou d'autres types de données semblables à des fils peuvent être pilotés en continu avec une valeur. La valeur peut être une constante ou une expression comprenant un groupe de signaux.

Attribuer la syntaxe

La syntaxe d'affectation commence par le mot-clé assign suivi du nom du signal qui peut être soit un signal unique, soit une concaténation de différents réseaux de signaux. La force d'entraînement et retarder sont facultatifs et sont principalement utilisés pour la modélisation de flux de données plutôt que pour la synthèse en matériel réel. L'expression ou le signal du côté droit est évalué et affecté au réseau ou à l'expression des réseaux du côté gauche.

  
  
assign <net_expression> = [drive_strength] [delay] <expression of different signals or constant value>

  

Les valeurs de retard sont utiles pour spécifier les retards des portes et sont utilisées pour modéliser le comportement de synchronisation dans le matériel réel, car la valeur dicte quand le réseau doit être affecté à la valeur évaluée.

Règles

Certaines règles doivent être suivies lors de l'utilisation d'un assign instruction :

• LHS doit toujours être un réseau scalaire ou vectoriel ou une concaténation de réseaux scalaires ou vectoriels et jamais un registre scalaire ou vectoriel.
• RHS peut contenir des registres scalaires ou vectoriels et des appels de fonction.
• Chaque fois qu'un opérande sur le RHS change de valeur, LHS sera mis à jour avec la nouvelle valeur.
• assign les instructions sont également appelées affectations continues et sont toujours actives

Exemple #1

Dans l'exemple suivant, un réseau appelé est piloté en continu par une expression de signaux. i1 et i2 avec le ET logique & forment l'expression.

Si les fils sont plutôt convertis en ports et synthétisés, nous obtiendrons un schéma RTL comme celui présenté ci-dessous après synthèse.

L'instruction d'affectation continue peut être utilisée pour représenter les portes combinatoires dans Verilog.

Exemple #2

Le module illustré ci-dessous prend deux entrées et utilise un assign instruction pour piloter la sortie z en utilisant la sélection de partie et les concaténations de plusieurs bits. Traiter chaque cas comme le seul code du module, sinon plusieurs assign les déclarations sur le même signal feront certainement que la sortie deviendra X.

  
  
module xyz (input [3:0] 	x,		// x is a 4-bit vector net
						input 				y, 		// y is a scalar net (1-bit)
						output [4:0] 	z ); 	// z is a 5-bit vector net

wire [1:0] 	a;
wire 				b;
						
// Assume one of the following assignments are chosen in real design
// If x='hC and y='h1 let us see the value of z  

// Case #1: 4-bits of x and 1 bit of y is concatenated to get a 5-bit net
// and is assigned to the 5-bit nets of z. So value of z='b11001 or z='h19
assign z = {x, y};

// Case #2: 4-bits of x and 1 bit of y is concatenated to get a 5-bit net
// and is assigned to selected 3-bits of net z. Remaining 2 bits of z remains
// undriven and will be high-imp. So value of z='bZ001Z
assign z[3:1] = {x, y};

// Case #3: The same statement is used but now bit4 of z is driven with a constant
// value of 1. Now z = 'b1001Z because only bit0 remains undriven
assign z[3:1] = {x, y};
assign z[4] = 1;

// Case #4: Assume bit3 is driven instead, but now there are two drivers for bit3,
// and both are driving the same value of 0. So there should be no contention and 
// value of z = 'bZ001Z
assign z[3:1] = {x, y};
assign z[3] = 0;

// Case #5: Assume bit3 is instead driven with value 1, so now there are two drivers
// with different values, where the first line is driven with the value of X which
// at the time is 0 and the second assignment where it is driven with value 1, so
// now it becomes unknown which will win. So z='bZX01Z
assign z[3:1] = {x, y};
assign z[3] = 1;

// Case #6: Partial selection of operands on RHS is also possible and say only 2-bits
// are chosen from x, then z = 'b00001 because z[4:3] will be driven with 0
assign z = {x[1:0], y};

// Case #7: Say we explicitly assign only 3-bits of z and leave remaining unconnected
// then z = 'bZZ001
assign z[2:0] = {x[1:0], y};

// Case #8: Same variable can be used multiple times as well and z = 'b00111
// 3{y} is the same as {y, y, y}
assign z = {3{y}};

// Case #9: LHS can also be concatenated: a is 2-bit vector and b is scalar
// RHS is evaluated to 11001 and LHS is 3-bit wide so first 3 bits from LSB of RHS
// will be assigned to LHS. So a = 'b00 and b ='b1
assign {a, b} = {x, y};

// Case #10: If we reverse order on LHS keeping RHS same, we get a = 'b01 and b='b0
assign {a, b} = {x, y};

endmodule

  

Attribuer des variables de registre

Il est illégal de conduire ou d'attribuer reg tapez les variables avec un assign déclaration. C'est parce qu'un reg La variable est capable de stocker des données et ne nécessite pas d'être pilotée en continu. reg les signaux ne peuvent être pilotés que dans des blocs procéduraux comme initial et always .

Affectation continue implicite

Lorsqu'un assign L'instruction est utilisée pour attribuer une valeur au réseau donné, elle est appelée explicite mission. Verilog permet également d'effectuer une affectation lorsque le réseau est déclaré et est appelé implicite affectation.

  
  
wire [1:0] a;
assign a = x & y; 			// Explicit assignment

wire [1:0] a = x & y; 	// Implicit assignment

  

Conception logique combinatoire

Considérez le circuit numérique suivant composé de portes combinatoires et du code Verilog correspondant.

La logique combinatoire nécessite que les entrées soient pilotées en continu pour maintenir la sortie contrairement aux éléments séquentiels comme les bascules où la valeur est capturée et stockée au bord d'une horloge. Donc un assign correspond bien à l'objectif car la sortie o est mise à jour chaque fois que l'une des entrées du côté droit change.

  
  
// This module takes four inputs and performs a boolean
// operation and assigns output to o. The combinational
// logic is realized using assign statement.

module combo (	input 	a, b, c, d,
								output  o);
  
  assign o = ~((a & b) | c ^ d);
  
endmodule

  

Schéma du matériel

Après l'élaboration et la synthèse de la conception, nous voyons un circuit combinatoire qui se comporterait de la même manière que modélisé par le assign déclaration.

Voir que le signal o devient 1 chaque fois que l'expression combinatoire sur le RHS devient vraie. De même o devient 0 lorsque RHS est faux. La sortie o est X de 0ns à 10ns car les entrées sont X pendant le même temps.

Cliquez ici pour un diaporama avec exemple de simulation !