Opérateurs Verilog
Les données qui ne peuvent pas être traitées sont tout à fait inutiles, il y aura toujours une forme de calcul requise dans les circuits numériques et les systèmes informatiques. Examinons quelques-uns des opérateurs de Verilog qui permettraient aux outils de synthèse de réaliser les éléments matériels appropriés.
Opérateurs arithmétiques Verilog
Si le deuxième opérande d'un opérateur de division ou de module est zéro, alors le résultat sera X. Si l'un ou l'autre des opérandes de l'opérateur de puissance est réel, alors le résultat sera également réel. Le résultat sera 1 si le deuxième opérande d'un opérateur de puissance est 0 (a 0 ).
| Opérateur | Description |
|---|---|
| a + b | a plus b |
| a - b | a moins b |
| a * b | a multiplié par b |
| a / b | a divisé par b |
| a % b | a modulo b |
| a ** b | a à la puissance b |
Un exemple d'utilisation des opérateurs arithmétiques est donné ci-dessous.
module des;
reg [7:0] data1;
reg [7:0] data2;
initial begin
data1 = 45;
data2 = 9;
$display ("Add + = %d", data1 + data2);
$display ("Sub - = %d", data1 - data2);
$display ("Mul * = %d", data1 * data2);
$display ("Div / = %d", data1 / data2);
$display ("Mod %% = %d", data1 % data2);
$display ("Pow ** = %d", data2 ** 2);
end
endmodule
Journal de simulation ncsim> run Add + = 54 Sub - = 36 Mul * = 149 Div / = 5 Mod % = 0 Pow ** = 81 ncsim: *W,RNQUIE: Simulation is complete.
Opérateurs relationnels Verilog
Une expression avec l'opérateur relationnel se traduira par un 1 si l'expression est évaluée comme étant vraie et 0 si elle est fausse. Si l'un des opérandes est X ou Z, alors le résultat sera X. Les opérateurs relationnels ont une priorité inférieure aux opérateurs arithmétiques et tous les opérateurs relationnels ont la même priorité.
| Opérateur | Description |
|---|---|
a | a moins que b | |
| a> b | a supérieur à b |
| a <=b | a inférieur ou égal à b |
| a>=b | a supérieur ou égal à b |
module des;
reg [7:0] data1;
reg [7:0] data2;
initial begin
data1 = 45;
data2 = 9;
$display ("Result for data1 >= data2 : %0d", data1 >= data2);
data1 = 45;
data2 = 45;
$display ("Result for data1 <= data2 : %0d", data1 <= data2); data1 = 9; data2 = 8; $display ("Result for data1 > data2 : %0d", data1 > data2);
data1 = 22;
data2 = 22;
$display ("Result for data1 < data2 : %0d", data1 < data2);
end
endmodule
Journal de simulation ncsim> run Result for data1 >= data2 : 1 Result for data1 <= data2 : 1 Result for data1 > data2 : 1 Result for data1 < data2 : 0 ncsim: *W,RNQUIE: Simulation is complete.
Opérateurs d'égalité Verilog
Les opérateurs d'égalité ont la même priorité entre eux et sont moins prioritaires que relationnel les opérateurs. Le résultat est 1 si vrai et 0 si faux. Si l'un des opérandes d'égalité logique (==) ou d'inégalité logique (!=) est X ou Z, alors le résultat sera X. Vous pouvez utiliser l'opérateur d'égalité de casse (===) ou l'opérateur d'inégalité de casse (!==) pour faire correspondre X et Z et aura toujours une valeur connue.
| Opérateur | Description |
|---|---|
| a ===b | a égal à b, y compris x et z |
| a !==b | a différent de b, y compris x et z |
| a ==b | a égal à b, le résultat peut être inconnu |
| a !=b | a différent de b, le résultat peut être inconnu |
module des;
reg [7:0] data1;
reg [7:0] data2;
initial begin
data1 = 45; data2 = 9; $display ("Result for data1(%0d) === data2(%0d) : %0d", data1, data2, data1 === data2);
data1 = 'b101x; data2 = 'b1011; $display ("Result for data1(%0b) === data2(%0b) : %0d", data1, data2, data1 === data2);
data1 = 'b101x; data2 = 'b101x; $display ("Result for data1(%0b) === data2(%0b) : %0d", data1, data2, data1 === data2);
data1 = 'b101z; data2 = 'b1z00; $display ("Result for data1(%0b) !== data2(%0b) : %0d", data1, data2, data1 !== data2);
data1 = 39; data2 = 39; $display ("Result for data1(%0d) == data2(%0d) : %0d", data1, data2, data1 == data2);
data1 = 14; data2 = 14; $display ("Result for data1(%0d) != data2(%0d) : %0d", data1, data2, data1 != data2);
end
endmodule
Journal de simulation ncsim> run Result for data1(45) === data2(9) : 0 Result for data1(101x) === data2(1011) : 0 Result for data1(101x) === data2(101x) : 1 Result for data1(101z) !== data2(1z00) : 1 Result for data1(39) == data2(39) : 1 Result for data1(14) != data2(14) : 0 ncsim: *W,RNQUIE: Simulation is complete.
Opérateurs logiques Verilog
Le résultat d'un et logique (&&) est 1 ou vrai lorsque ses deux opérandes sont vrais ou différents de zéro. Le résultat d'un ou logique (||) est 1 ou vrai lorsque l'un de ses opérandes est vrai ou différent de zéro. Si l'un des opérandes est X, le résultat sera également X. L'opérateur de négation logique (!) convertira un opérande non nul ou vrai en 0 et un opérande nul ou faux en 1, tandis qu'un X restera comme un X.
| Opérateur | Description |
|---|---|
| a &&b | est évalué à vrai si un et b sont vrais |
| a || b | est évalué à vrai si un ou b sont vrais |
| !a | Convertit une valeur non nulle en zéro, et vice versa |
module des;
reg [7:0] data1;
reg [7:0] data2;
initial begin
data1 = 45; data2 = 9; $display ("Result of data1(%0d) && data2(%0d) : %0d", data1, data2, data1 && data2);
data1 = 0; data2 = 4; $display ("Result of data1(%0d) && data2(%0d) : %0d", data1, data2, data1 && data2);
data1 = 'dx; data2 = 3; $display ("Result of data1(%0d) && data2(%0d) : %0d", data1, data2, data1 && data2);
data1 = 'b101z; data2 = 5; $display ("Result of data1(%0d) && data2(%0d) : %0d", data1, data2, data1 && data2);
data1 = 45; data2 = 9; $display ("Result of data1(%0d) || data2(%0d) : %0d", data1, data2, data1 || data2);
data1 = 0; data2 = 4; $display ("Result of data1(%0d) || data2(%0d) : %0d", data1, data2, data1 || data2);
data1 = 'dx; data2 = 3; $display ("Result of data1(%0d) || data2(%0d) : %0d", data1, data2, data1 || data2);
data1 = 'b101z; data2 = 5; $display ("Result of data1(%0d) || data2(%0d) : %0d", data1, data2, data1 || data2);
data1 = 4; $display ("Result of !data1(%0d) : %0d", data1, !data1);
data1 = 0; $display ("Result of !data1(%0d) : %0d", data1, !data1);
end
endmodule
Journal de simulation ncsim> run Result of data1(45) && data2(9) : 1 Result of data1(0) && data2(4) : 0 Result of data1(x) && data2(3) : x Result of data1(Z) && data2(5) : 1 Result of data1(45) || data2(9) : 1 Result of data1(0) || data2(4) : 1 Result of data1(x) || data2(3) : 1 Result of data1(Z) || data2(5) : 1 Result of !data1(4) : 0 Result of !data1(0) : 1 ncsim: *W,RNQUIE: Simulation is complete.
Opérateurs Bitwise Verilog
Cet opérateur combinera un bit dans un opérande avec son bit correspondant dans l'autre opérande pour calculer un résultat de bit unique.
| & | 0 | 1 | x | z |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 1 | 0 | 1 | x | x |
| x | 0 | x | x | x |
| z | 0 | x | x | x |
| | | 0 | 1 | x | z |
|---|---|---|---|---|
| 0 | 0 | 1 | x | x |
| 1 | 1 | 1 | 1 | 1 |
| x | x | 1 | x | x |
| z | x | 1 | x | x |
module des;
reg data1 [4] ;
reg data2 [4] ;
int i, j;
initial begin
data1[0] = 0; data2[0] = 0;
data1[1] = 1; data2[1] = 1;
data1[2] = 'x; data2[2] = 'x;
data1[3] = 'z; data2[3] = 'z;
for (i = 0; i < 4; i += 1) begin
for (j = 0; j < 4; j += 1) begin
$display ("data1(%0d) & data2(%0d) = %0d", data1[i], data2[j], data1[i] & data2[j]);
end
end
end
endmodule
Journal de simulation ncsim> run data1(0) & data2(0) = 0 data1(0) & data2(1) = 0 data1(0) & data2(x) = 0 data1(0) & data2(z) = 0 data1(1) & data2(0) = 0 data1(1) & data2(1) = 1 data1(1) & data2(x) = x data1(1) & data2(z) = x data1(x) & data2(0) = 0 data1(x) & data2(1) = x data1(x) & data2(x) = x data1(x) & data2(z) = x data1(z) & data2(0) = 0 data1(z) & data2(1) = x data1(z) & data2(x) = x data1(z) & data2(z) = x ncsim: *W,RNQUIE: Simulation is complete.
Opérateurs Verilog Shift
Il existe deux types d'opérateurs de décalage :
- Opérateurs de décalage logique :<< and>>
- Opérateurs de décalage arithmétique :<<
>>
module des;
reg [7:0] data;
int i;
initial begin
data = 8'h1;
$display ("Original data = 'd%0d or 'b%0b", data, data);
for (i = 0; i < 8; i +=1 ) begin
$display ("data << %0d = 'b%b", i, data << i);
end
data = 8'h80;
$display ("Original data = 'd%0d or 'b%0b", data, data);
for (i = 0; i < 8; i +=1 ) begin $display ("data >> %0d = 'b%b", i, data >> i);
end
data = 8'h1;
$display ("
data >> 1 = 'b%b", data >> 1);
end
endmodule
Journal de simulation ncsim> run Original data = 'd1 or 'b00000001 data << 0 = 'b00000001 data << 1 = 'b00000010 data << 2 = 'b00000100 data << 3 = 'b00001000 data << 4 = 'b00010000 data << 5 = 'b00100000 data << 6 = 'b01000000 data << 7 = 'b10000000 Original data = 'd128 or 'b10000000 data >> 0 = 'b10000000 data >> 1 = 'b01000000 data >> 2 = 'b00100000 data >> 3 = 'b00010000 data >> 4 = 'b00001000 data >> 5 = 'b00000100 data >> 6 = 'b00000010 data >> 7 = 'b00000001 data >> 1 = 'b00000000 ncsim: *W,RNQUIE: Simulation is complete.
Verilog