Zahlen ohne Größenangabe

Teil des Abschnitts Grundlagen der Verilog-Journey von Coddy — Lektion 15 von 90.

Eine unsized number ist eine Zahl, die ohne Angabe der Bitbreite geschrieben wird. Wenn Sie eine Zahl ohne Größen-Präfix schreiben, nimmt Verilog standardmäßig an, dass sie 32 Bits groß ist.

a = 'b1010;        // Unsized: Verilog behandelt dies als 32 Bits
a = 32'b1010;    // Genauso wie oben, aber explizit

Zahlen ohne Größenangabe verwenden nur das Format und den Wert: [format][value]

<strong>format</strong> — die Basis der Zahl: b für binär, d für dezimal, h für hexadezimal oder o für oktal
<strong>value</strong> — die eigentliche Zahl (zum Beispiel 1010)

Der Apostroph ' ist weiterhin zwischen dem Format und dem Wert erforderlich, aber es steht keine Bit-Anzahl davor.

'b1010 — 32-Bit-Binärzahl 1010
'd255 — 32-Bit-Dezimalzahl 255
'hFF — 32-Bit-Hexadezimalzahl FF
'b1 — 32-Bit-Binärzahl 1 (mit 31 führenden Nullen)

Code-Beispiel:

reg [7:0] data;

initial begin
  data = 1010;      // Ohne Größenangabe: 32-Bit-Wert (kann Warnung verursachen)
  data = 'd255;     // Ohne Größenangabe: 32-Bit dezimal 255
  data = 'hFF;      // Ohne Größenangabe: 32-Bit hex FF
end

Unsized vs Sized

	Unsized	Sized
Beispiel	`1010` oder `'d255`	`8'b1010` oder `8'd255`
Bitbreite	32 Bit (Standard)	Explizit (wie angegeben)
Apostroph	Erforderlich bei Formatangabe	Erforderlich
Verwendung	Einfacher Testbench-Code	Hardware-Zuweisungen

Potenzielles Problem

Zahlen ohne Größenangabe können unerwartetes Verhalten verursachen, wenn sie kleineren Registern zugewiesen werden:

reg [3:0] small;
small = 'b1111;      // 32-Bit-Wert, passt aber in 4 Bits (okay)
small = 'b10000;     // 32-Bit-Wert, aber zu groß! (Warnung)

Das zweite Beispiel weist einen 32-Bit-Wert 10000 einem 4-Bit-Register zu. Nur die unteren 4 Bits werden beibehalten (0000), was möglicherweise nicht das ist, was Sie erwarten.

Wann Zahlen ohne Größenangabe verwendet werden

Zahlen ohne Größenangabe sind praktisch für:

Einfache Zahlen in Testbenches
Schleifenzähler
$display-Anweisungen

Für tatsächliche Hardware-Zuweisungen verwenden Sie Zahlen mit Größenangabe, um explizit zu sein und Warnungen zu vermeiden.

Aufgabe

Im folgenden Code sind einige Zahlen ohne Größenangabe (unsized). Ändern Sie diese in Zahlen mit Größenangabe (8 Bits), um Warnungen zu vermeiden.

Was zu tun ist:

Ändern Sie a in eine 8-Bit-Binärzahl für 1010
Ändern Sie b in eine 8-Bit-Dezimalzahl für 255
Ändern Sie c in eine 8-Bit-Hex-Zahl für FF

Spickzettel

Zahlen ohne Größenangabe in Verilog sind standardmäßig 32 Bit groß. Syntax: '[format][value]

'b1010   // 32-Bit binär
'd255    // 32-Bit dezimal
'hFF     // 32-Bit hexadezimal

Zahlen mit Größenangabe verwenden [bits]'[format][value]:

8'b1010  // 8-Bit binär
8'd255   // 8-Bit dezimal
8'hFF    // 8-Bit hexadezimal

Das Zuweisen einer Zahl ohne Größenangabe an ein kleineres Register behält nur die niederwertigen Bits bei — verwenden Sie Zahlen mit Größenangabe für Hardware-Zuweisungen, um Warnungen und unerwartetes Abschneiden zu vermeiden.

Probier es selbst

module unsized_challenge;
  reg [7:0] a, b, c;
  
  initial begin
    a = 'b1010;      // Change to sized (8-bit binary)
    b = 'd255;     // In 8-Bit-Dezimalzahl mit Größenangabe ändern
    c = 'hFF;      // Change to sized (8-bit hex)
    
    $display("a = %b", a);
    $display("b = %b", b);
    $display("c = %b", c);
    $finish;
  end
endmodule