Verilog Saatli Mantık: Flip-Flop'lar, Register'lar ve Pipeline'lar

Yapı Taşı: D Flip-Flop

Senkron tasarımdaki her şey küçük bir donanım parçasına döner: D flip-flop. Bir saat girişi, bir veri girişi ve bir veri çıkışı vardır. Her yükselen saat kenarında D'nin değerini yakalar ve bir sonraki kenara kadar tutar. Hepsi bu.

Verilog'da:

always @(posedge clk) begin
    q <= d;
end

Üç satır, bir flip-flop. <= non-blocking'dir, bu da gerçek flip-flop'ların tam davranışıdır (Blocking vs Non-blocking bölümünde kapsanır). posedge clk duyarlılığı onu sıralı yapan şeydir.

Bunlardan çoğunu aralarına kombinasyonel mantık koyarak üst üste yığarsan, kurmak isteyeceğin herhangi bir senkron devreye sahip olursun.

Reset'li Bir Register

Gerçek tasarımlar her zaman bir reset gerektirir - güç açıldığında veya isteğe bağlı olarak sistemi bilinen bir duruma getirmenin bir yolu:

module reg_with_reset #(
    parameter WIDTH = 8
)(
    input  wire             clk,
    input  wire             reset,
    input  wire [WIDTH-1:0] d,
    output reg  [WIDTH-1:0] q
);
    always @(posedge clk) begin
        if (reset) q <= 0;
        else       q <= d;
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg [7:0] d;
    wire [7:0] q;

    reg_with_reset dut(.clk(clk), .reset(reset), .d(d), .q(q));

    always #5 clk = ~clk;

    initial begin
        d = 8'hA5;
        #20 reset = 0;
        #10 d = 8'h3C;
        #10 d = 8'hFF;
        #20 $finish;
    end

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

Bu bir senkron reset'tir - reset koşulu, herhangi bir giriş gibi bir saat kenarında değerlendirilir. Sentezleyici, veri girişinde 2-to-1 mux olan bir flip-flop üretir: reset yüksek olduğunda mux sıfır besler; aksi halde d besler.

Çoğu tasarım için senkron reset doğru seçimdir. Daha basit timing'dir, FPGA'larla iyi geçinir ve reset sinyali her yerden gelebilir - kendi saat hizalı kaynağına ihtiyacı yoktur.

Enable'lı Bir Register

Çoğu zaman yalnızca bir şey söylediğinde güncellenen bir register istersin. Saatli bloğun içinde bir if kullan ve eksik else'in örtük "önceki değeri koru" davranışına güven:

module reg_with_enable(
    input  wire       clk,
    input  wire       reset,
    input  wire       enable,
    input  wire [7:0] d,
    output reg  [7:0] q
);
    always @(posedge clk) begin
        if (reset)       q <= 8'd0;
        else if (enable) q <= d;
        // else yok - q önceki değerini korur, ki bu FF'nin yaptığıdır
    end
endmodule

Bu kanonik "load-enabled register"'dır. Her yerde karşına çıkar - konfigürasyon register'ları, yalnızca downstream hazır olduğunda ilerleyen pipeline aşamaları, duraklatıp devam eden counter'lar. Son else'in atlanması, saatli bir bloğun içinde kasıtlı ve güvenlidir: bir flip-flop zaten önceki değerini hatırlar, yani "hiçbir şey yapma" "tut" demektir.

Kombinasyonel bir blokta aynı kod bir latch çıkarır. Farklı kurallar, aynı sözdizimi.

Bir Counter

Counter, sonraki değeri mevcut değer artı bir olan bir register'dır:

module counter #(
    parameter WIDTH = 4
)(
    input  wire             clk,
    input  wire             reset,
    input  wire             enable,
    output reg  [WIDTH-1:0] count
);
    always @(posedge clk) begin
        if (reset)        count <= 0;
        else if (enable)  count <= count + 1;
    end
endmodule

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

    counter #(.WIDTH(4)) dut(.clk(clk), .reset(reset), .enable(enable), .count(count));

    always #5 clk = ~clk;

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

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

Counter, enable yüksek olduğunda her saat döngüsünde artar. 16 döngü sonra 0'a sarar (çünkü 4 bit tanımladık ve 15 + 1 0'a taşar). Bu sarma N bitlik aritmetiğin doğasında vardır ve gerçek bir donanım counter'ının tam olarak davrandığı gibidir.

Bir Shift Register

Flip-flop'ları üst üste yığmak sana bir shift register verir. Püf nokta, tüm shift'leri tek bir non-blocking ifadede yapmaktır:

