Dokumentasi Verilog interaktif: Logika Clocked

Q: Apa itu logika clocked di Verilog?

Logika yang pembaruannya diatur oleh sinyal clock. Idiom standarnya adalah always @(posedge clk) target <= nextvalue;: di setiap tepi naik clk, target menangkap nextvalue. Satu baris itu menggambarkan sebuah flip-flop di hardware. Menumpuk banyak flip-flop dengan logika kombinasional di antaranya akan membangun counter, shift register, pipeline, pokoknya semua yang sinkron.

Q: Apa perbedaan reset sinkron dan asinkron di Verilog?

Reset sinkron memakai always @(posedge clk) if (reset) ...: reset diambil sampelnya di tepi clock seperti input lainnya. Reset asinkron memakai always @(posedge clk or negedge resetn) if (~resetn) ...: blok terpicu oleh tepi clock atau saat reset diaktifkan, sehingga reset langsung berlaku. Reset sinkron adalah pilihan default; reset asinkron dipakai saat reset harus dijamin berlaku meskipun clock-nya mati.

Q: Bagaimana cara membangun pipeline di Verilog?

Tumpuk beberapa tahap always @(posedge clk) stageNreg <= stageNcombinational;: logika kombinasional setiap tahap mengisi register tahap berikutnya, dan setiap register menangkap di tepi clock yang sama. Hasilnya adalah pipeline di mana data baru masuk setiap siklus dan keluar N siklus kemudian, dengan throughput satu hasil per clock.

Q: Apa itu shift register di Verilog?

Rantai flip-flop di mana output setiap flip-flop mengisi input flip-flop berikutnya. Setiap tepi clock menggeser semua bit satu posisi. Versi Verilog yang baku memakai penugasan non-blocking: out <= {out[N-2:0], in};. Satu baris itu membuat shift register N-bit yang mengambil satu bit per siklus dari in.

Logika Clocked di Verilog: Flip-Flop, Register, dan Pipeline

Cara membangun register, counter, shift register, dan pipeline dari blok always yang dikendalikan clock, pola andalan setiap desain digital sinkron.

Halaman ini dilengkapi editor yang bisa dijalankan. Edit, jalankan, dan lihat output-nya seketika.

Oleh Kevin Spektor, Co-founder & CTO

Diterbitkan May 26, 2026

Blok Dasar: D Flip-Flop

Semua hal di desain sinkron kembali ke satu potong hardware kecil: D flip-flop. Ia punya input clock, input data, dan output data. Di setiap tepi naik clock, ia menangkap nilai D dan menahannya sampai tepi berikutnya. Itu saja.

Di Verilog:

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

Tiga baris, satu flip-flop. <= adalah non-blocking, persis seperti perilaku flip-flop sungguhan (dibahas di Blocking vs Non-blocking). Sensitivity posedge clk-lah yang membuatnya sekuensial.

Tumpuk banyak flip-flop ini dengan logika kombinasional di antaranya, dan kamu bisa membangun rangkaian sinkron apa pun yang kamu inginkan.

Register dengan Reset

Desain sungguhan selalu butuh reset, yaitu cara untuk menaruh sistem ke state yang jelas saat dinyalakan atau saat diminta:

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

Itu adalah reset sinkron: kondisi reset dievaluasi di tepi clock seperti input lainnya. Synthesizer menghasilkan flip-flop dengan mux 2-ke-1 di input datanya: saat reset bernilai high, mux mengisi nol; selain itu ia mengisi d.

Untuk kebanyakan desain, reset sinkron adalah pilihan yang tepat. Timing-nya lebih sederhana, cocok untuk FPGA, dan sinyal reset bisa datang dari mana saja, tanpa butuh sumber sendiri yang selaras dengan clock.

Register dengan Enable

Sering kali kamu ingin register yang hanya diperbarui saat ada yang menyuruhnya. Pakai if di dalam blok yang dikendalikan clock, dan andalkan perilaku implisit "tahan nilai sebelumnya" dari else yang tidak ditulis:

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;
        // No else - q holds its previous value, which is what a FF does
    end
endmodule

Inilah "register dengan load enable" yang baku. Ia muncul di mana-mana: register konfigurasi, tahap pipeline yang hanya maju saat tahap berikutnya siap, counter yang bisa dijeda dan dilanjutkan. Tidak menulis else terakhir itu disengaja dan aman di dalam blok yang dikendalikan clock: flip-flop sudah mengingat nilai sebelumnya, jadi "tidak melakukan apa-apa" berarti "tahan".

Di blok kombinasional, kode yang sama akan menghasilkan latch. Aturannya berbeda, sintaksnya sama.

Counter

Counter adalah register yang nilai berikutnya adalah nilai saat ini ditambah satu:

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 bertambah di setiap siklus clock saat enable bernilai high. Setelah 16 siklus, nilainya kembali ke 0 (karena kita mendeklarasikan 4 bit dan 15 + 1 overflow menjadi 0). Perputaran itu bawaan aritmetika N-bit dan persis seperti perilaku counter di hardware sungguhan.

