Verilog Always Block: Kombinasyonel ve Sıralı Mantık

Davranışsal Verilog'un İş Atı

assign, tek denklemli kombinasyonel mantığı tanımlar. if/else, case veya bellek gerektiren bir şey olduğu anda always'e uzanırsın. Bir always bloğu, belirli sinyaller değiştiğinde tekrar çalışan bir prosedürel kod parçasıdır. Yeniden çalışmayı tetikleyen sinyaller sensitivity list'tir.

En sık göreceğin iki always şekli vardır:

1. always @(*) - blokta okunan herhangi bir sinyal değiştiğinde tekrar çalışır. Kombinasyonel mantık kurar.
2. always @(posedge clk) - yalnızca clk'nin yükselen kenarında tekrar çalışır. Saatli sıralı mantık (flip-flop) kurar.

Diğer formlar da vardır (@(a or b), @(negedge clk), @(posedge clk or negedge reset_n)), ama yukarıdaki ikisi yazacağın neredeyse her sentezlenebilir bloğu kapsar.

Kombinasyonel always @(*)

module decoder3(
    input  wire [2:0] sel,
    output reg  [7:0] out
);
    always @(*) begin
        case (sel)
            3'd0: out = 8'b0000_0001;
            3'd1: out = 8'b0000_0010;
            3'd2: out = 8'b0000_0100;
            3'd3: out = 8'b0000_1000;
            3'd4: out = 8'b0001_0000;
            3'd5: out = 8'b0010_0000;
            3'd6: out = 8'b0100_0000;
            3'd7: out = 8'b1000_0000;
            default: out = 8'b0;
        endcase
    end
endmodule

module test;
    reg [2:0] sel;
    wire [7:0] out;
    decoder3 dut(.sel(sel), .out(out));

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

Fark etmen gereken üç şey:

• out, reg'dir. always içinde atanan her şey reg olmalıdır. Bu anahtar sözcük "bu bir flip-flop'tur" anlamına gelmez; burada yalnızca "prosedürel bir bloktan yazılıyorum" demektir.
• always @(*). * ifadesi "okuduğum bir şey her değiştiğinde uyan" der. Simülatör sensitivity list'i otomatik çıkarır. Listeyi elle de yazabilirsin - always @(sel) - ama @(*) daha güvenlidir çünkü bir sinyali unutmak klasik bir hata kaynağıdır.
• Saat yok. Bu blok kombinasyonel mantığı tanımlar. Sentezleyici, out'u doğrudan sel'den hesaplayan bir mantık parçası üretir - flip-flop yok, saat ucuna gerek yok.

default durumu sözdizimi olarak isteğe bağlı olsa da ruhen değildir. Onu atlarsan, belirtilmemiş bir giriş değeri out'un önceki değerini korumasına neden olur - bu da istenmeyen bir latch olarak sentezlenir. Her zaman default ekle.

Sıralı always @(posedge clk)

module counter4(
    input  wire       clk,
    input  wire       reset,
    output reg  [3:0] count
);
    always @(posedge clk) begin
        if (reset) count <= 4'd0;
        else       count <= count + 4'd1;
    end
endmodule

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

    counter4 dut(.clk(clk), .reset(reset), .count(count));

    always #5 clk = ~clk;

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

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

Kombinasyonel sürümden temel farkları:

• always @(posedge clk). Blok yalnızca clk'nin yükselen kenarında tekrar çalışır. Kenarlar arasında hiçbir şey olmaz.
• Non-blocking atama <=. Saatli bir bloğun içinde doğru operatör budur. "Zaman adımı sonunda count'a yeni değerini al" demektir, ki bu tam olarak bir flip-flop'un davranışıdır. Nedeni ve alternatifi Blocking vs Non-blocking bölümündedir.
• default gerekmez. if her iki dalı da (reset ve reset değil) kapsar. Latch riski yok.

Sentezleyici bu şekli görür - saatli sensitivity, non-blocking atama - ve 4 bitlik bir register (dört flip-flop) artı count + 1'i hesaplayan kombinasyonel mantık ve reset ile artış arasından seçen mux'ı üretir.

Sentez Ayrımı

Aynı modül kaynağı, always bloğunun şekline göre tamamen farklı iki donanım parçasını tanımlayabilir:

