Logik digital pada DE1-SoC dengan VHDL (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 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 VHDL. Hampir setiap FSM dalam kursus ini ditulis sebagai dua atau tiga blok yang bekerjasama:

1. Daftar keadaan — proses VHDL berjam (if rising_edge(clock) then ...) yang menyimpan keadaan semasa dan menyalin keadaan seterusnya pada setiap pinggir. Inilah satu-satunya blok yang mempunyai ingatan.
2. Proses keadaan seterusnya — proses gabungan VHDL yang mengira keadaan seterusnya daripada keadaan semasa dan input. Ia perlu memberikan nilai lalai yang selamat sebelum case atau meliputi setiap cabang secara jelas supaya setiap laluan memberikan nilai kepada output dan next_state.
3. Logik output — tugasan isyarat serentak atau tugasan dalam proses gabungan yang memacu output daripada keadaan (Moore) atau daripada keadaan dan input (Mealy).

Kedua-dua reka bentuk dalam pelajaran ini mengikuti bentuk tersebut: proses keadaan berjam, proses gabungan keadaan seterusnya dengan nilai lalai dan logik output.

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

Dalam Pelajaran 3, flip-flop dan daftar menggunakan set semula segerak: set semula diuji di dalam proses berjam, seperti if KEY(0) = '0' then Q <= '0'; di dalam if rising_edge(CLOCK_50) then. Pelajaran 4 sudah menggunakan set semula tak segerak aktif-rendah bagi litar jam perlahan; pelajaran ini meneruskan gaya itu untuk keadaan FSM supaya set semula tidak menunggu jam perlahan.

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

process(slow_clk, KEY)
begin
    if KEY(0) = '0' then state <= TODO_RESET_STATE;
    elsif rising_edge(slow_clk) then state <= TODO_NEXT_STATE;
    end if;
end process;

Meletakkan KEY dalam senarai kepekaan proses dan memeriksa if KEY(0) = '0' then sebelum cabang pinggir jam bermakna proses keadaan turut bertindak pada saat KEY(0) menjadi rendah, iaitu ketika butang ditekan, bukan hanya pada pinggir slow_clk. Menekan KEY(0) memaksa mesin ke keadaan yang diketahui serta-merta, tanpa menunggu jam perlahan.

Nyatakan perbezaannya dengan jelas:

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

Mengapa berubah? FSM ini berjalan daripada slow_clk terbahagi yang pinggirnya berselang beberapa saat. Jika set semula segerak digunakan, anda mungkin menekan KEY(0) tetapi tidak melihat apa-apa berlaku selama lebih satu saat hingga pinggir perlahan berikutnya. Jika mesin tersekat, ketika itulah anda paling memerlukan jalan keluar segera. Set semula tak segerak memberikan pemaksaan kembali ke mula yang segera dan boleh dipercayai pada papan sebenar. KEY ialah aktif-rendah: KEY(0) menjadi rendah ketika butang ditekan dan KEY(0) = '0' benar selagi butang ditahan.

FSM pertama anda ialah pengawal lampu isyarat. Ia mempunyai tiga keadaan yang dilalui dalam kitaran tetap, dengan setiap lampu dikekalkan selama bilangan detik tertentu:

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

Sambungannya 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 menaik ialah satu detik mesin keadaan. Dengan pembahagi ini, gunakan kira-kira 0.67 s bagi setiap detik yang kelihatan; pinggir menaik pertama selepas set semula boleh tiba lebih awal.

Ini ialah mesin Moore. Logik output di bahagian bawah ialah

LEDR(0) <= TODO_GREEN_LED;
LEDR(1) <= TODO_YELLOW_LED;
LEDR(2) <= TODO_RED_LED;

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

Dua daftar berasingan menjalankan dua tugas berasingan. Baca daftar keadaan dengan teliti kerana reka bentuk ini mempunyai *dua* ingatan yang mudah dikelirukan:

- state, isyarat jenis state_t, menyimpan lampu yang sedang menyala: GREEN, YELLOW atau RED. Inilah keadaan FSM.
- timer, isyarat unsigned(2 downto 0), ialah pembilang tempoh berasingan yang mengira turun bilangan detik yang tinggal bagi lampu semasa. Selagi timer lebih besar daripada sifar, ia hanya berkurang (timer <= timer - 1) dan keadaan tidak berubah. Hanya apabila timer mencapai 0, mesin bergerak ke next_state dan memuat semula timer bagi lampu baharu.

Jadi daftar keadaan menyimpan *lampu yang mana* menyala, manakala pemasa mengira *berapa lama* lampu itu kekal menyala. Kedua-duanya ialah daftar berlainan dengan tujuan berlainan; pemasa mengekalkan setiap lampu dan menghalangnya daripada berlalu dalam satu detik sahaja.

Tempoh sebenar daripada kod. Apabila mesin memasuki setiap keadaan, ia memuat semula timer; kiraan daripada nilai yang dimuat hingga 0, termasuk kedua-duanya, memberikan bilangan detik:

- GREEN memuatkan timer = 3 dan mengira 3, 2, 1, 0 -> 4 detik (kira-kira 2.7 s).
- YELLOW memuatkan timer = 1 dan mengira 1, 0 -> 2 detik (kira-kira 1.3 s).
- RED memuatkan timer = 3 -> 4 detik (kira-kira 2.7 s).

Oleh itu, satu kitaran lengkap mempunyai 4 + 2 + 4 = 10 detik, kira-kira 10 × 0.67 s = 6.7 s dari mula hingga akhir.

Inilah entiti lengkap. Pembahagi menghasilkan slow_clk; proses keadaan dengan set semula tak segerak memajukan lampu apabila pemasa tamat; proses gabungan mengira lampu seterusnya; dan tiga tugasan LED serentak membentuk logik output Moore.

-- Kod permulaan: lengkapkan baris TODO sebelum sintesis.
-- Pelajaran 5 - Latihan 3-A: pengawal lampu isyarat (FSM Moore).
-- KEY(0)=set semula. LEDR(0)=hijau, LEDR(1)=kuning, LEDR(2)=merah.
-- Tempoh: GREEN = 4 detik, YELLOW = 2 detik, RED = 4 detik.
-- Satu detik FSM yang kelihatan ialah pinggir menaik slow_clk, kira-kira 0.67 s dengan pembahagi ini.
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity blink is
    port (
        CLOCK_50 : in  std_logic;
        KEY      : in  std_logic_vector(3 downto 0);
        LEDR     : out std_logic_vector(9 downto 0)
    );
end entity blink;

architecture rtl of blink is
    type state_t is (GREEN, YELLOW, RED);
    signal state, next_state : state_t := GREEN;
    signal timer : unsigned(2 downto 0) := "011";
    constant DIV : unsigned(24 downto 0) := to_unsigned(16666666, 25);
    signal div_count : unsigned(24 downto 0) := (others => '0');
    signal slow_clk : std_logic := '0';
begin
    process(CLOCK_50)
    begin
        if rising_edge(CLOCK_50) then
            if KEY(0) = '0' then
                div_count <= (others => '0'); slow_clk <= '0';
            elsif div_count = DIV then
                div_count <= (others => '0'); slow_clk <= not slow_clk;
            else
                div_count <= div_count + 1;
            end if;
        end if;
    end process;

    process(state)
    begin
        case state is
            when GREEN  => next_state <= TODO_AFTER_GREEN;
            when YELLOW => next_state <= TODO_AFTER_YELLOW;
            when RED    => next_state <= TODO_AFTER_RED;
        end case;
    end process;

    process(slow_clk, KEY)
    begin
        if KEY(0) = '0' then
            state <= GREEN; timer <= "011";
        elsif rising_edge(slow_clk) then
            if timer = 0 then
                state <= next_state;
                case next_state is
                    when GREEN  => timer <= TODO_GREEN_RELOAD; -- 4 detik
                    when YELLOW => timer <= TODO_YELLOW_RELOAD; -- 2 detik
                    when RED    => timer <= TODO_RED_RELOAD; -- 4 detik
                end case;
            else
                timer <= timer - 1;
            end if;
        end if;
    end process;

    LEDR(0) <= TODO_GREEN_OUTPUT;
    LEDR(1) <= TODO_YELLOW_OUTPUT;
    LEDR(2) <= TODO_RED_OUTPUT;
    LEDR(9 downto 3) <= (others => '0');
end architecture rtl;

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

Hantar bukti anda. Tunggu fasa YELLOW dan ambil tangkap layar kamera ketika LEDR(1) (kuning) menyala sementara LEDR(0) (hijau) dan LEDR(2) (merah) padam. Lampirkannya di bawah.

Sekarang lakukan satu perubahan pemasaan wajib pada reka bentuk.

(Ubah suai) Tukar tempoh. Edit nilai muat semula timer supaya kitarannya menjadi GREEN = 6 detik, YELLOW = 4 detik, RED = 6 detik. Pemasa mengira daripada nilai yang dimuat hingga 0, termasuk kedua-duanya, jadi N detik bermaksud memuatkan N - 1: muatkan "101" (5) bagi GREEN, "011" (3) bagi YELLOW dan "101" (5) bagi RED, dalam case daftar keadaan dan juga baris set semula jika nilai awal berubah. Jalankan sintesis, muat naik, sahkan pemasaan baharu pada kamera dan kira jumlah panjang kitaran baharu dalam detik.

Sambungan pilihan: tambah keadaan merah berkelip. Tambah keadaan keempat, FLASH_RED, selepas RED hanya jika guru meminta sambungan ini. Untuk mengelakkan LEDR(2) dipacu dari dua tempat, gantikan tugasan LED merah dengan satu pemacu gabungan seperti LEDR(2) <= '1' when state = RED else timer(0) when state = FLASH_RED else '0';. Kemudian tambah FLASH_RED pada jenis VHDL state_t dan case keadaan seterusnya, berikan tempoh dalam case pemasa, jalankan sintesis, muat naik dan sahkan LED merah berkelip sebelum kembali ke hijau.

FSM kedua anda memerhatikan aliran bit yang tiba satu per detik jam pada SW(0) dan menyalakan LED apabila corak 1011 baru dikesan. Ini ialah mesin Mealy: ia menegaskan “dikesan” dalam keadaan tertentu *hanya apabila bit masuk juga betul*, jadi output bergantung pada keadaan dan input bersama-sama.

Sambungannya ialah SW(0) = bit input bersiri, KEY(0) = set semula aktif-rendah, LEDR(0) = dikesan dan LEDR(5 downto 1) = keadaan semasa dalam paparan one-hot, satu LED bagi setiap keadaan, supaya pergerakan mesin dapat dilihat. Mesin dipacu oleh slow_clk terbahagi yang pinggir menaiknya, satu detik, berlaku kira-kira setiap 1.33 s dengan pembahagi ini.

Keadaan. Pengesan mengingati bahagian 1011 yang telah dipadankan:

- S0 — belum memadankan apa-apa; keadaan set semula.
- S1 — bit terakhir ialah 1; memadankan 1.
- S2 — memadankan 10.
- S3 — memadankan 101.
- S4 — memadankan 1011 sepenuhnya. Dari sini mesin masih boleh memulakan padanan baharu, membolehkan pengesanan bertindih: 1 terakhir bagi satu 1011 boleh menjadi 1 pertama bagi yang berikutnya.

Pada setiap detik, blok keadaan seterusnya melihat keadaan semasa dan bit pada SW(0), lalu bergerak sewajarnya. Output detect ditegaskan dalam S3 hanya apabila bit masuk ialah 1, kerana 101 diikuti 1 melengkapkan 1011. Itulah output Mealy, yang ditentukan oleh keadaan dan input.

Mengapa output disimpan — baca dengan teliti. Isyarat Mealy mentah detect tinggi selama satu detik sahaja. Pada jam pantas, denyut itu tidak kelihatan; walaupun pada jam perlahan ini, kilatan kira-kira 1.33 s mudah terlepas pada kamera jauh. Oleh itu, reka bentuk tidak menyambungkan detect terus ke LED. Sebaliknya, pengesanan disimpan: daftar berasingan detected_latch ditetapkan kepada 1 apabila detect dicetuskan dan kekal ditetapkan hingga set semula ditekan. LEDR(0) memaparkan latch itu. Selepas 1011 dikesan, LED menyala dan kekal menyala hingga KEY(0). Peristiwa singkat ditukar menjadi petunjuk stabil yang mudah dirakam.

Inilah entiti lengkap. Perhatikan bentuk dua proses: proses gabungan mengira next_state dan isyarat Mealy detect, manakala process(slow_clk, KEY) berjam menyimpan keadaan dan latch dengan set semula tak segerak.

-- Kod permulaan: lengkapkan baris TODO sebelum sintesis.
-- Pelajaran 5 - Latihan 3-B: pengesan jujukan 1011 (FSM Mealy) dengan pengesanan tersimpan.
-- SW(0)=bit input bersiri. KEY(0)=set semula. LEDR(0)=latch pengesanan.
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity blink is
    port (
        CLOCK_50 : in  std_logic;
        KEY      : in  std_logic_vector(3 downto 0);
        SW       : in  std_logic_vector(9 downto 0);
        LEDR     : out std_logic_vector(9 downto 0)
    );
end entity blink;

architecture rtl of blink is
    type state_t is (S0, S1, S2, S3, S4);
    signal state, next_state : state_t := S0;
    signal detect, detected_latch : std_logic := '0';
    constant DIV : unsigned(26 downto 0) := to_unsigned(33333333, 27);
    signal div_count : unsigned(26 downto 0) := (others => '0');
    signal slow_clk : std_logic := '0';
begin
    process(CLOCK_50)
    begin
        if rising_edge(CLOCK_50) then
            if KEY(0) = '0' then
                div_count <= (others => '0'); slow_clk <= '0';
            elsif div_count = DIV then
                div_count <= (others => '0'); slow_clk <= not slow_clk;
            else
                div_count <= div_count + 1;
            end if;
        end if;
    end process;

    process(state, SW)
    begin
        next_state <= S0;
        detect <= '0';
        case state is
            when S0 => TODO_TRANSITION_FROM_S0;
            when S1 => TODO_TRANSITION_FROM_S1;
            when S2 => TODO_TRANSITION_FROM_S2;
            when S3 => TODO_TRANSITION_FROM_S3_AND_DETECT;
            when S4 => TODO_TRANSITION_FROM_S4;
        end case;
    end process;

    process(slow_clk, KEY)
    begin
        if KEY(0) = '0' then
            state <= S0; detected_latch <= '0';
        elsif rising_edge(slow_clk) then
            state <= next_state;
            if TODO_DETECT_CONDITION then detected_latch <= '1'; end if;
        end if;
    end process;

    LEDR(0) <= detected_latch;
    LEDR(5 downto 1) <= "00001" when state = S0 else
                         "00010" when state = S1 else
                         "00100" when state = S2 else
                         "01000" when state = S3 else
                         "10000";
    LEDR(9 downto 6) <= (others => '0');
end architecture rtl;

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

Hantar bukti anda. Selepas memasukkan 1, 0, 1, 1, LEDR(0) (dikesan) tersimpan menyala hingga set semula, iaitu keadaan stabil yang boleh difoto. Ambil tangkap layar kamera yang menunjukkan LEDR(0) tersimpan menyala dan lampirkannya.

Sambungan pilihan jika masih ada masa: ubah suai pengesan untuk mengenal 101 dan bukan 1011. Mula-mula lukis rajah keadaan baharu: anda memerlukan keadaan “belum dipadankan”, “padan 1” dan “padan 10”; output pengesanan perlu dicetuskan apabila bit seterusnya ialah 1 dalam keadaan “padan 10”. Jika dilaksanakan, kekalkan latch dan paparan one-hot, jalankan sintesis, muat naik dan sahkan bahawa memasukkan 1, 0, 1 menyimpan LEDR(0) menyala.

Anda membina pengawal lampu isyarat Moore pada DE1-SoC sebenar: outputnya bergantung pada keadaan sahaja dan ia bergerak GREEN -> YELLOW -> RED menggunakan pemasa tempoh. Dalam sambungan pilihan, anda turut meneroka pengesan jujukan 1011 Mealy yang output detect-nya bergantung pada keadaan dan input bersama-sama. Anda menggunakan bentuk FSM piawai: daftar keadaan berjam, blok gabungan keadaan seterusnya dengan nilai lalai dan logik output. Anda juga melihat cara set semula tak segerak aktif-rendah mengembalikan FSM berjam perlahan ke keadaan diketahui serta-merta dan, dalam sambungan, sebab output satu detik disimpan supaya kamera jauh dapat menangkapnya.