Verilog If-Else: Prosedürel Bloklarda Koşullu Mantık

Tanıdık Sözdizimi, Farklı Mental Model

if/else, tam olarak C gibi görünür:

if (condition) begin
    // ... ifadeler ...
end else begin
    // ... ifadeler ...
end

Ama kurallar farklı çünkü Verilog yazılım değil. Akılda tutman gereken iki şey:

1. if/else yalnızca bir prosedürel blok içinde yaşar. Modül seviyesinde serbest bir if yazamazsın.
2. if/else'in neye sentezlendiği blok tipine bağlıdır. Bir kombinasyonel blokta, multiplexer veya priority encoder olur. Bir saatli blokta, koşullu güncelleme mantığıyla bir flip-flop olur.

Bir Kombinasyonel Blok İçinde

module max_of_three(
    input  wire [7:0] a,
    input  wire [7:0] b,
    input  wire [7:0] c,
    output reg  [7:0] max
);
    always @(*) begin
        if (a >= b && a >= c)
            max = a;
        else if (b >= c)
            max = b;
        else
            max = c;
    end
endmodule

module test;
    reg [7:0] a, b, c;
    wire [7:0] max;
    max_of_three dut(.a(a), .b(b), .c(c), .max(max));

    initial begin
        a = 8'd10; b = 8'd20; c = 8'd15; #1 $display("max(%0d,%0d,%0d)=%0d", a, b, c, max);
        a = 8'd50; b = 8'd30; c = 8'd40; #1 $display("max(%0d,%0d,%0d)=%0d", a, b, c, max);
        a = 8'd5;  b = 8'd5;  c = 8'd50; #1 $display("max(%0d,%0d,%0d)=%0d", a, b, c, max);
        $finish;
    end
endmodule

Kombinasyonel always @(*) bloğu, a, b veya c değiştiğinde tekrar çalışır. if/else zinciri bir dal seçer, max'a atar ve blok biter. max her zaman atandığı için (her yolun bir ataması var), sentezleyici saf kombinasyonel mantık üretir - latch yok.

Donanımda flip-flop olmamasına rağmen max'in reg olarak tanımlandığına dikkat et. Her zamanki gibi aynı kural: always içinde atanan her şey reg olmalıdır.

Latch Tuzağı

Bu, başlangıç kombinasyonel kodundaki en yaygın hatadır:

// YANLIŞ - bir latch çıkarır
always @(*) begin
    if (enable)
        out = data;
    // else yok! `enable` düşükken `out` ne yapar?
end

Sentezleyici "enable düşükken, out atanmamış" okur ve out'un önceki değerini hatırlaması gerektiğine karar verir. Bir değeri hatırlamak bir depolama hücresi gerektirir, bu yüzden araç bir latch ekler. Senkron tasarımlardaki latch'ler zamanlama sorunlarına neden olur, reset edilmeleri zordur ve neredeyse hiç ne demek istediğin değildir.

İki düzeltme yolu:

// Düzeltme 1: açık else dalı
module no_latch_1(
    input  wire       enable,
    input  wire [7:0] data,
    output reg  [7:0] out
);
    always @(*) begin
        if (enable) out = data;
        else        out = 8'd0;
    end
endmodule

// Düzeltme 2: başta varsayılan atama
module no_latch_2(
    input  wire       enable,
    input  wire [7:0] data,
    output reg  [7:0] out
);
    always @(*) begin
        out = 8'd0;             // önce varsayılan
        if (enable) out = data; // koşul tutarsa override
    end
endmodule

module test;
    reg en;
    reg [7:0] d;
    wire [7:0] out1, out2;

    no_latch_1 u1(.enable(en), .data(d), .out(out1));
    no_latch_2 u2(.enable(en), .data(d), .out(out2));

    initial begin
        en = 0; d = 8'h55; #1 $display("en=%b d=%h out1=%h out2=%h", en, d, out1, out2);
        en = 1; d = 8'hAA; #1 $display("en=%b d=%h out1=%h out2=%h", en, d, out1, out2);
        $finish;
    end
endmodule

İkisi de aynı kombinasyonel donanımı üretir - bir 2-to-1 mux. "Başta varsayılan" kalıbı, aynı sinyale çok sayıda koşullu ataman olduğunda daha iyi ölçeklenir.

Bir Saatli Blok İçinde

