Verilog Case İfadesi: Çok Yönlü Decoding Doğru Yapılır

Çok Yönlü Branch

case, Verilog'un düz dispatch yapısıdır. Ona bir ifade verirsin; eşleşen dalı seçer:

case (expression)
    pattern_1: statement_1;
    pattern_2: statement_2;
    pattern_3: begin
        statement_3a;
        statement_3b;
    end
    default: default_statement;
endcase

C'nin switch'ine yapısal olarak benzer, ama:

• break yoktur - her dal bir sonraki tarafından örtük olarak sonlandırılır.
• Kalıplar yalnızca tamsayılar değil, vektörler de olabilir.
• Sentezleyici tüm yapıyı düz bir mux'a (veya kalıplar mümkün kıldığında one-hot decoder'a) dönüştürür.

Çalışılmış Örnek: 4-to-1 Mux

module mux4(
    input  wire [1:0] sel,
    input  wire [7:0] in0, in1, in2, in3,
    output reg  [7:0] out
);
    always @(*) begin
        case (sel)
            2'd0: out = in0;
            2'd1: out = in1;
            2'd2: out = in2;
            2'd3: out = in3;
            default: out = 8'bx;
        endcase
    end
endmodule

module test;
    reg [1:0] sel;
    wire [7:0] out;
    wire [7:0] a = 8'hA0, b = 8'hB0, c = 8'hC0, d = 8'hD0;

    mux4 dut(.sel(sel), .in0(a), .in1(b), .in2(c), .in3(d), .out(out));

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            sel = i[1:0];
            #1 $display("sel=%0d out=%h", sel, out);
        end
        $finish;
    end
endmodule

case gövdesinde dört açık kalıp artı bir default vardır. Sentezleyici dört değerden birine eşleştirilen 2 bitlik bir giriş görür ve 4-to-1 multiplexer çıkarır. Temiz, düz, hızlı.

default Neden Gerekli

Kombinasyonel case için, default'u atlamak else olmadan if tuzağının aynısıdır: eşleşmeyen herhangi bir giriş değeri out'u atanmamış bırakır ve sentezleyici bir latch çıkarır.

2 bitlik sel için yukarıdaki kalıplar dört olası değerin tamamını kapsar - yani teoride default gereksizdir. Pratikte:

1. Sentezleyici her zaman case'lerin kapsamlı olduğunu kanıtlayamaz.
2. Seçici simülasyonda x veya z olabilir, bu da hiçbir açık case ile eşleşmez.
3. Daha sonra yeni bir case eklemek, varsayılan davranışı belirtilmemiş bırakabilir.

Her zaman default yaz. Varsayılanın ulaşılamaz olduğunu bildiğin state machine'ler ve mux mantığı için 'x ataması:

default: out = 8'bx;

…sentezleyiciye "bu bir don't-care, serbest optimize et" der ve ulaşılamaz case bir şekilde ulaşılırsa simülasyonda parlak kırmızı bir x ortaya çıkarır. Her iki dünyanın da en iyisi.

case İçinde Bir State Machine

case'in klasik kullanımı, sonlu durum makinesinin durum geçiş mantığıdır:

