Verilog-gegevenstypen

De primaire bedoeling van gegevenstypen in de Verilog-taal is om gegevensopslagelementen zoals bits in een flip-flop en transmissie-elementen zoals draden weer te geven die verbinding maken tussen logische poorten en sequentiële structuren.

Welke waarden hebben variabelen?

Bijna alle datatypes kunnen slechts één van de vier verschillende waarden hebben, zoals hieronder aangegeven, behalve real en event gegevenstypen.

De volgende afbeelding laat zien hoe deze waarden worden weergegeven in timingdiagrammen en simulatiegolfvormen. De meeste simulators gebruiken deze conventie waarbij rood staat voor X en oranje in het midden staat voor hoge impedantie of Z .

Wat houdt de verilog-waardeset in?

Aangezien Verilog hoofdzakelijk wordt gebruikt om hardware-elementen zoals flip-flops en combinatorische logica zoals NAND en NOR te beschrijven, moet het het waardesysteem in hardware modelleren. Een logische zou de voedingsspanning V_dd . voorstellen die kan variëren van 0,8 V tot meer dan 3 V op basis van het fabricagetechnologieknooppunt. Een logische nul zou aarde vertegenwoordigen en dus een waarde van 0V.

X of x betekent dat de waarde op dat moment gewoon onbekend is en 0 of 1 kan zijn. Dit is heel anders dan de manier waarop X wordt behandeld in booleaanse logica, waar het betekent "maakt niet uit".

Zoals bij elk onvolledig elektrisch circuit, heeft de draad die nergens op is aangesloten een hoge impedantie op dat knooppunt en wordt weergegeven door Z of z . Zelfs in verilog resulteert elke niet-aangesloten draad in een hoge impedantie.

Netten en variabelen

Netten en variabelen zijn de twee hoofdgroepen van gegevenstypen die verschillende hardwarestructuren vertegenwoordigen en verschillen in de manier waarop ze worden toegewezen en waarden behouden.

Netten

Netten worden gebruikt om verbinding te maken tussen hardware-entiteiten zoals logische poorten en slaan daarom op zichzelf geen waarde op. In de onderstaande afbeelding wordt een net met de naam net_11 gebruikt om verbinding te maken tussen de uitgang van de EN-poort en de eerste ingang van de flip-flop genaamd data_0. Op een vergelijkbare manier zijn de twee ingangen van de EN-poort verbonden met de netten net_45 en net_67.

Er zijn verschillende soorten netten, elk met verschillende kenmerken, maar het meest populaire en meest gebruikte net in digitale ontwerpen is van het type wire . Een wire is een Verilog-gegevenstype dat wordt gebruikt om elementen te verbinden en netten aan te sluiten die worden aangedreven door een enkele poort of doorlopende toewijzing. De wire is vergelijkbaar met de elektrische draad die wordt gebruikt om twee componenten op een breadboard te verbinden.

Als er meerdere netten nodig zijn, kunnen ze worden samengevoegd tot een enkele wire . In de onderstaande afbeelding hebben we een 4-bits draad die 4 afzonderlijke waarden op elk van de draden kan verzenden. Dergelijke entiteiten met een breedte van meer dan 1 worden vectoren genoemd, zoals we in het volgende artikel zullen zien.

  
  
wire [3:0] 	n0; 		// 4-bit wire -> this is a vector

  

Het is illegaal om een ​​naam opnieuw te declareren die al is gedeclareerd door een net, parameter of variabele, zoals weergegeven in de onderstaande code.

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

  

Variabelen

Een variabele daarentegen is een abstractie van een gegevensopslagelement en kan waarden bevatten. Een flip-flop is een goed voorbeeld van een opbergelement.

Verilog-gegevenstype reg kan worden gebruikt om hardwareregisters te modelleren, omdat het waarden tussen toewijzingen kan bevatten. Merk op dat een reg hoeft niet altijd een flip-flop te vertegenwoordigen omdat het ook kan worden gebruikt om combinatorische logica weer te geven.

In de afbeelding links hebben we een flip-flop die 1 bit kan opslaan en de flip-flop aan de rechterkant kan 4 bits opslaan.

Andere gegevenstypen

geheel getal

Een integer is een variabele voor algemeen gebruik van 32 bits breed die voor andere doeleinden kan worden gebruikt bij het modelleren van hardware en het opslaan van gehele waarden.

  
  
    integer     count;              // Count is an integer value > 0

  

tijd

Een time variabele is niet-ondertekend, 64-bits breed en kan worden gebruikt om simulatietijdhoeveelheden op te slaan voor foutopsporingsdoeleinden. Een realtime variabele slaat eenvoudig tijd op als een drijvende-kommagrootheid.

  
  
    time        end_time;           // end_time can be stored a time value like 50ns
    realtime    rtime;              // rtime = 40.25ps 

  

echt

Een real variabele kan drijvende-kommawaarden opslaan en kan op dezelfde manier worden toegewezen als integer en reg .

  
  
    real        float;              // float = 12.344  - can store floating numbers

  

Voorbeeld

  
  
module testbench;
  integer  	int_a; 				// Integer variable
  real 		real_b; 			// Real variable
  time 		time_c; 			// Time variable
  
  initial begin
    int_a 	= 32'hcafe_1234; 	// Assign an integer value
    real_b 	= 0.1234567; 		// Assign a floating point value

    #20; 						// Advance simulation time by 20 units
    time_c 	= $time; 			// Assign current simulation time
    
    // Now print all variables using $display system task
    $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 vast te houden. Elk teken in een string vertegenwoordigt een ASCII-waarde en vereist 1 byte. Als de grootte van de variabele kleiner is dan de string, dan kapt Verilog de meest linkse bits van de string af. Als de grootte van de variabele groter is dan de tekenreeks, voegt Verilog nullen toe aan de linkerkant van de tekenreeks.

  
  
// "Hello World" requires 11 bytes

reg [8*11:1] str = "Hello World";         // Variable can store 11 bytes, str = "Hello World"
reg [8*5:1]  str = "Hello World";         // Variable stores only 5 bytes (rest is truncated), str = "World"
reg [8*20:1] str = "Hello World";         // Variable can store 20 bytes (rest is padded with zeros), str = "         Hello World"

  

Hier is een volledig voorbeeld dat laat zien hoe de drie hierboven gegeven variabelen kunnen worden gesimuleerd.

  
  
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

  

Merk op dat str1 de juiste grootte heeft om alle 11 bytes van de string "Hello World" op te slaan en daarom wordt de hele string afgedrukt. str2 kan echter slechts 5 bytes opslaan en daarom worden de bovenste 6 bytes afgekapt en wordt er uiteindelijk alleen "Wereld" opgeslagen. De derde variabele str3 is groter dan 11 bytes en vult lege ruimtes aan de linkerkant in en daarom wordt de waarde die erin is opgeslagen "Hallo Wereld".

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