Blok Always Verilog: Logika Kombinasional dan Sekuensial

Andalan Utama Verilog Behavioral

assign menggambarkan logika kombinasional dengan satu persamaan. Begitu kamu butuh if/else, case, atau memori, kamu beralih ke always. Blok always adalah potongan kode prosedural yang berjalan ulang setiap kali sinyal tertentu berubah. Sinyal-sinyal yang memicu jalannya ulang itu adalah sensitivity list.

Ada dua bentuk always yang paling sering kamu lihat:

1. always @(*): berjalan ulang setiap kali sinyal apa pun yang dibaca di dalam blok berubah. Membangun logika kombinasional.
2. always @(posedge clk): hanya berjalan ulang di tepi naik clk. Membangun logika sekuensial yang dikendalikan clock (flip-flop).

Bentuk lain juga ada (@(a or b), @(negedge clk), @(posedge clk or negedge reset_n)), tapi dua bentuk di atas mencakup hampir setiap blok yang bisa disintesis yang akan kamu tulis.

always @(*) yang Kombinasional

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

Tiga hal yang perlu diperhatikan:

• out bertipe reg. Apa pun yang diberi nilai di dalam always harus bertipe reg. Kata kunci itu tidak berarti "ini flip-flop"; di sini artinya hanya "aku ditulis dari blok prosedural".
• always @(*). Tanda * berarti "bangun setiap kali ada yang kubaca berubah". Simulator otomatis menentukan sensitivity list-nya. Kamu bisa menulis daftarnya secara manual, misalnya always @(sel), tapi @(*) lebih aman karena sinyal yang terlewat adalah sumber bug klasik.
• Tanpa clock. Blok ini menggambarkan logika kombinasional. Synthesizer menghasilkan sepotong logika yang langsung menghitung out dari sel: tanpa flip-flop, tanpa butuh pin clock.

Case default secara sintaks memang opsional, tapi secara semangat tidak. Kalau dihilangkan, nilai input apa pun yang tidak ditentukan membuat out menahan nilai sebelumnya, yang disintesis menjadi latch yang tidak diinginkan. Selalu sertakan default.

always @(posedge clk) yang Sekuensial

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

Perbedaan utamanya dari versi kombinasional:

• always @(posedge clk). Blok ini hanya berjalan ulang di tepi naik clk. Tidak ada yang terjadi di antara tepi-tepi itu.
• Penugasan non-blocking <=. Di dalam blok yang dikendalikan clock, inilah operator yang tepat. Artinya "jadwalkan count untuk menerima nilai barunya di akhir langkah waktu", persis seperti perilaku flip-flop. Alasannya dan alternatifnya ada di Blocking vs Non-blocking.
• Tidak perlu default. if-nya sudah mencakup kedua cabang (reset dan bukan reset). Tidak ada risiko latch.

Synthesizer melihat bentuk ini (sensitivity dengan clock, penugasan non-blocking) dan menghasilkan register 4-bit (empat flip-flop), ditambah logika kombinasional yang menghitung count + 1 dan mux yang memilih antara reset dan penambahan.

Perbedaan di Sintesis

Sumber module yang sama bisa menggambarkan dua hardware yang sama sekali berbeda, tergantung bentuk blok always-nya:

Kasus ketiga adalah jebakan latch. Latch adalah sel memori transparan yang menahan output-nya saat input-nya tidak aktif: berguna di desain tertentu, tapi hampir selalu bug kalau muncul tanpa sengaja. Kebanyakan tool sintesis memberi peringatan keras saat menyimpulkan latch yang tidak kamu minta. Perlakukan peringatan itu sebagai error.

Variasi Sensitivity List

Kamu akan melihat beberapa sensitivity list yang kurang umum:

• always @(a or b or c): daftar eksplisit. Verilog-2001 menambahkan pemisah ,: always @(a, b, c). Keduanya bisa dipakai.
• always @(posedge clk or negedge reset_n): reset asinkron. Blok berjalan di tepi naik clock atau di tepi turun reset. Dipakai saat reset harus langsung berlaku, tanpa menunggu clock berikutnya.
• always @(negedge clk): clock di tepi turun. Jarang; beberapa desain memakainya untuk flip-flop "negative-edge-triggered" yang menangkap di tepi turun, bukan tepi naik.

Untuk desain baru, utamakan always @(*) untuk kombinasional dan always @(posedge clk) untuk sekuensial. Pakai reset asinkron hanya kalau desainnya memang benar-benar membutuhkannya.

Dua Blok Adalah Dua Potong Hardware

Beberapa blok always di module yang sama saling independen: masing-masing menjadi potongan hardware tersendiri:

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

    always @(*) begin
        comb_out = in ^ 8'hFF;     // bitwise invert
    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

Blok yang dikendalikan clock menghasilkan register flip-flop. Blok kombinasional menghasilkan gerbang XOR. Keduanya berdampingan; tidak ada yang tahu tentang yang lain. Kedua output berubah dengan jadwal yang sama sekali berbeda.

Yang Tidak Bisa Dilakukan Blok always

Beberapa hal yang terlihat menggoda tapi tidak diperbolehkan:

• Memberi nilai ke wire: targetnya harus reg. Compiler menegakkan aturan ini.
• Memberi nilai ke reg yang sama dari dua blok always yang berbeda: menghasilkan perilaku tak terdefinisi di simulasi dan tidak bisa disintesis. Satu penggerak untuk setiap sinyal.
• Membaca dan menulis sinyal yang sama di blok kombinasional yang sama dengan cara yang menciptakan loop umpan balik: always @(*) x = x + 1; adalah loop tanpa delay yang tidak bisa diselesaikan simulator.

Dua yang pertama ditangkap compiler. Yang ketiga kadang baru terlihat saat simulasi, dalam bentuk simulasi yang macet.

Selanjutnya

Dokumen berikutnya, Blok Initial, membahas saudara dari always: blok yang berjalan tepat satu kali di awal simulasi. Ini andalan utama testbench. Setelah itu, aturan penugasan blocking vs non-blocking yang menentukan apakah blok yang dikendalikan clock-mu bekerja seperti yang kamu maksud.