Finite State Machine di Verilog: Pola FSM Standar

Apa Itu FSM

Finite state machine adalah kontroler yang:

• Memegang salah satu dari sekumpulan state bernama yang tetap pada waktu kapan pun.
• Berpindah antar-state berdasarkan input (dan mungkin state saat ini).
• Menghasilkan output yang bergantung pada state saat ini (dan mungkin input saat ini).

Itu mencakup bagian desain digital yang luasnya mengejutkan: kontroler lampu lalu lintas, transmitter UART, kontroler memori, penangan protokol jaringan, decoder instruksi, apa pun yang punya mode operasi yang terpisah-pisah.

Yang membuat FSM terasa berbeda dari logika jalur data adalah isinya berupa state, bukan nilai. Counter berjalan melewati 1, 2, 3, 4. FSM berjalan melewati IDLE, FETCHING, BUSY, DONE: bentuknya sama, tapi state-nya punya nama dan transisinya punya makna.

Pola Dua Proses

FSM Verilog yang standar memakai dua blok always:

1. Blok yang dikendalikan clock yang menangkap register state di setiap tepi clock. Memakai penugasan non-blocking. Ukurannya kecil, biasanya tiga baris.
2. Blok kombinasional yang memakai case pada state saat ini untuk menghitung state berikutnya dan output. Memakai penugasan blocking. Kode yang "menarik" ada di sini.

Pemisahan ini punya tiga manfaat: memaksamu memikirkan state secara eksplisit, menghasilkan hardware yang dengan rapi menjadi "satu register ditambah satu blok kombinasional", dan menjadi standar, sehingga siapa pun yang membaca kode Verilog-mu langsung mengenalinya.

Contoh Lengkap: Detektor Urutan

FSM klasik untuk belajar: mendeteksi urutan bit 1011 di sebuah input serial. Keluarkan pulsa selama satu siklus saat urutannya lengkap.

module seq_detect_1011(
    input  wire clk,
    input  wire reset,
    input  wire in,
    output reg  detected
);
    // State encoding - localparam because it's an implementation detail.
    localparam S0 = 3'd0;   // no progress
    localparam S1 = 3'd1;   // saw "1"
    localparam S2 = 3'd2;   // saw "10"
    localparam S3 = 3'd3;   // saw "101"

    reg [2:0] state, next_state;

    // ---------------------------------------------------------------------
    // Block 1: clocked state register
    // ---------------------------------------------------------------------
    always @(posedge clk) begin
        if (reset) state <= S0;
        else       state <= next_state;
    end

    // ---------------------------------------------------------------------
    // Block 2: combinational next-state + output logic
    // ---------------------------------------------------------------------
    always @(*) begin
        // Defaults - so we never accidentally infer a latch.
        next_state = state;
        detected   = 1'b0;

        case (state)
            S0: if (in)  next_state = S1;
            S1: if (~in) next_state = S2;
                else     next_state = S1;
            S2: if (in)  next_state = S3;
                else     next_state = S0;
            S3: if (in) begin
                    next_state = S1;
                    detected   = 1'b1;     // emit pulse, keep looking
                end else begin
                    next_state = S2;
                    detected   = 1'b1;     // same - pulse, then look from S2
                end
            default: next_state = S0;
        endcase
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg in = 0;
    wire detected;

    seq_detect_1011 dut(.clk(clk), .reset(reset), .in(in), .detected(detected));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        // Drive the input sequence: 1 0 1 1 (should detect at the second-to-last)
        in = 1; #10;
        in = 0; #10;
        in = 1; #10;
        in = 1; #10;    // <-- detected should pulse here
        in = 0; #10;
        // Try again with an overlapping sequence: 1 0 1 1 0 1 1
        in = 1; #10;
        in = 1; #10;    // another detection
        #20 $finish;
    end

    always @(posedge clk)
        $display("t=%0t in=%b state=%0d detected=%b", $time, in, dut.state, detected);
endmodule

Struktur dua bloknya sesuai dengan poin-poin di atas. Ada beberapa detail kerapian yang patut ditunjukkan:

• Nilai default di awal blok kombinasional. next_state = state (tetap di tempat) dan detected = 1'b0 (tanpa pulsa) adalah penugasan "tidak melakukan apa-apa". Setiap cabang case lalu hanya mengatur hal yang berbeda. Ini membuat latch mustahil tersimpulkan.
• localparam untuk nama state. Siapa pun yang membaca module ini berpikir dalam S0, S1, S2, S3, bukan dalam 3'd0, 3'd1. Synthesizer yang melakukan penggantiannya.
• Tidak ada output dari blok yang dikendalikan clock. Semua logika "apa yang dilakukan state ini" berada di blok kombinasional. Blok yang dikendalikan clock tidak bertanggung jawab atas apa pun selain memegang state saat ini.

Moore vs Mealy

Moore: output hanya bergantung pada state saat ini. Mealy: output bergantung pada state saat ini dan input saat ini.

