Verilog scalair en vector

Verilog moet zowel individuele bits als groepen bits vertegenwoordigen. Een sequentieel element met een enkel bit is bijvoorbeeld een flip-flop. Een 16-bits sequentieel element is echter een register dat 16 bits kan bevatten. Voor dit doel heeft Verilog scalar en vector netten en variabelen.

Scalair en vector

Een net of reg declaratie zonder bereikspecificatie wordt als 1-bits breed beschouwd en is een scalar . Als een bereik is opgegeven, dan is het net of reg wordt een multibit-entiteit die bekend staat als een vector .

  
  
	wire 	    o_nor;           // single bit scalar net
	wire [7:0]  o_flop;          // 8-bit vector net
	reg         parity;          // single bit scalar variable
	reg  [31:0] addr;            // 32 bit vector variable to store address

  

Het bereik geeft de mogelijkheid om individuele bits in een vector te adresseren. Het meest significante bit van de vector moet worden opgegeven als de linkerwaarde in het bereik, terwijl het minst significante bit van de vector aan de rechterkant moet worden opgegeven.

  
  
	wire  [msb:lsb]   name;
	integer           my_msb;
	
	wire [15:0]        priority;      // msb = 15, lsb = 0
	wire [my_msb: 2]   prior;         // illegal

  

In het bovenstaande voorbeeld wordt een 16-bits breed net met de naam prioriteit gemaakt. Merk op dat de msb en lsb moet een constante uitdrukking zijn en kan niet worden vervangen door een variabele. Maar ze kunnen elke gehele waarde zijn - positief, negatief of nul; en de lsb waarde kan groter zijn dan, gelijk aan of kleiner zijn dan msb-waarde.

Bit-selecties

Elk bit in een vectorvariabele kan afzonderlijk worden geselecteerd en een nieuwe waarde krijgen, zoals hieronder wordt weergegeven. Dit wordt een bit-select . genoemd . Als de bitselectie buiten de grenzen valt of de bitselectie x . is of z , dan is de geretourneerde waarde x .

  
  
	reg [7:0]      addr;         // 8-bit reg variable [7, 6, 5, 4, 3, 2, 1, 0]
	
	addr [0] = 1;                // assign 1 to bit 0 of addr
	addr [3] = 0;                // assign 0 to bit 3 of addr
	addr [8] = 1;                // illegal : bit8  does not exist in addr

  

Deelselecties

Een reeks aaneengesloten bits kan worden geselecteerd en staat bekend als een part-select . Er zijn twee soorten deelselecties, een met een constante deelselectie en een andere met een geïndexeerde deelselectie.

  
  
	reg [31:0]    addr;
	
	addr [23:16] = 8'h23;         // bits 23 to 16 will be replaced by the new value 'h23 -> constant part-select

  

Met een variabele deelselectie kan deze effectief in lussen worden gebruikt om delen van de vector te selecteren. Hoewel het startbit kan worden gevarieerd, moet de breedte constant zijn.

[<start_bit> +: <width>]     // part-select increments from start-bit
[<start_bit> -: <width>]     // part-select decrements from start-bit

  
  
module des;
  reg [31:0]  data;
  int         i;
  
  initial begin
    data = 32'hFACE_CAFE;
    for (i = 0; i < 4; i++) begin
      $display ("data[8*%0d +: 8] = 0x%0h", i, data[8*i +: 8]);
    end
    
    $display ("data[7:0]   = 0x%0h", data[7:0]);
    $display ("data[15:8]  = 0x%0h", data[15:8]);
    $display ("data[23:16] = 0x%0h", data[23:16]);
    $display ("data[31:24] = 0x%0h", data[31:24]);
  end
  
endmodule

  

ncsim> run
data[8*0 +: 8] = 0xfe              // ~ data [8*0+8 : 8*0]
data[8*1 +: 8] = 0xca              // ~ data [8*1+8 : 8*1]
data[8*2 +: 8] = 0xce              // ~ data [8*2+8 : 8*2]
data[8*3 +: 8] = 0xfa              // ~ data [8*3+8 : 8*3]

data[7:0]   = 0xfe
data[15:8]  = 0xca
data[23:16] = 0xce
data[31:24] = 0xfa
ncsim: *W,RNQUIE: Simulation is complete.

Veelvoorkomende fouten

  
  
module tb;
   reg [15:0]    data;
   
   initial begin
      $display ("data[0:9] = 0x%0h", data[0:9]);   // Error : Reversed part-select index expression ordering
   end
endmodule