Literały liczbowe w Verilogu: binarne, hex, dziesiętne i stałe z rozmiarem

Budowa literału z rozmiarem

Literał w Verilogu ma do trzech części:

8'b1010_1100
│  │ │
│  │ └─ digits in the chosen base
│  └─── base specifier: b (binary), h (hex), d (decimal), o (octal)
└────── width in bits (decimal)

Czytając od lewej do prawej: "8-bitowa wartość zapisana binarnie cyframi 10101100". To 172 dziesiętnie i 0xAC szesnastkowo: te same bity, niezależnie od zapisu. Szerokość mówi kompilatorowi dokładnie, ile bitów przydzielić, a podstawa, jak interpretować cyfry.

Podkreślenia to wizualne separatory. 32'b1010_1100_0011_0101 to to samo co 32'b1010110000110101. Używaj ich.

Cztery podstawy

module bases;
    initial begin
        $display("binary  4'b1010 = %0d", 4'b1010);   // 10
        $display("hex     8'hFF   = %0d", 8'hFF);     // 255
        $display("decimal 16'd100 = %0d", 16'd100);   // 100
        $display("octal   6'o77   = %0d", 6'o77);     // 63
        $finish;
    end
endmodule

Zapis szesnastkowy (h) to standard dla wszystkiego, co ma więcej niż 4 bity. Zapis binarny (b) to standard, gdy chcesz bezpośrednio czytać wzorce bitów. Zapis dziesiętny (d) służy do liczb mających znaczenie dla człowieka. Zapis ósemkowy (o) istnieje, ale prawie nigdy go nie zobaczysz.

Wielkość liter w cyfrach szesnastkowych nie ma znaczenia: 8'hAB i 8'hab są identyczne.

Co się dzieje, gdy wartość się nie mieści?

Jeśli cyfry nie wypełniają zadeklarowanej szerokości, Verilog dopełnia zerami z lewej strony:

8'b101       // equivalent to 8'b00000101  (= 5)
8'hF         // equivalent to 8'h0F        (= 15)

Jeśli cyfry przekraczają zadeklarowaną szerokość, Verilog obcina starsze bity i wyświetla ostrzeżenie:

4'hFF        // truncates to 4'hF, simulator warns
4'b10000     // truncates to 4'b0000

To ostrzeżenie jest twoim sprzymierzeńcem. Nie wyłączaj go.

Z rozmiarem i bez rozmiaru

Literał bez szerokości:

'd10    // unsized, takes default size (≥32 bits)
10      // also unsized - no base means decimal

W większości narzędzi literały bez rozmiaru mają domyślnie 32 bity. To źródło całej klasy błędów:

reg [7:0] count;
if (count == -1) ...      // -1 is unsized 32-bit; comparison gets weird

Rozwiązanie to zapis 8'hFF zamiast -1, albo 8'd255, albo {8{1'b1}}. Zawsze podawaj rozmiar literałów używanych w wyrażeniach o określonej szerokości.

Jedyne miejsce, w którym literały bez rozmiaru są w porządku, to liczniki całkowite w pętlach for testbenchy, bo liczba całkowita jest tam na tyle szeroka, że nic zaskakującego się nie dzieje.

Literały ze znakiem

Domyślnie literały z rozmiarem są bez znaku:

8'd255   // unsigned 255
8'b1111_1111   // unsigned 255 - same bit pattern, just written differently

Jeśli literał ma być interpretowany jako liczba ze znakiem, dodaj s po apostrofie:

8'sd10           // signed 10
8'sb1111_1111    // signed -1 (two's complement)

Flaga s ma znaczenie dla:

• Operatorów <<< i >>> (przesunięć arytmetycznych), które rozszerzają argumenty ze znakiem bitem znaku.
• Operatorów porównania w mieszanych wyrażeniach ze znakiem.
• Rzutowań $signed/$unsigned.

W większości zwykłych obliczeń na sygnałach magistral zostawisz s w spokoju.

Literały liczbowe z X i Z

Cyfrą literału może być x (wartość nieznana) albo z (wysoka impedancja):

module xz_literals;
    initial begin
        $display("partial unknown: %b", 8'b1010_xxxx);
        $display("partial high-Z:  %b", 8'b0000_zzzz);
        $display("all unknown:     %b", 8'bx);
        $finish;
    end
endmodule

8'bx to skrót od "wszystkie 8 bitów nieznane": wartość jest powielana, żeby wypełnić zadeklarowaną szerokość. Cyfry x są częste w gałęziach default maszyn stanów i przy inicjalizacji. Ich semantykę omawiamy w artykule Wartości X i Z.

Gdzie literały z rozmiarem pojawiają się w praktyce

Gdy zaczniesz pisać prawdziwe moduły, literały z rozmiarem pojawią się wszędzie:

// Bus widths
input  wire [31:0] addr;
wire [31:0] zero = 32'h0;
wire [31:0] all_ones = 32'hFFFF_FFFF;

// State encodings
localparam IDLE = 3'd0;
localparam BUSY = 3'd1;
localparam DONE = 3'd2;

// Masks
wire is_msb_set = data & 32'h8000_0000;

// Comparisons
if (counter == 8'd255) ...

// Reset values
always @(posedge clk) begin
    if (reset) data_out <= 8'd0;
    else       data_out <= data_in;
end

Wzorzec jest zawsze ten sam: podaj szerokość, podaj podstawę, podaj cyfry. Każdy literał, po który sięgniesz, ma taki sam kształt.

Jazda próbna

module literal_tour;
    reg [7:0]  byte_val;
    reg [15:0] word_val;
    reg [31:0] big_val;

    initial begin
        byte_val = 8'hAC;
        word_val = 16'b1010_1100_0011_0101;
        big_val  = 32'd1_000_000;

        $display("byte_val = %h (decimal %0d)", byte_val, byte_val);
        $display("word_val = %h (decimal %0d)", word_val, word_val);
        $display("big_val  = %h (decimal %0d)", big_val,  big_val);

        // Underscores are just visual.
        if (32'd1_000_000 == 32'd1000000) $display("yes, underscores are ignored");

        $finish;
    end
endmodule

Masz już wszystko, czego potrzebujesz, żeby zapisać dowolną stałą, jakiej może potrzebować moduł w Verilogu. Ostatni element historii o typach danych to to, co się dzieje, gdy sygnał nie jest czystym 0 albo 1, czyli wartości x i z.