Verilog-datatypes: Bits, wires en logische waarden uitgelegd

Het primaire doel van datatypes in Verilog is het voorstellen van data-opslagelementen zoals bits in een flipflop en transmissie-elementen zoals draden die logische gates en sequentiële structuren verbinden.

Welke waarden houden variabelen?

Bijna alle datatypes kunnen slechts één van de vier waarden hebben, behalve real en event:

De volgende afbeelding toont hoe deze waarden in timingdiagrammen en simulatiegolven worden weergegeven. Meeste simulators gebruiken deze conventie: rood staat voor X en oranje in het midden voor hoog-impedantie of Z.

Wat impliceert de Verilog-waardenset?

Omdat Verilog hardware-elementen beschrijft zoals flipflops en combinatorische logica (NAND, NOR), moet het het waardensysteem in hardware modelleren. Logische een vertegenwoordigt de spanningsvoorziening V_dd (0.8V tot >3V afhankelijk van technologienode). Logische nul vertegenwoordigt ground (0V).

X of x betekent dat de waarde onbekend is op dat moment, en 0 of 1 kan zijn. Dit verschilt van Booleaanse logica waar X "don't care" betekent.

Net als bij een onvolledig elektrisch circuit, heeft een draad die nergens met verbonden is een hoog-impedantie op dat knooppunt, voorgesteld door Z of z. In Verilog resulteert elke onverbonden draad in hoog-impedantie.

Nets en variabelen

Nets en variabelen zijn de twee hoofdcategorieën van datatypes die verschillende hardware-structuren voorstellen en verschillen in toewijzing en waardebehoud.

Nets

Nets worden gebruikt om te verbinden tussen hardware-entiteiten zoals logische gates en slaan geen waarde op zich op. In de onderstaande afbeelding verbindt een net net_11 de uitgang van de AND-gate met de eerste ingang van de flipflop data_0. De twee ingangen van de AND-gate zijn verbonden met nets net_45 en net_67.

Er zijn verschillende nettypes, maar de populairste en meest gebruikte in digitale ontwerpen is wire. Een wire is een Verilog-datatype om elementen te verbinden en nets die gedreven worden door een enkele gate of continue toewijzing. De wire is vergelijkbaar met de elektrische draad die twee componenten op een breadboard verbindt.

Als er meerdere nets nodig zijn, kunnen ze gebundeld worden tot een enkele wire. In de afbeelding hieronder hebben we een 4-bit wire die 4 afzonderlijke waarden kan zenden. Dergelijke entiteiten met een breedte >1 heten vectoren (zie volgende artikel).

wire [3:0] n0; // 4-bit wire -> dit is een vector

Het is illegaal een naam opnieuw te declareren die al gedeclareerd is als net, parameter of variabele:

module design;
wire abc;
wire a;
wire b;
wire c;
wire abc; // Fout: Identifier "abc" previously declared
assign abc = a & b | c;
endmodule

Variabelen

Een variabele is een abstractie van een data-opslagelement en kan waarden vasthouden. Een flipflop is een goed voorbeeld van een opslagelement.

Verilog-datatype reg kan hardwareregisters modelleren omdat het waarden kan vasthouden tussen toewijzingen. Let op: een reg hoeft niet altijd een flipflop voor te stellen; het kan ook combinatorische logica voorstellen.

In de afbeelding links zien we een flipflop dat 1 bit kan opslaan, en rechts een flipflop dat 4 bits kan opslaan.

Overige datatypes

integer

Een integer is een algemene variabele van 32-bits breed die gebruikt kan worden voor andere doeleinden tijdens het modelleren van hardware en gehele getallen opslaat.

integer count; // Count is een integer waarde > 0

time

Een time variabele is unsigned, 64-bits breed en kan simulatietijdwaarden opslaan voor debugging. Een realtime variabele slaat tijd op als drijvendekommagetal.

time end_time; // end_time kan een tijdwaarde opslaan zoals 50ns
realtime rtime; // rtime = 40.25ps

real

Een real variabele kan drijvendekommagetallen opslaan en wordt op dezelfde manier toegewezen als integer en reg.

real float; // float = 12.344 - kan drijvende getallen opslaan

Voorbeeld

module testbench;
integer int_a; // Integer variabele
real real_b;   // Real variabele
time time_c;   // Time variabele
initial begin
    int_a = 32'hcafe_1234; // Ken een integer waarde toe
    real_b = 0.1234567;    // Ken een drijvendekommagetal toe
    #20;                   // Verhoog simulatietijd met 20 eenheden
    time_c = $time;        // Ken huidige simulatietijd toe
    // Print alle variabelen met $display systeeltaak
    $display ("int_a = 0x%0h", int_a);
    $display ("real_b = %0.5f", real_b);
    $display ("time_c = %0t", time_c);
end
endmodule

 ncsim> run
int_a = 0xcafe1234
real_b = 0.12346
time_c = 20
ncsim: *W,RNQUIE: Simulation is complete. 

Verilog Strings

Strings worden opgeslagen in reg, en de breedte van de reg variabele moet groot genoeg zijn om de string te houden. Elk teken in een string vertegenwoordigt een ASCII-waarde en vereist 1 byte. Als de variabelengrootte kleiner is dan de string, knipt Verilog de linkerbits af. Als de variabele groter is, voegt Verilog nullen toe aan de linkerkant.

// "Hello World" vereist 11 bytes
reg [8*11:1] str = "Hello World"; // Variabele kan 11 bytes opslaan, str = "Hello World"
reg [8*5:1] str = "Hello World"; // Variabele slaat slechts 5 bytes op (rest geknipt), str = "World"
reg [8*20:1] str = "Hello World"; // Variabele kan 20 bytes opslaan (rest gepadded met nullen), str = " Hello World"

Hier is een volledig voorbeeld hoe de drie variabelen gesimuleerd worden:

module testbench;
reg [8*11:1] str1;
reg [8*5:1] str2;
reg [8*20:1] str3;
initial begin
    str1 = "Hello World";
    str2 = "Hello World";
    str3 = "Hello World";
    $display ("str1 = %s", str1);
    $display ("str2 = %s", str2);
    $display ("str3 = %s", str3);
end
endmodule

Let op: str1 heeft de juiste grootte voor alle 11 bytes van "Hello World" en de hele string wordt geprint. Str2 kan slechts 5 bytes opslaan, dus de bovenste 6 bytes worden geknipt en "World" blijft over. Str3 is groter dan 11 bytes en vult lege ruimtes aan links, dus de waarde wordt " Hello World".

 ncsim> run
str1 = Hello World
str2 = World
str3 = Hello World
ncsim: *W,RNQUIE: Simulation is complete.