module counter_with_reset(
    input  wire       clk,
    input  wire       reset,
    input  wire       enable,
    output reg  [7:0] count
);
    always @(posedge clk) begin
        if (reset)        count <= 8'd0;
        else if (enable)  count <= count + 8'd1;
        // else: örtük tut (count değerini korur - bir flip-flop'un yaptığı budur)
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg enable = 0;
    wire [7:0] count;

    counter_with_reset dut(.clk(clk), .reset(reset), .enable(enable), .count(count));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #5  enable = 1;
        #50 enable = 0;
        #20 enable = 1;
        #30 $finish;
    end

    always @(posedge clk)
        $display("t=%0t reset=%b enable=%b count=%0d", $time, reset, enable, count);
endmodule

Kombinasyonel durumdan farkına dikkat et:

• Blok always @(posedge clk) - flip-flop bölgesi.
• Atama <= (non-blocking) kullanır.
• "Ne reset ne enable" durumu için bir else yok. Bu sorun değil. Saatli bir blokta, hiçbir dal tetiklenmediğinde, flip-flop sadece önceki değerini korur - ki bu fiziksel olarak bir flip-flop'un yaptığı şeydir. Sinyal zaten bir register olduğu için latch çıkarılmaz.

Bu, bir else'i atlamanın güvenli olduğu tek yerdir. Saatli bloklar dışında her zaman her yolu işle.

Zincirlenmiş else if: Bir Priority Encoder

else if ifadelerinin bir zinciri örtük önceliğe sahiptir - daha erken koşullar daha sonrakilerden öncelikli olur:

module priority_encoder(
    input  wire [3:0] requests,
    output reg  [1:0] grant,
    output reg        any
);
    always @(*) begin
        any = |requests;
        if      (requests[0]) grant = 2'd0;
        else if (requests[1]) grant = 2'd1;
        else if (requests[2]) grant = 2'd2;
        else if (requests[3]) grant = 2'd3;
        else                  grant = 2'd0;
    end
endmodule

module test;
    reg [3:0] req;
    wire [1:0] grant;
    wire any;
    priority_encoder dut(.requests(req), .grant(grant), .any(any));

    initial begin
        req = 4'b0000; #1 $display("req=%b any=%b grant=%0d", req, any, grant);
        req = 4'b0010; #1 $display("req=%b any=%b grant=%0d", req, any, grant);
        req = 4'b1010; #1 $display("req=%b any=%b grant=%0d", req, any, grant);
        req = 4'b1111; #1 $display("req=%b any=%b grant=%0d", req, any, grant);
        $finish;
    end
endmodule

requests[0] en yüksek önceliktir - ayarlıysa, yüksek numaralı bitlerin ne yaptığına bakılmaksızın grant 0'dır. Sentezleyici zinciri zincirlenmiş bir mux'a dönüştürür: önce bit 0'ı, sonra bit 1'i, sonra bit 2'yi, sonra bit 3'ü kontrol et. Her seviye küçük bir gecikme ekler.

Koşullar birbirini dışlıyorsa - örneğin bir one-hot girişi decode etmek - bir case ifadesi (sonraki doc) else if zincirinden çok daha düz, daha hızlı donanım üretir. Gerçek bir öncelik gereksinimi olmadığında case formunu kullan.

Saatli Kodda else Olmadan if

Bir saatli bloğun else'e ihtiyacı yoktur çünkü "önceki değeri tut" varsayılandır. Enable'ları böyle kurarsın:

always @(posedge clk) begin
    if (load) target <= incoming;
    // else yok: load düşük olduğunda, target değerini korur
end

Bu bir load-enabled register'dır. Çoğu pipeline register'ı, counter ve konfigürasyon register'ı bu kalıbı kullanır.

begin/end ve Tek İfadeler

C gibi, tek bir ifade için begin/end'i atlayabilirsin:

if (a) out = 1;
else   out = 0;

Bir ifadeden fazlası için bloğu kullan:

if (a) begin
    out = 1;
    flag = 1;
end else begin
    out = 0;
    flag = 0;
end

İki kalıp serbestçe karışır. Stil kılavuzları genellikle ikinci bir ifade eklemeyi acısız hale getirmek için her zaman begin/end kullanmayı önerir.

Sırada Ne Var

Bir sonraki doc - Case Statement - çok yönlü decoding (state machine'ler, opcode dispatch, ROM tabloları) için doğru araç olan case'i kapsar. Ondan sonra, for döngüleri, elaboration zamanında açıldıkları için yazılım kuzenlerinden ince bir şekilde farklıdır.