Logik digital pada DE1-SoC (5/6): mesin keadaan terhingga

Anda sudah membina litar yang mengingati: flip-flop menyimpan satu bit, daftar menyimpan beberapa bit dan pembilang menyimpan kiraan semasa. Mesin keadaan terhingga (FSM) menyusun ingatan itu menjadi *situasi yang bermakna*. Pada setiap masa, mesin berada dalam tepat satu daripada set keadaan yang kecil dan tetap. Bagi lampu isyarat, keadaannya mungkin GREEN, YELLOW dan RED. Bilangan keadaan itu terhingga, maka namanya, dan mesin sentiasa berada dalam tepat satu daripadanya.

FSM ditakrifkan oleh tiga perkara:

- Keadaan — set situasi terhingga yang boleh diduduki mesin. Satu keadaan khas ialah keadaan set semula, tempat mesin bermula.
- Peralihan — peraturan untuk berpindah daripada satu keadaan kepada keadaan lain. Pada setiap pinggir jam, mesin melihat keadaan semasa dan input lalu menentukan keadaan seterusnya. GREEN -> YELLOW bermaksud, jika mesin berada dalam GREEN dan syarat dipenuhi, ia berpindah ke YELLOW pada pinggir berikutnya.
- Output — nilai yang dipacu oleh mesin pada outputnya, di sini LED, dalam setiap situasi.

Seluruh mesin bergerak mengikut jam. Pada setiap pinggir, ia mungkin berpindah kepada keadaan baharu berdasarkan keadaan semasa dan input semasa, kemudian mengekalkan keadaan itu hingga pinggir berikutnya. Antara pinggir, ia hanya menunggu. Ini ialah tingkah laku sampel dan tahan yang sama seperti flip-flop, kini digunakan untuk melalui jujukan keadaan.

Moore berbanding Mealy. FSM terbahagi kepada dua jenis mengikut sumber output:

- Dalam mesin Moore, output bergantung hanya pada keadaan semasa. Jika keadaan diketahui, output juga diketahui; input tidak muncul dalam persamaan output. Lampu isyarat ialah Moore: apabila keadaan ialah RED, LED merah menyala tanpa mengira input.
- Dalam mesin Mealy, output bergantung pada keadaan semasa dan input semasa bersama-sama. Keadaan yang sama boleh menghasilkan output berbeza mengikut input ketika itu. Pengesan jujukan ialah Mealy: ia menegaskan “dikesan” dalam keadaan tertentu *hanya apabila bit masuk juga mempunyai nilai yang betul*.

Output Moore stabil selagi mesin kekal dalam sesuatu keadaan. Output Mealy boleh berubah sebaik sahaja input berubah, walaupun keadaan tidak bertukar. Ini menjadikannya pantas tetapi juga berpotensi singkat dan terganggu oleh glitch, perkara yang penting pada kamera.

Bentuk piawai FSM dalam Verilog. Hampir setiap FSM dalam kursus ini ditulis sebagai dua atau tiga blok yang bekerjasama:

1. Daftar keadaan — blok berjam (always @(posedge clock ...)) yang menyimpan keadaan semasa dan menyalin keadaan seterusnya pada setiap pinggir. Inilah satu-satunya blok yang mempunyai ingatan.
2. Blok keadaan seterusnya — blok gabungan (always @(*)) yang mengira keadaan berikut berdasarkan keadaan semasa dan input. Blok ini mesti mempunyai nilai lalai, iaitu tugasan awal next_state = ... dan kes default:, supaya setiap laluan memberikan nilai; tanpa lalai, selak yang tidak dikehendaki akan diterbitkan.
3. Logik output — pernyataan assign atau sebahagian blok gabungan yang memacu output daripada keadaan bagi Moore, atau daripada keadaan dan input bagi Mealy.

Kedua-dua reka bentuk dalam pelajaran ini mengikut bentuk tersebut: daftar keadaan berjam, blok keadaan seterusnya always @(*) dengan lalai dan logik output.