Shift Register

Menumpuk flip-flop menghasilkan shift register. Triknya, lakukan semua pergeseran dalam satu pernyataan non-blocking:

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

Isinya adalah out <= {out[WIDTH-2:0], in}: sambungkan bit-bit bawah dari out saat ini dengan in yang baru, lalu berikan semuanya sekaligus. Karena non-blocking, RHS membaca out yang lama sebelum LHS diperbarui. Hasilnya adalah pergeseran N-bit yang bersih dalam satu siklus clock.

Inilah pola shift register dalam bentuk terkecilnya. Pola ini bisa dikembangkan menjadi LFSR, transmitter serial, deserializer, desain apa pun di mana data bergerak melewati rantai flip-flop di setiap clock.

Pipeline

Pipeline adalah rantai register yang dipisahkan oleh logika kombinasional. Setiap tahap memproses data dari tahap sebelumnya dan mengisi tahap berikutnya:

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
            // Stage 1: two parallel adds.
            stage1_ab <= a + b;
            stage1_cd <= c + d;
            // Stage 2: combine the two partial sums.
            stage2    <= stage1_ab + stage1_cd;
            // Stage 3: forward to output.
            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

Tiga tahap, latensi tiga siklus, tapi ada hasil baru di setiap siklus begitu pipeline-nya penuh. Latensinya 3 clock karena data melewati tiga flip-flop; throughput-nya 1 operasi per clock karena ketiga tahap bekerja bersamaan pada input yang berbeda.

Begitulah desain berperforma tinggi mencapai target throughput-nya: buat tahap-tahapnya pendek, perdalam pipeline-nya, dan biarkan paralelisme yang bekerja.

Reset Asinkron (Saat Kamu Membutuhkannya)

Kadang kamu tidak bisa menunggu tepi clock untuk mengaktifkan reset: chip sedang dimatikan, clock-nya di-gate, watchdog eksternal sedang menarik jalurnya. Dalam kasus seperti itu:

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

Sekarang sensitivity list-nya punya tepi clock dan tepi reset. Flip-flop langsung merespons salah satunya. Menurut konvensi, reset_n aktif low (aktif saat bernilai low), itulah kenapa pengujiannya ~reset_n.

Reset asinkron punya konsekuensi: lebih sulit dianalisis timing-nya, bisa menyebabkan metastabilitas kalau pelepasannya tidak ditangani dengan hati-hati, dan tidak portabel di semua arsitektur FPGA. Pakai reset sinkron secara default, dan reset asinkron hanya kalau desainnya memang membutuhkannya.

Selanjutnya

Sekarang kamu bisa membangun jalur data sinkron apa pun. Dokumen berikutnya, Finite State Machine, menggabungkan register yang dikendalikan clock dengan pernyataan case untuk menghasilkan idiom FSM yang standar: andalan utama setiap kontroler, mesin protokol, dan blok pengambil keputusan di desain digital.

Pertanyaan yang sering diajukan

Apa itu logika clocked di Verilog?

Logika yang pembaruannya diatur oleh sinyal clock. Idiom standarnya adalah always @(posedge clk) target <= next_value;: di setiap tepi naik clk, target menangkap next_value. Satu baris itu menggambarkan sebuah flip-flop di hardware. Menumpuk banyak flip-flop dengan logika kombinasional di antaranya akan membangun counter, shift register, pipeline, pokoknya semua yang sinkron.

Apa perbedaan reset sinkron dan asinkron di Verilog?

Reset sinkron memakai always @(posedge clk) if (reset) ...: reset diambil sampelnya di tepi clock seperti input lainnya. Reset asinkron memakai always @(posedge clk or negedge reset_n) if (~reset_n) ...: blok terpicu oleh tepi clock atau saat reset diaktifkan, sehingga reset langsung berlaku. Reset sinkron adalah pilihan default; reset asinkron dipakai saat reset harus dijamin berlaku meskipun clock-nya mati.

Bagaimana cara membangun pipeline di Verilog?

Tumpuk beberapa tahap always @(posedge clk) stageN_reg <= stageN_combinational;: logika kombinasional setiap tahap mengisi register tahap berikutnya, dan setiap register menangkap di tepi clock yang sama. Hasilnya adalah pipeline di mana data baru masuk setiap siklus dan keluar N siklus kemudian, dengan throughput satu hasil per clock.

Apa itu shift register di Verilog?

Rantai flip-flop di mana output setiap flip-flop mengisi input flip-flop berikutnya. Setiap tepi clock menggeser semua bit satu posisi. Versi Verilog yang baku memakai penugasan non-blocking: out <= {out[N-2:0], in};. Satu baris itu membuat shift register N-bit yang mengambil satu bit per siklus dari in.

Konsep terkait