Blok	Donanım
always @(*) y = expr;	Saf kombinasyonel mantık. Bellek yok.
always @(posedge clk) y <= expr;	Flip-flop. expr'i saat döngüsü başına bir kez yakalar.
always @(*) if (en) y = expr;	Latch - genellikle bir hata. "else" durumu eski değeri tutar.
always @(posedge clk) if (en) y <= expr;	Enable'lı flip-flop. Yalnızca en yüksekken yakalar.

Üçüncü durum latch tuzağıdır. Latch, girişi onaylanmadığında çıkışını koruyan saydam bir bellek hücresidir - belirli tasarımlarda kullanışlı, kaza eseri ortaya çıktığında neredeyse her zaman bir hata. Çoğu sentez aracı, istemediğin bir latch çıkardığında yüksek sesle uyarır. Uyarıyı hata olarak değerlendir.

Sensitivity List Varyantları

Daha az yaygın bazı sensitivity list'leri göreceksin:

• always @(a or b or c) - açık liste. Verilog-2001, , ayırıcısını ekledi: always @(a, b, c). İkisi de çalışır.
• always @(posedge clk or negedge reset_n) - asenkron reset. Blok, yükselen saat kenarında veya düşen reset kenarında çalışır. Reset'in sonraki saati beklemeden hemen etkili olması gereken durumlarda kullanılır.
• always @(negedge clk) - düşen-kenar saatleme. Nadirdir; bazı tasarımlar yükselen yerine düşen kenarda yakalayan "negatif-kenar-tetiklemeli" flip-flop'lar için kullanır.

Yeni tasarımlarda kombinasyonel için always @(*), sıralı için always @(posedge clk) tercih et. Asenkron reset'e yalnızca tasarım gerçekten gerektirdiğinde uzan.

İki Blok, İki Donanım Parçası

Aynı modüldeki birden çok always bloğu birbirinden bağımsızdır - her biri kendi donanım parçası olur:

module two_blocks(
    input  wire       clk,
    input  wire       reset,
    input  wire [7:0] in,
    output reg  [7:0] reg_out,    // sıralı
    output reg  [7:0] comb_out    // kombinasyonel
);
    always @(posedge clk) begin
        if (reset) reg_out <= 8'd0;
        else       reg_out <= in;
    end

    always @(*) begin
        comb_out = in ^ 8'hFF;     // bitwise tersleme
    end
endmodule

module test;
    reg clk = 0, reset = 1;
    reg [7:0] in;
    wire [7:0] reg_out, comb_out;

    two_blocks dut(.clk(clk), .reset(reset), .in(in),
                   .reg_out(reg_out), .comb_out(comb_out));

    always #5 clk = ~clk;

    initial begin
        in = 8'h00; #12 reset = 0;
        in = 8'hA5; #10;
        in = 8'h3C; #10;
        $finish;
    end

    always @(posedge clk)
        $display("t=%0t in=%h reg_out=%h comb_out=%h",
                 $time, in, reg_out, comb_out);
endmodule

Saatli blok bir flip-flop register üretir. Kombinasyonel blok bir XOR gate üretir. Yan yana yaşarlar; ikisi de diğerinden haberdar değildir. İki çıkış tamamen farklı takvimlerde değişir.

always Bloklarının Yapamayacakları

Çekici görünen ama izin verilmeyen birkaç şey:

• Bir wire'a atama: hedef reg olmalı. Derleyici zorlar.
• Aynı reg'e iki farklı always bloğundan atama: simülasyonda tanımsız davranış üretir ve sentezlenmez. Sinyal başına tek sürücü.
• Aynı kombinasyonel blokta aynı sinyali okuyup yazmak, geri besleme döngüsü oluşturacak şekilde: always @(*) x = x + 1; simülatörün çözemediği sıfır gecikmeli bir döngüdür.

İlk ikisini derleyici yakalar. Üçüncüsü bazen yalnızca simülasyon sırasında bir takılma olarak ortaya çıkar.

Sırada Ne Var

Bir sonraki doc - Initial Block - always'in kardeşini kapsar: simülasyon başlangıcında tam olarak bir kez çalışan bir blok. Testbench'lerin iş atıdır. Ondan sonra, saatli bloğunun istediğin gibi çalışıp çalışmadığını belirleyen blocking ve non-blocking atama kuralları gelecek.