module traffic_light(
    input  wire       clk,
    input  wire       reset,
    output reg  [1:0] light    // 00=kırmızı, 01=sarı, 10=yeşil
);
    localparam RED    = 2'd0;
    localparam GREEN  = 2'd1;
    localparam YELLOW = 2'd2;

    reg [1:0] state;
    reg [3:0] timer;

    always @(posedge clk) begin
        if (reset) begin
            state <= RED;
            timer <= 4'd0;
        end else if (timer == 4'd0) begin
            case (state)
                RED:    begin state <= GREEN;  timer <= 4'd6; end
                GREEN:  begin state <= YELLOW; timer <= 4'd2; end
                YELLOW: begin state <= RED;    timer <= 4'd5; end
                default: begin state <= RED;   timer <= 4'd0; end
            endcase
        end else begin
            timer <= timer - 4'd1;
        end
    end

    always @(*) light = state;
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    wire [1:0] light;
    traffic_light dut(.clk(clk), .reset(reset), .light(light));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #200 $finish;
    end

    always @(posedge clk)
        $display("t=%0t light=%0d", $time, light);
endmodule

case (state) bloğu durum geçiş mantığıdır. Her dal sonraki durumun ne olacağına ve ne kadar süre orada kalınacağına karar verir. default burada ulaşılmazdır (RED/GREEN/YELLOW'u 2 bitlik alanda kapsamlı olarak kapsarız) ama bir güvenlik ağı olarak burada - state bir şekilde 2'd3 olursa, FSM latch yerine temiz bir şekilde RED'e reset olur.

Finite State Machines bu kalıba daha derinden iner.

Dal Başına Birden Çok Kalıp

Tek bir ifadeyi paylaşan birkaç kalıbı virgülle ayırarak listeleyebilirsin:

case (opcode)
    4'h0, 4'h1, 4'h2: result = a + b;
    4'h3, 4'h4:       result = a - b;
    4'h8:             result = a & b;
    default:          result = 8'd0;
endcase

Bu, ikisi "çıkar", üçü "topla" anlamına gelen opcode'lar. Sentezleyici karşılaştırıcı için kalıpları OR'lar.

casez ve casex: Don't-Care Eşleştirme

Bazen bazı bitleri belirtilmemiş bir kalıpla eşleşmek istersin - "010 ile başlayan herhangi bir opcode":

casez (opcode)
    8'b010?_????: instruction = ALU_OP;
    8'b110?_????: instruction = LOAD_OP;
    8'b1110_????: instruction = JUMP_OP;
    default:      instruction = UNKNOWN;
endcasez

casez, kalıptaki ? (ve z) değerlerini don't-care olarak işler. Her ?, 0 veya 1 ile eşleşir. Belirli opcode sınıfları için bazı bit pozisyonlarının kullanılmadığı instruction formatlarını decode etmek için kullanışlıdır.

casex bunu x değerini de don't-care olarak işleyecek şekilde genişletir. casex tehlikelidir çünkü initialize edilmemiş sinyaller (simülasyonda x olan), her case ile eşleşir ve sürpriz davranış üretir. Çoğu modern stil kılavuzu casez'i önerir ve casex'i yasaklar.

SystemVerilog'da ayrıca case inside da vardır, bu en temiz versiyondur - aralıkları ve listeleri kabul eder - ama düz Verilog casez'de durur.

case vs if/else if Zinciri

İki yapı da çok yönlü kararları ifade edebilir, ama farklı donanıma sentezlenirler:

• case düz bir dispatch'tir. Sentezleyici one-hot decoder, dengeli mux ağacı veya diğer düz yapıları üretebilir. Değerlendirme için sabit zaman.
• if/else if bir priority zinciridir. Sentezleyici her seviyenin gecikme eklediği bir cascade üretir. Logaritmik olarak yavaşlar.

İşlevsel olarak örtüşürler. Stilistik olarak: koşullar tek bir ifadenin değeri hakkında olduğunda case kullan. Gerçek bir priority varsa veya koşullar farklı sinyalleri içeriyorsa if/else if kullan.

// case olarak daha iyi:
if      (sel == 2'd0) out = a;
else if (sel == 2'd1) out = b;
else if (sel == 2'd2) out = c;
else                  out = d;

// if/else if olarak daha iyi:
if      (urgent_event)  next_state = HANDLE_URGENT;
else if (timer_expired) next_state = TIMEOUT;
else if (data_ready)    next_state = PROCESS;
else                    next_state = state;

İlk üç koşul da "sel ne?" - bir case daha doğal okunur ve daha düz sentezlenir. İkinci üçü bariz bir öncelikle bağımsız olaylardır - if/else if daha uygun.

Sırada Ne Var

Bu bölümün son doc'u - For Loops - Verilog'un for'unu ve onu sentezlenebilir kodda kullandığında ortaya çıkan sürpriz şeyi kapsar. Sonra sıralı mantık ve FSM'lere ciddi şekilde geçiyoruz.