module shift_register #(
    parameter WIDTH = 4
)(
    input  wire             clk,
    input  wire             reset,
    input  wire             in,
    output reg  [WIDTH-1:0] out
);
    always @(posedge clk) begin
        if (reset) out <= 0;
        else       out <= {out[WIDTH-2:0], in};
    end
endmodule

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

    shift_register #(.WIDTH(4)) dut(.clk(clk), .reset(reset), .in(in), .out(out));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        in = 1; #10;
        in = 0; #10;
        in = 1; #10;
        in = 1; #10;
        in = 0; #40 $finish;
    end

    always @(posedge clk)
        $display("t=%0t in=%b out=%b", $time, in, out);
endmodule

Gövde out <= {out[WIDTH-2:0], in}'dir - mevcut out'un alt bitlerini yeni in ile birleştir ve tümünü ata. Non-blocking olduğu için, RHS, LHS güncellemeden önce eski out'u okur. Etki, tek bir saat döngüsünde temiz bir N bit shift'tir.

Bu shift register kalıbının en küçük formudur. LFSR'lara, seri vericilere, deserializer'lara - verinin her saatte flip-flop zincirinden geçtiği herhangi bir tasarıma genelleşir.

Pipeline'lar

Pipeline, kombinasyonel mantık ile ayrılmış bir register zinciridir. Her aşama önceki aşamadan gelen veriyi işler ve bir sonrakini besler:

module pipelined_add(
    input  wire        clk,
    input  wire        reset,
    input  wire [7:0]  a, b, c, d,
    output reg  [9:0]  result
);
    reg [8:0] stage1_ab, stage1_cd;
    reg [9:0] stage2;

    always @(posedge clk) begin
        if (reset) begin
            stage1_ab <= 0;
            stage1_cd <= 0;
            stage2    <= 0;
            result    <= 0;
        end else begin
            // Aşama 1: iki paralel toplama.
            stage1_ab <= a + b;
            stage1_cd <= c + d;
            // Aşama 2: iki parsiyel toplamı birleştir.
            stage2    <= stage1_ab + stage1_cd;
            // Aşama 3: çıkışa ilet.
            result    <= stage2;
        end
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg [7:0] a, b, c, d;
    wire [9:0] result;

    pipelined_add dut(.clk(clk), .reset(reset), .a(a), .b(b), .c(c), .d(d), .result(result));

    always #5 clk = ~clk;

    initial begin
        a = 0; b = 0; c = 0; d = 0;
        #12 reset = 0;
        a = 10; b = 20; c = 30; d = 40; #10;
        a = 1;  b = 2;  c = 3;  d = 4;  #10;
        a = 5;  b = 5;  c = 5;  d = 5;  #40;
        $finish;
    end

    always @(posedge clk)
        $display("t=%0t a=%0d b=%0d c=%0d d=%0d result=%0d", $time, a, b, c, d, result);
endmodule

Üç aşama, üç döngü gecikme, ama pipeline dolduğunda her döngüde yeni bir sonuç. Latency 3 saattir çünkü veri üç flip-flop'tan geçer; throughput saat başına 1 işlemdir çünkü üç aşama da farklı girişler üzerinde aynı anda çalışır.

Yüksek performanslı tasarımların throughput hedeflerine ulaşma yolu budur: aşamaları kısa tut, daha derin pipeline yap ve paralelliğin işi yapmasına izin ver.

Asenkron Reset (Gerektiğinde)

Bazen reset'i onaylamak için bir saat kenarı bekleyemezsin - chip kapanıyor, saat kapatılmış, harici bir watchdog hattı çekiyor. Bu durumlarda:

always @(posedge clk or negedge reset_n) begin
    if (~reset_n) q <= 0;
    else          q <= d;
end

Sensitivity list'in artık hem bir saat kenarı hem de bir reset kenarı vardır. Flip-flop her ikisine de anında yanıt verir. reset_n geleneksel olarak active-low'dur (düşük olduğunda onaylanır), bu yüzden test ~reset_n'dir.

Asenkron reset'in dezavantajları vardır: zaman analizi daha zordur, de-assertion'da dikkatli ele alınmazsa metastability'ye neden olabilir, tüm FPGA mimarileri arasında taşınabilir değildir. Varsayılan olarak senkron reset kullan, asenkron'u yalnızca tasarım gerektirdiğinde.

Sırada Ne Var

Artık herhangi bir senkron veri yolu kurabilirsin. Bir sonraki doc - Finite State Machines - saatli bir register'ı bir case ifadesiyle bir araya getirerek standart FSM deyimini üretir: her kontrolör, protokol motoru ve dijital tasarımdaki karar verme bloğunun iş atı.