home Productietechnologie Fabricage-apparatuur
Industriële fabricage
Industrieel internet der dingen | Industriële materialen | Onderhoud en reparatie van apparatuur | Industriële programmering |
home  MfgRobots >> Industriële fabricage >  >> Industrial programming >> Verilog

Verilog operatoren: Essentiële rekenkundige & controle operatoren voor synthetise

Data die niet verwerkt kan worden is nutteloos; er is altijd een vorm van berekening nodig in digitale circuits en computersystemen. Laten we kijken naar operatoren in Verilog die synthetise-tools in staat stellen passende hardware-elementen te realiseren.

Verilog rekenkundige operatoren

Als de tweede operand van een deling of modulus-operator nul is, is het resultaat X. Als een van de operanden van de macht-operator real is, is het resultaat ook real. Het resultaat is 1 als de tweede operand van de macht-operator 0 is (a0).

OperatorBeschrijving
a + ba plus b
a - ba min b
a * ba vermenigvuldigd met b
a / ba gedeeld door b
a % ba modulo b
a ** ba tot de macht b

Een voorbeeld van hoe rekenkundige operatoren gebruikt worden:

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
Simulation Log 
 ncsim> run
Add + = 54
Sub - = 36
Mul * = 149
Div / = 5
Mod % = 0
Pow ** = 81
ncsim: *W,RNQUIE: Simulation is complete.

Verilog relationele operatoren

Een expressie met een relationele operator resulteert in 1 als de expressie true is, 0 als false. Als een van de operanden X of Z is, is het resultaat X. Relationele operatoren hebben lagere precedentie dan rekenkundige operatoren en alle relationele operatoren hebben dezelfde precedentie.

OperatorBeschrijving
a < ba kleiner dan b
a > ba groter dan b
a <= ba kleiner dan of gelijk aan b
a >= ba groter dan of gelijk aan 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
Simulation Log 
 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.

Verilog gelijkheidsoperatoren

Gelijkheidsoperatoren hebben dezelfde precedentie onderling en zijn lager in precedentie dan relationele operatoren. Resultaat is 1 als true, 0 als false. Als een van de operanden van logische-gelijkheid (==) of logische-ongelijkheid (!=) X of Z is, is het resultaat X. Je kunt case-gelijkheid (===) of case-ongelijkheid (!==) gebruiken om X en Z mee te matchen en altijd een bekende waarde te hebben.

OperatorBeschrijving
a === ba gelijk aan b, inclusief x en z
a !== ba niet gelijk aan b, inclusief x en z
a == ba gelijk aan b, resultaat kan onbekend zijn
a != ba niet gelijk aan b, resultaat kan onbekend zijn
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
Simulation Log 
 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.

Verilog logische operatoren

Het resultaat van logische AND (&&) is 1 als beide operanden true of non-zero zijn. Logische OR (||) is 1 als een van de operanden true of non-zero is. Als een operand X is, is resultaat X. Logische negatie (!) zet non-zero/true om in 0 en zero/false in 1, X blijft X.

OperatorBeschrijving
a && bevalueert true als a en b true zijn
a || bevalueert true als a of b true zijn
!aConverteert non-zero naar zero, en 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
Simulation Log 
 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.

Verilog bitwise operatoren

Deze operator combineert een bit in één operand met de corresponderende bit in de andere operand om een enkele bit resultaat te berekenen.

&01xz
00000
101xx
x0xxx
z0xxx
|01xz
001xx
11111
xx1xx
zx1xx
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
Simulation Log 
 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.

Verilog shift-operatoren

Er zijn twee soorten shift-operatoren:

  • Logische shift-operatoren: << en >>
  • Arithmetische shift-operatoren: <<< en >>>>

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

  • C Taal
  • VHDL
  • Verilog
  • MATLAB
  • Python
  • Java
    1. C# Operators – Uitgebreide gids voor operators in C#
    2. Verilog beheersen: Complete tutorial voor digitale schakelingontwerp
    3. Verilog concatenatie beheersen: Een praktische gids
    4. Verilog-toewijzingen begrijpen: types, syntax en best practices
    5. Verilog Blocking vs. Non-Blocking: belangrijkste verschillen uitgelegd
    6. Verilog-functies beheersen voor efficiënt RTL-ontwerp
    7. Verilog Tasks begrijpen: Functions vs Tasks, Syntax en Gebruik
    8. Verilog Clock Generator: Ontwerp & Implementatie Gids
    9. Verilog Math Functions beheersen voor efficiënt Hardware-ontwerp
    10. Verilog $timeformat beheersen: Precisie en Weergave-controle
    11. Verilog Timescales begrijpen en printen in elke Scope