Operadores en Verilog: Aritméticos y de control esenciales para síntesis
Los datos que no se pueden procesar son inútiles; siempre hay algún cálculo requerido en circuitos digitales y sistemas computacionales. Veamos operadores en Verilog que permiten a herramientas de síntesis realizar elementos de hardware apropiados.
Operadores Aritméticos
Si el segundo operando de división o módulo es cero, resultado será X. Si algún operando del operador potencia es real, resultado será real. Resultado será 1 si segundo operando de potencia es 0 (a0).
| Operador | Descripción |
|---|---|
| a + b | a más b |
| a - b | a menos b |
| a * b | a multiplicado por b |
| a / b | a dividido por b |
| a % b | a módulo b |
| a ** b | a elevado a b |
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
Salida:
ncsim> run Add + = 54 Sub - = 36 Mul * = 149 Div / = 5 Mod % = 0 Pow ** = 81 ncsim: *W,RNQUIE: Simulation is complete.
Operadores Relacionales
Expresión con operador relacional resulta 1 si verdadera, 0 si falsa. Si algún operando es X o Z, resultado X. Precedencia menor que aritméticos, todos iguales entre sí.
| Operador | Descripción |
|---|---|
| a < b | a menor que b |
| a > b | a mayor que b |
| a <= b | a menor o igual que b |
| a >= b | a mayor o igual que b |
module des;
reg [7:0] data1, 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
Salida:
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.
Operadores de Igualdad
Misma precedencia entre ellos, menor que relacionales. Resultado 1 si verdadero, 0 si falso. Si algún operando de igualdad lógica (==) o desigualdad (!=) es X o Z, resultado X. Usa igualdad de caso (===) o desigualdad de caso (!==) para comparar incluyendo X y Z, siempre valor conocido.
| Operador | Descripción |
|---|---|
| a === b | a igual a b, incluyendo x y z |
| a !== b | a no igual a b, incluyendo x y z |
| a == b | a igual a b, resultado puede ser desconocido |
| a != b | a no igual a b, resultado puede ser desconocido |
module des;
reg [7:0] data1, 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
Salida:
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.
Operadores Lógicos
Resultado de AND lógico (&&) es 1 cuando ambos operandos verdaderos/no-cero. OR lógico (||) es 1 cuando alguno verdadero/no-cero. Si algún operando es X, resultado X. Negación lógica (!) convierte no-cero/verdadero en 0 y cero/falso en 1, X permanece X.
| Operador | Descripción |
|---|---|
| a && b | evalúa true si a y b son true |
| a || b | evalúa true si a o b son true |
| !a | Convierte no-cero a cero y viceversa |
module des;
reg [7:0] data1, 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
Salida:
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.
Operadores Bit a Bit
Combinan un bit en un operando con su correspondiente en el otro para calcular resultado de un bit.
| & | 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
Salida (tabla de verdad AND):
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.
Operadores de Desplazamiento (Shift)
Dos tipos:
- Lógicos: << y >>
- Aritméticos: <<< y >>>
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
Salida:
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.
Diseñar lógica combinacional en Verilog usando sentencias assign continuas
Dominar la concatenación en Verilog: Guía práctica
Verilog
- Operadores en C# – Guía completa de operadores en C#
- Dominar Verilog: Tutorial completo para diseño de circuitos digitales
- Dominar la concatenación en Verilog: Guía práctica
- Comprender las asignaciones en Verilog: tipos, sintaxis y mejores prácticas
- Bloqueante vs. No bloqueante en Verilog: Diferencias clave explicadas
- Dominar las funciones en Verilog para diseño RTL eficiente
- Comprender las Tasks en Verilog: Funciones vs Tasks, sintaxis y uso
- Generador de reloj en Verilog: Guía de diseño e implementación
- Dominar las funciones matemáticas en Verilog para diseño de hardware eficiente
- Dominar $timeformat en Verilog: Control de precisión y visualización
- Comprender e imprimir timescales de Verilog en cualquier alcance