Di contoh di atas, detected diatur di dalam cabang S3 hanya saat in cocok dengan salah satu pola yang melengkapi urutan. Itu output Mealy: ia bergantung pada in selain pada state. Versi Moore akan punya state tersendiri untuk "baru saja terdeteksi" dan mengatur detected = 1 setiap kali state itu aktif; output-nya akan muncul satu siklus lebih lambat, tapi tidak pernah terpengaruh glitch di in.

Kedua gaya sama-sama sah. Moore menjadi default di buku teks karena output-nya dijamin tidak mengalami glitch saat input berubah di tengah siklus. Mealy lebih cepat (tanpa latensi register untuk output yang digerakkan input) dan dalam banyak kasus menghasilkan hardware yang lebih kecil. Pilih berdasarkan protokol yang sedang kamu implementasikan.

Encoding State: Biner, One-Hot, Gray

Pola bit yang kamu berikan ke setiap state berpengaruh pada luas area dan kecepatan:

• Biner (S0 = 3'd0, S1 = 3'd1, ...): register state paling kecil, $\lceil \log_2 N \rceil$ bit untuk $N$ state. Logika dekodenya paling banyak.
• One-hot (S0 = 4'b0001, S1 = 4'b0010, ...): N bit untuk N state. Logika dekodenya sangat sederhana (setiap state adalah satu kabel); transisinya cepat. FPGA sering memakai ini secara default.
• Gray code: state yang berurutan hanya berbeda satu bit. Berguna saat bit-bit state melintasi clock domain.

Kebanyakan tool sintesis modern memilih encoding untukmu (Vivado, Quartus, dan Design Compiler semuanya punya mode otomatis yang mencoba setiap encoding lalu memilih yang terbaik). Kamu jarang perlu menentukannya. Kalau perlu, kebanyakan tool menerima anotasi attribute atau pragma (* fsm_encoding = "one_hot" *).

Varian Tiga Blok

Sesekali kamu akan melihat FSM yang dipecah menjadi tiga: satu blok yang dikendalikan clock untuk state, satu blok kombinasional untuk next-state, satu blok kombinasional untuk output. Itu hanyalah pola dua blok dengan perhitungan output yang dipindahkan ke bloknya sendiri:

// State register
always @(posedge clk) ...

// Next-state logic
always @(*) ...

// Output logic
always @(*) begin
    case (state)
        ...
    endcase
end

Gaya output terpisah ini berguna saat output-nya banyak dan logika next-state akan jadi berantakan kalau keduanya ada di blok yang sama. Untuk FSM kecil, ini berlebihan.

Fungsi default di FSM

Setiap pernyataan case di FSM sebaiknya punya cabang default. Dua alasannya:

1. Keamanan: kalau register state entah bagaimana menerima nilai yang tidak valid (korupsi, bug, reset sebagian), default mengembalikannya ke state yang jelas.
2. Petunjuk untuk sintesis: saat case eksplisitnya sudah lengkap (misalnya state 2-bit dengan keempat nilai ditangani), default: next_state = 'x; memberi tahu synthesizer "aku jamin default-nya tidak terjangkau, optimalkan sesukamu". Kalau jalur yang tidak terjangkau itu ternyata tercapai di simulasi, x yang dihasilkan akan menyebar dan langsung menampakkan bug-nya.

default: begin
    next_state = S0;   // safe recovery
    // or
    next_state = 'x;   // unreachable, optimize freely
end

Pilih berdasarkan apakah kamu sudah membuktikan default-nya benar-benar tidak terjangkau.

Hal yang Perlu Diwaspadai

Lupa nilai default di awal blok kombinasional. Tanpa next_state = state dan default untuk output, cabang yang tidak memberi nilai ke semua sinyal akan memunculkan latch.

Menaruh output di blok yang dikendalikan clock. Kalau detected <= 1 ada di blok always @(posedge clk), output-nya menjadi registered: ia muncul satu siklus terlambat. Itu bisa disengaja (output "Mealy registered"), tapi sering menjadi kesalahan desain yang tidak disengaja saat spesifikasinya meminta pulsa seketika.

Mencampur blocking dan non-blocking. Blok yang dikendalikan clock: <=. Blok kombinasional: =. Mencampur keduanya dalam satu blok adalah race condition.

Blok always kombinasional yang merujuk next_state dan memberi nilai ke state. Itu membangun loop umpan balik yang tidak bisa diselesaikan simulator. Blok yang dikendalikan clock memiliki state; blok kombinasional memiliki next_state; jangan biarkan salah satunya menyentuh variabel milik yang lain.

Selanjutnya

Sekarang kamu bisa membangun kontroler apa pun yang bisa kamu gambarkan. Bab berikutnya mundur selangkah dari desain yang bisa disintesis dan membahas testbench yang mengujinya: cara menggerakkan stimulus, mengamati output, menyimpan waveform, dan memastikan module-mu benar-benar melakukan apa yang kamu kira.