Sebelum membina, perhatikan satu perubahan yang disengajakan daripada pelajaran terdahulu.

Dalam Pelajaran 2 dan 3, flip-flop dan daftar menggunakan set semula segerak: set semula diuji *di dalam* blok berjam, seperti if (!KEY[0]) Q <= 0; dalam always @(posedge CLOCK_50). Oleh sebab ujian ini hanya dijalankan pada pinggir jam, set semula segerak hanya berkuat kuasa pada pinggir menaik seterusnya. Jika jam perlahan, set semula perlu menunggu.

FSM dalam pelajaran ini menggunakan set semula tak segerak aktif-rendah. Lihat senarai kepekaan daftar keadaan:

always @(posedge slow_clk or negedge KEY[0]) begin
    if (!KEY[0]) state <= TODO_RESET_STATE;   // tak segerak: tercetus apabila KEY[0] menjadi 0
    else         state <= TODO_NEXT_STATE;
end

Penambahan or negedge KEY[0] menyebabkan blok bertindak serta-merta apabila KEY[0] menjadi rendah, ketika butang ditekan, bukan hanya pada pinggir slow_clk. Jadi menekan KEY[0] memaksa mesin ke keadaan yang diketahui tanpa menunggu pinggir jam perlahan.

Nyatakan perbezaannya dengan jelas:

- Set semula segerak (Pelajaran 2–3): berkuat kuasa hanya pada pinggir jam. Ia kemas dan boleh diramal, tetapi perlu menunggu jika jam perlahan.
- Set semula tak segerak (Pelajaran 5–6): berkuat kuasa serta-merta apabila isyarat set semula ditegaskan, tanpa bergantung pada jam.

Mengapa berubah di sini? FSM ini dipacu oleh slow_clk yang pinggirnya berselang beberapa saat. Dengan set semula segerak, anda boleh menekan KEY[0] tetapi tiada apa-apa berlaku selama lebih satu saat. Set semula tak segerak menyediakan jalan keluar segera dan boleh dipercayai pada papan sebenar. KEY ialah aktif-rendah: negedge KEY[0] ialah saat butang ditekan dan !KEY[0] benar selagi ia ditahan.

FSM pertama ialah pengawal lampu isyarat. Ia mempunyai tiga keadaan dan melaluinya dalam kitaran tetap, mengekalkan setiap lampu selama beberapa detik:

GREEN -> YELLOW -> RED -> GREEN -> ...

Pendawaiannya ialah LEDR[0] = hijau, LEDR[1] = kuning, LEDR[2] = merah dan KEY[0] = set semula aktif-rendah yang mengembalikan mesin ke GREEN. Mesin dipacu oleh slow_clk terbahagi; setiap pinggir ialah satu detik, kira-kira 0.33 s dengan pembahagi ini.

Ini mesin Moore. Logik outputnya ialah:

assign LEDR[0] = TODO_GREEN_LED_EXPRESSION;
assign LEDR[1] = TODO_YELLOW_LED_EXPRESSION;
assign LEDR[2] = TODO_RED_LED_EXPRESSION;

Setiap LED ialah fungsi keadaan sahaja; tiada input muncul. Mengetahui keadaan cukup untuk menentukan lampu yang menyala. Itulah ciri mesin Moore.

Dua daftar berasingan menjalankan dua tugas. Daftar keadaan mengandungi dua jenis ingatan yang mudah dikelirukan:

- state, reg [1:0], menyimpan lampu yang sedang menyala: GREEN, YELLOW atau RED. Inilah keadaan FSM.
- timer, reg [2:0], ialah pembilang tempoh berasingan yang mengira baki detik dalam keadaan semasa. Selagi timer melebihi sifar, ia hanya berkurang dan keadaan tidak berubah. Apabila timer mencapai 0, mesin berpindah ke next_state dan memuat semula timer.

Jadi state menyimpan *lampu yang mana*, manakala timer mengira *berapa lama* ia kekal. Kedua-duanya daftar yang berbeza dengan fungsi yang berbeza.

Tempoh sebenar daripada kod. Kiraan daripada nilai muatan hingga 0, termasuk 0, memberikan bilangan detik:

- GREEN memuat timer = 3 dan mengira 3, 2, 1, 0: 4 detik, kira-kira 1.33 s.
- YELLOW memuat timer = 1: 2 detik, kira-kira 0.67 s.
- RED memuat timer = 3: 4 detik, kira-kira 1.33 s.

Satu kitaran lengkap ialah 4 + 2 + 4 = 10 detik, kira-kira 10 x 0.33 s = 3.3 s.

Ini modul permulaan. Pembahagi menghasilkan slow_clk; daftar keadaan dengan set semula tak segerak maju apabila pemasa tamat; always @(*) mengira lampu seterusnya; dan tiga baris assign ialah logik output Moore. Lengkapkan ruang letak TODO_* sebelum sintesis.

// Pelajaran 5 - Latihan 3-A: pengawal lampu isyarat permulaan (FSM Moore)
// Lengkapkan logik keadaan seterusnya dan output sebelum sintesis.
module leds_mirror(CLOCK_50, KEY, LEDR);
    input        CLOCK_50;
    input  [3:0] KEY;
    output [9:0] LEDR;

    localparam GREEN = 2'd0, YELLOW = 2'd1, RED = 2'd2;
    localparam [24:0] DIV = 25'd16_666_666;
    reg [24:0] div;
    reg        slow_clk;
    always @(posedge CLOCK_50) begin
        if (!KEY[0]) begin div <= 0; slow_clk <= 0; end
        else if (div == DIV) begin div <= 0; slow_clk <= ~slow_clk; end
        else div <= div + 1'b1;
    end

    reg [1:0] state, next_state;
    reg [2:0] timer;
    always @(posedge slow_clk or negedge KEY[0]) begin
        if (!KEY[0]) begin state <= GREEN; timer <= 3'd3; end
        else if (timer == 3'd0) begin
            state <= next_state;
            case (next_state)
                GREEN:   timer <= 3'd3;
                YELLOW:  timer <= 3'd1;
                RED:     timer <= 3'd3;
                default: timer <= 3'd3;
            endcase
        end else timer <= timer - 1'b1;
    end

    always @(*) begin
        case (state)
            GREEN:   next_state = TODO_AFTER_GREEN;
            YELLOW:  next_state = TODO_AFTER_YELLOW;
            RED:     next_state = TODO_AFTER_RED;
            default: next_state = GREEN;
        endcase
    end

    assign LEDR[0]   = TODO_GREEN_LED_EXPRESSION;
    assign LEDR[1]   = TODO_YELLOW_LED_EXPRESSION;
    assign LEDR[2]   = TODO_RED_LED_EXPRESSION;
    assign LEDR[9:3] = 7'b0;
endmodule

Sekarang bina lampu isyarat pada DE1-SoC sebenar, ukur setiap fasa dan kemudian ubah reka bentuknya.

Hantar bukti anda. Tunggu fasa YELLOW, ambil tangkapan kamera ketika LEDR[1], kuning, menyala manakala LEDR[0], hijau, dan LEDR[2], merah, padam, kemudian lampirkannya di bawah.

Sekarang buat dua perubahan pada reka bentuk.

(Ubah suai) Tukar tempoh setiap keadaan. Edit nilai muatan semula timer supaya kitarannya menjadi GREEN = 6 detik, YELLOW = 2 detik, RED = 6 detik. Pemasa mengira daripada nilai yang dimuat hingga 0, termasuk 0, jadi N detik memerlukan muatan N - 1: muat 5 bagi GREEN, 1 bagi YELLOW dan 5 bagi RED, dalam case daftar keadaan serta baris set semula jika nilai awal berubah. Jalankan sintesis, muat naik dan sahkan tempoh baharu pada kamera. Kemudian kira jumlah panjang kitaran dalam detik.

(Tambah) Keadaan merah berkelip. Tambah keadaan keempat, FLASH_RED, selepas RED, supaya kitarannya menjadi GREEN -> YELLOW -> RED -> FLASH_RED -> GREEN. Dalam FLASH_RED, LED merah perlu berselang antara menyala dan padam selama beberapa detik, contohnya empat, kemudian kembali ke GREEN. Petunjuk: lebarkan state/next_state untuk nilai keempat; tambah FLASH_RED pada localparam dan case keadaan seterusnya; berikan tempoh dalam case pemasa; dan pacu LEDR[2] dalam FLASH_RED daripada bit yang berubah pada setiap detik, seperti bit rendah pemasa, bukan 1 tetap. Jalankan sintesis, muat naik dan sahkan LED merah berkelip sebelum kembali hijau.

FSM kedua memerhatikan aliran bit yang tiba satu demi satu pada setiap detik jam melalui SW[0] dan menyalakan LED apabila pola 1011 baru sahaja muncul. Ini mesin Mealy: ia menegaskan “dikesan” dalam keadaan tertentu *hanya apabila bit masuk juga betul*, maka output bergantung pada keadaan dan input bersama-sama.

Pendawaiannya ialah SW[0] = bit input bersiri, KEY[0] = set semula aktif-rendah, LEDR[0] = dikesan dan LEDR[4:1] = keadaan semasa dalam paparan one-hot, satu LED bagi setiap keadaan. Pinggir menaik slow_clk, iaitu satu detik, berlaku kira-kira setiap 1.33 s dengan pembahagi ini.

Keadaan. Pengesan mengingati bahagian 1011 yang telah sepadan:

- S0 — belum ada padanan; keadaan set semula.
- S1 — bit terakhir ialah 1; sepadan dengan 1.
- S2 — sepadan dengan 10.
- S3 — sepadan dengan 101.
- S4 — sepadan dengan keseluruhan 1011. Dari sini, mesin masih boleh memulakan padanan baharu, membolehkan pengesanan bertindih: 1 terakhir dalam satu 1011 boleh menjadi 1 pertama bagi jujukan seterusnya.

Pada setiap detik, blok keadaan seterusnya melihat keadaan semasa dan bit SW[0]. Output detect ditegaskan dalam S3 hanya apabila bit masuk ialah 1, kerana 101 diikuti 1 melengkapkan 1011. Itulah output Mealy daripada keadaan dan input.

Mengapa output disimpan. Baca dengan teliti. Isyarat Mealy mentah detect tinggi selama satu detik sahaja. Dengan jam pantas, denyut itu tidak kelihatan; walaupun dengan jam perlahan, kilatan kira-kira 1.33 s mudah terlepas pada kamera jauh. Oleh itu, reka bentuk tidak menyambung detect terus kepada LED. Sebaliknya, pengesanan disimpan: daftar detected_latch ditetapkan kepada 1 apabila detect tercetus dan kekal 1 hingga set semula ditekan. LEDR[0] menunjukkan nilai itu, jadi selepas 1011 dikesan, LED menyala dan kekal menyala hingga KEY[0]. Peristiwa singkat ditukar menjadi petunjuk stabil yang boleh difoto.

Ini modul permulaan. always @(*) gabungan mengira next_state dan output Mealy detect; always @(posedge slow_clk or negedge KEY[0]) berjam menyimpan keadaan dan nilai pengesanan, dengan set semula tak segerak. Lengkapkan ruang letak TODO_* sebelum sintesis.

// Pelajaran 5 - Latihan 3-B: pengesan jujukan 1011 permulaan (FSM Mealy)
// Lengkapkan peralihan, denyut Mealy detect dan logik paparan keadaan.
module leds_mirror(CLOCK_50, KEY, SW, LEDR);
    input        CLOCK_50;
    input  [3:0] KEY;
    input  [9:0] SW;
    output [9:0] LEDR;

    localparam [26:0] DIV = TODO_DIVIDER_LIMIT;
    reg [26:0] div;
    reg        slow_clk;
    always @(posedge CLOCK_50) begin
        if (!KEY[0]) begin div <= 0; slow_clk <= 0; end
        else if (div == DIV) begin div <= 0; slow_clk <= ~slow_clk; end
        else div <= div + 1'b1;
    end

    localparam S0=3'd0, S1=3'd1, S2=3'd2, S3=3'd3, S4=3'd4;
    reg [2:0] state, next_state;
    reg       detect;
    always @(*) begin
        next_state = TODO_DEFAULT_NEXT_STATE;
        detect     = 1'b0;
        case (state)
            S0: TODO_TRANSITION_FROM_S0;
            S1: TODO_TRANSITION_FROM_S1;
            S2: TODO_TRANSITION_FROM_S2;
            S3: begin
                TODO_TRANSITION_AND_DETECT_FROM_S3;
            end
            S4: TODO_TRANSITION_FROM_S4;
            default: next_state = TODO_DEFAULT_STATE;
        endcase
    end

    reg detected_latch;
    always @(posedge slow_clk or negedge KEY[0]) begin
        if (!KEY[0]) begin state <= TODO_RESET_STATE; detected_latch <= 1'b0; end
        else begin
            state <= next_state;
            if (detect) detected_latch <= 1'b1;
        end
    end

    assign LEDR[0]   = detected_latch;
    assign LEDR[4:1] = TODO_ONE_HOT_STATE_DISPLAY;
    assign LEDR[9:5] = 5'b0;
endmodule

Sekarang bina pengesan dan masukkan bit secara manual. Cara memasukkan satu bit: tetapkan SW[0] kepada nilai bit, kemudian tunggu satu detik penuh jam perlahan, kira-kira 1.33 s, supaya mesin mensampelnya pada pinggir menaik seterusnya. Selepas itu, tukar SW[0] kepada bit berikutnya dan tunggu sekali lagi. Perhatikan LEDR[4:1] untuk menjejaki keadaan.

Muat naik bukti anda. Selepas memasukkan 1, 0, 1, 1, LEDR[0] (dikesan) akan kekal menyala sehingga set semula—keadaan stabil yang boleh dirakam. Ambil tangkapan skrin kamera yang menunjukkan LEDR[0] kekal menyala dan lampirkannya di bawah.

Sekarang ubah suai pengesan.

(Ubah suai) Kesan 101 dan bukannya 1011. Mula-mula lukis rajah keadaan baharu pada kertas: anda memerlukan keadaan untuk "tiada padanan", "1 sudah dipadankan" dan "10 sudah dipadankan". Output pengesanan sepatutnya tercetus apabila, dalam keadaan "10 sudah dipadankan", bit seterusnya ialah 1 (melengkapkan 101). Fikirkan tentang tindihan: selepas mengesan 101, 1 yang terakhir boleh menjadi permulaan bagi 101 seterusnya. Kemudian edit Verilog—anda boleh menggugurkan S4, mengubah hala peralihan supaya detect ditegaskan pada langkah 10 diikuti 1, serta mengekalkan daftar simpanan dan paparan keadaan one-hot. Jalankan sintesis, muat naik dan sahkan bahawa memasukkan 1, 0, 1 menjadikan LEDR[0] kekal menyala.

Anda membina dua mesin keadaan terhingga pada DE1-SoC sebenar: pengawal lampu isyarat Moore, yang outputnya hanya bergantung pada keadaan dan bergerak GREEN -> YELLOW -> RED mengikut pemasa tempoh; serta pengesan jujukan 1011 Mealy, yang output detect bergantung pada keadaan dan input. Anda menggunakan struktur FSM piawai—daftar keadaan berjam, blok kombinasi keadaan seterusnya dengan nilai lalai dan logik output—serta set semula tak segerak aktif-rendah yang memaksa keadaan diketahui dengan serta-merta. Anda juga melihat sebab output satu detik disimpan supaya dapat dirakam oleh kamera jauh.