Logika digitala DE1-SoC plakan VHDLrekin (5/6): egoera finituko makinak

Gogoratzen duten zirkuituak eraiki dituzu dagoeneko: biegonkorrak bit bat gordetzen du; erregistroak, hainbat; eta kontagailuak, uneko kontua. Egoera finituko makinak (finite-state machine, FSM) memoria hori esanahia duten egoeretan antolatzen du. Une bakoitzean, makina egoera multzo mugatu bateko egoera bakarrean dago. Semaforo batean, adibidez, BERDEA, HORIA eta GORRIA izan daitezke. Egoera kopurua finitua da, eta makina beti dago horietako batean, eta bakarrean.

FSM bat hiru osagairekin deskribatzen dugu:

• Egoerak: egon daitezkeen egoeren multzo finitua. Reset-egoera berezia da: reset egitean makina egoera horretara doa.
• Trantsizioak: egoera batetik bestera pasatzeko arauak. Erlojuaren ertz aktiboan, makina uneko egoeraren eta sarreren arabera eguneratzen da. BERDEA → HORIA trantsizioak hau esan nahi du: «BERDEA egoeran bazaude eta baldintza betetzen bada, hurrengo ertzean HORIA egoerara pasatuko zara».
• Irteerak: makinak egoera bakoitzean kontrolatzen duena; hemen, LEDak.

Egoera-erregistroa erlojuak gidatzen du: ertz aktibo bakoitzean egoera berria har dezake, uneko egoeraren eta sarreren arabera, eta egoera hori mantentzen du hurrengo ertzera arte, reset egin ezean. Biegonkorrekin ikasitako lagina hartzeko eta mantentzeko portaera bera da, egoeren sekuentzia bat egiteko erabilia. Irteera konbinazionalak, ordea, ertz artean ere alda daitezke, ondoren ikusiko duzun bezala.

Moore eta Mealy. Bi ereduen arteko aldea irteerak kalkulatzeko modua da:

• Moore makinan, irteerak uneko egoeraren araberakoak dira soilik. Egoera ezagututa, irteerak ezagutzen dituzu; sarrerak ez dira irteeraren ekuazioan agertzen. Semaforoaren oinarrizko diseinua Moore da: GORRIA egoeran, gorriaren funtzioa duen LEDa piztuta dago.
• Mealy makinan, irteerak uneko egoeraren eta uneko sarreren araberakoak dira. Egoera berean irteera desberdinak izan daitezke sarrera aldatzean. Sekuentzia-detektagailuko detect seinalea Mealy da: egoera jakin batean aktibatzen da sarrerako bitak ere behar den balioa badu.

Moore irteerak egonkor mantentzen dira egoera berean gauden bitartean. Mealy irteerak sarrera aldatu bezain laster alda daitezke, egoera aldatu gabe. Azkar erantzuten dute, baina pultsu laburrak edo nahi gabeko iragankor laburrak (glitch) sor ditzakete; hori kontuan hartu behar da kameraz behatzean.

FSM baten ohiko egitura VHDLn. Bi edo hiru zati bereizten ditugu:

1. Egoera-erregistroa: erlojudun prozesua (if rising_edge(clock) then ...), uneko egoera gordetzen duena eta dagokion ertzean hurrengoa kargatzen duena. Diseinu osoak beste memoria batzuk ere baditu, hala nola tenporizadorea eta zatitzailea.
2. Hurrengo egoeraren logika: prozesu konbinazionala, uneko egoeratik eta sarreretatik hurrengoa kalkulatzen duena. Bide guztietan esleitu behar zaie balioa irteerei eta next_state seinaleari: case aurretik balio lehenetsia emanez edo adar guztiak osatuz. Prozesu konbinazional batean esleipenik gabeko bide batek nahi gabeko latch bat sor dezake.
3. Irteeren logika: esleipen konkurrenteak edo prozesu konbinazionalaren zati bat. Egoeratik kalkulatzen ditu irteerak (Moore), edo egoeratik eta sarreretatik (Mealy).

Bi diseinuetan ikusiko duzu bereizketa hori. Semaforoaren case blokeak state_t motako hiru egoerak esplizituki estaltzen ditu; detektagailuak, berriz, balio lehenetsiak ematen ditu case aurretik eta ondoren dagokion trantsizioa hautatzen du.

Eraikitzen hasi aurretik, alderatu bi reset motak.

Hirugarren ikasgaiko biegonkorrek eta erregistroek reset sinkronoa zuten: resetaren baldintza goranzko ertzaren adarrean egiaztatzen zen, adibidez if KEY(0) = '0' then Q <= '0';, if rising_edge(CLOCK_50) then barruan. Baldintza erloju-ertzean bakarrik ebaluatzen denez, reset sinkronoak hurrengo goranzko ertzean eragiten du. Erlojua motela bada, itxaron egin behar da.

Ikasgai honetako FSMek maila baxuan aktibo den reset asinkronoa dute; 4. ikasgaiko kontagailuaren eta desplazamendu-erregistroaren antzera. Begiratu egoera-erregistroaren sentikortasun-zerrenda:

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;

KEY sentikortasun-zerrendan sartzeak prozesua sakagailuen aldaketekin ere aktibatzen du. KEY(0) = '0' baldintza erlojuaren adarraren aurretik egiaztatzeak egoera resetera eramaten du sakatzean, slow_clk seinalearen ertzari itxaron gabe.

• Reset sinkronoa: erlojuaren ertz aktiboan eragiten du. Resetak aktibo jarraitu behar du une horretan.
• Reset asinkronoa: aktibatu bezain laster eragiten du, erlojuaren ertzik itxaron gabe.

KEY(0) sakatzean, zatitzaileak slow_clk = 0 mantentzen du. Beraz, egoera-erregistroko reset-baldintza goranzko ertzaren barrura eramanez gero, ez litzateke ertzik iritsiko reset aktibo dagoen bitartean; askatzean, berriz, reset-baldintza ez litzateke beteko. Reset asinkronoak hasierako egoera ezartzen du erlojua geldirik egonda ere. Horrek ez du esan nahi kamerako irudia berehalakoa denik: kameraren eta sarearen atzerapena dago. KEY maila baxuan aktibo da; sakatzean 0 ematen du eta KEY(0) = '0' egia da sakatuta mantentzen den bitartean.

Lehen FSM semaforo-kontrolagailua da. Hiru egoera ditu, ziklo finko batean; argi bakoitza erloju-urrats kopuru jakin batez mantentzen du:

BERDEA → HORIA → GORRIA → BERDEA → ...

Konexioak: LEDR(0) = berdearen funtzioa; LEDR(1) = horiaren funtzioa; LEDR(2) = gorriaren funtzioa. Plakako LEDR LEDak gorriak dira fisikoki: izenek semaforoaren funtzioak adierazten dituzte. KEY(0) resetak (maila baxuan aktibo) GREEN egoera ezartzen du. FSMak slow_clk zatitua erabiltzen du. Urrats bakoitza haren goranzko ertz bat da: zatitzaile honekin, ondoz ondoko goranzko ertzen arteko tartea 0,67 s ingurukoa da.

Moore makina da. Amaierako irteera-logika hau da:

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

LED bakoitza egoeraren araberakoa da soilik: adierazpenetan ez dago sarrerarik. Egoera ezagututa, zein LED dagoen piztuta badakizu. Hori da Moore makinaren ezaugarria.

Bi erregistro, bi eginkizun. Erlojudun blokeak bi memoria eguneratzen ditu:

• state erregistroak (state_t motako seinalea) zein argi dagokion uneko egoerari gordetzen du: GREEN, YELLOW edo RED.
• timer erregistroak (unsigned(2 downto 0) motako seinalea) iraute-denbora kontrolatzen du. Zero baino handiagoa den bitartean, urrats bakoitzean unitate bat kentzen zaio (timer <= timer - 1), eta egoera ez da aldatzen. timer aurretik 0 den ertzean, makinak next_state kargatzen du eta tenporizadorea egoera berrirako birkargatzen du.

Beraz, state erregistroak zein argi gordetzen du; timer erregistroak, zenbat iraun. Bigarrenari esker, argi bakoitzak hainbat urrats irauten du.

Kodearen denborak. Egoera batean sartzean, timer kargatzen da. Kargatutako baliotik 0 arte, biak barne, zenbatzeak urrats kopurua ematen du:

• GREEN: timer = 3; 3, 2, 1, 0 → 4 urrats, gutxi gorabehera 2,67 s.
• YELLOW: timer = 1; 1, 0 → 2 urrats, gutxi gorabehera 1,33 s.
• RED: timer = 3 → 4 urrats, gutxi gorabehera 2,67 s.

Ziklo osoa 4 + 2 + 4 = 10 urratsekoa da: 6,67 s inguru. Kontuz: DIV = 16_666_666 izanik, slow_clk 0,33 s ingurutik behin alderantzikatzen da, baina goranzko ertzetik hurrengora bi aldaketa behar dira. Reset askatu ondorengo lehen ertza 0,33 s ingurura dator; beraz, denborak neurtzeko, utzi lehen zikloa igarotzen.

Txantiloi osoan, zatitzaileak slow_clk sortzen du; reset asinkronoa duen prozesuak egoera eguneratzen du tenporizadorea amaitzean; prozesu konbinazionalak hurrengo argia aukeratzen du; eta hiru esleipen konkurrenteek Moore irteerak sortzen dituzte. Osatu TODO guztiak sintetizatu aurretik.

-- Ikaslearen txantiloia: osatu TODO lerroak sintetizatu aurretik.
-- 5. ikasgaia - 3-A ariketa: semaforo-kontrolagailua (Moore FSM).
-- KEY(0)=reset. LEDR(0)=berdea, LEDR(1)=horia, LEDR(2)=gorria (funtzioak).
-- Iraupenak: GREEN = 4 urrats, YELLOW = 2 urrats, RED = 4 urrats.
-- FSMaren urrats bat slow_clk-ren goranzko ertz bat da; ertzen arteko tartea 0,67 s inguru da.
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 urrats
                    when YELLOW => timer <= TODO_YELLOW_RELOAD; -- 2 urrats
                    when RED    => timer <= TODO_RED_RELOAD; -- 4 urrats
                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;

Eraiki semaforoa benetako DE1-SoC plakan, neurtu faseak eta moldatu diseinua.

Jaso zure ebidentzia. Hartu kameraren irudi bat YELLOW fasean: LEDR(1) piztuta eta LEDR(0) zein LEDR(2) itzalita. Gehitu irudiaren erreferentzia edo esteka.

Egin orain derrigorrezko denbora-aldaketa.

Aldatu iraute-denborak. Moldatu timer birkargatzeko balioak, zikloa GREEN = 6 urrats, YELLOW = 4 urrats, RED = 6 urrats izan dadin. Tenporizadoreak 0 ere zenbatzen duenez, N urratsetarako N − 1 kargatu behar duzu: "101" (5) GREEN-erako, "011" (3) YELLOW-erako eta "101" (5) RED-erako. Aldatu erlojudun prozesuko case adarrak eta reset-lerroko GREEN hasierako balioa ere. Sintetizatu, igo eta egiaztatu denbora berriak kameran, lehen zikloa igarotzen utzita. Kalkulatu ziklo osoaren urrats kopurua.

Aukerako hedapena: gorri keinukariaren egoera. Irakasleak proposatzen badu, gehitu FLASH_RED laugarren egoera RED ondoren: GREEN → YELLOW → RED → FLASH_RED → GREEN. Egoera horretan gorriaren funtzioa duen LEDak keinu egin behar du hainbat urratsetan. Ordeztu oraingo LEDR(2) esleipena esleipen bakar honekin: LEDR(2) <= '1' when state = RED else timer(0) when state = FLASH_RED else '0';. Horrela, ez duzu irteera bera bi tokietatik kontrolatuko. Gehitu FLASH_RED state_t motari, osatu hurrengo egoeraren case blokea eta eman iraute-denbora tenporizadorearen case blokean. Sintetizatu, igo eta egiaztatu GREEN-era itzuli aurretik keinuak egiten dituela.

Bigarren FSMak SW(0) sarreratik urratseko bit bat jasotzen du, eta LED bat pizten du 1011 patroia detektatzean. Bere detect irteera Mealy da: egoera jakin batean aktibatzen da sarrerako bita ere zuzena denean. Beraz, egoeraren eta sarreraren araberakoa da.

Konexioak: SW(0) = serieko sarrerako bita; KEY(0) = reset (maila baxuan aktibo); LEDR(0) = detekzioa gordeta; eta LEDR(5 downto 1) = egoeraren adierazpena, arazteko. Bost egoeretako bakoitzean LED bakarra pizten da (one-hot). slow_clk zatitzaileak 1,33 s inguru uzten ditu goranzko ertzen artean; erabili DIV = 33_333_333 balioa.

Egoerak. Detektagailuak 1011 patroiaren zer zati ikusi duen gogoratzen du:

• S0: oraingoz ez dago bat datorren aurrizkirik; reset-egoera da.
• S1: azken bita 1 izan da; 1 aurrizkia bat dator.
• S2: 10 bat dator.
• S3: 101 bat dator.
• S4: 1011 osoa detektatu da. Ondorengo trantsizioek bat datorren amaiera gordetzen dute, gainjarritako sekuentziak detektatzeko.

Hurrengo egoeraren blokeak uneko egoera eta SW(0) bita erabiltzen ditu. detect S3 egoeran eta sarrera 1 denean aktibatzen da: 101 ondoren 1 jasotzeak 1011 osatzen du. Hori da Mealy irteera.

Zergatik mantendu detekzioa gordeta? detect seinale konbinazionala laburra izan daiteke: sarrera aldatzean aktiba daiteke eta egoera edo sarrera berriz aldatzean desaktibatu. Ez du beti urrats oso bat irauten. Erloju azkar batekin kamerak ez luke bereiziko; motelean ere erraz gal daiteke. Horregatik, diseinuak ez du detect zuzenean LEDera konektatzen. detected_latch erregistroak 1 gordetzen du goranzko ertzean detect = 1 irakurtzen badu, eta reset egin arte 1 mantentzen du. LEDR(0) erregistro horren irteera da. Izenak latch badio ere, hemen erloju-ertzak gidatutako biegonkorra da. Gertaera laburra behatzeko moduko adierazle iraunkor bihurtzen du.

Txantiloi osoan, prozesu konbinazionalak next_state eta Mealy detect irteera kalkulatzen ditu. process(slow_clk, KEY) prozesuak egoera eta detekzio-adierazlea gordetzen ditu, reset asinkronoarekin. Osatu trantsizioen TODOak eta detekzio-baldintza sintetizatu aurretik.

-- Ikaslearen txantiloia: osatu TODO lerroak sintetizatu aurretik.
-- 5. ikasgaia - 3-B ariketa: 1011 detektagailua (Mealy FSM), detekzioa gordeta.
-- SW(0)=serieko sarrerako bita; KEY(0)=reset; LEDR(0)=gordetako detekzioa.
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;

Eraiki detektagailua eta sartu bitak eskuz. Bit bat sartzeko, ezarri SW(0) dagokion balioan eta mantendu hurrengo slow_clk goranzko ertzean lagina hartu arte. Ondoz ondoko ertzen tartea 1,33 s ingurukoa da. Jarraitu egoera LEDR(5 downto 1) bidez, eta aldatu hurrengo bita aurrekoa hartu ondoren. Eskuzko denborak eta kameraren atzerapenak ez dira zehatzak: taulako egoerak espero dituzunekin bat ez badatoz, egin reset eta errepikatu, bit bakoitza ertz bakarrean hartzea helburu. Resetaren ondorengo lehen ertza 0,67 s ingurura dator; prestatu lehen bita reset askatu aurretik.

Jaso zure ebidentzia. 1, 0, 1, 1 sartu ondoren, LEDR(0) piztuta mantentzen da reset egin arte. Hartu hori erakusten duen kameraren irudi bat eta gehitu haren erreferentzia edo esteka.

Astirik badago, moldatu detektagailua aukerako ariketa honetan.

Detektatu 101, 1011 ordez. Marraztu lehenik egoera-diagrama berria paperean: «ez dago bat datorren aurrizkirik», «1 bat dator» eta «10 bat dator» egoerak behar dituzu. detect aktibatu behar da «10 bat dator» egoeran sarrerako bita 1 denean. Kontuan hartu gainjartzea: 101 detektatu ondorengo azken 1 hurrengo 101 sekuentziaren hasiera izan daiteke. Ondoren, moldatu VHDL kodea: kendu beharrezkoak ez diren egoerak —S4, adibidez—, zuzendu trantsizioak eta aktibatu detect dagokion baldintzan. Mantendu gordetako detekzio-adierazlea eta egokitu egoera-LEDak geratzen diren egoeretara. Sintetizatu, kargatu eta egiaztatu 1, 0, 1 sartzeak LEDR(0) piztuta uzten duela.

Moore semaforoa eraiki duzu benetako DE1-SoC plakan: irteerak egoeraren araberakoak dira, eta tenporizadoreak GREEN → YELLOW → RED zikloa gidatzen du. FSM-ren ohiko zatiak erabili dituzu: erlojudun egoera-erregistroa, hurrengo egoeraren logika konbinazionala eta irteeren logika. Maila baxuan aktibo den reset asinkronoak egoera ezaguna ezartzen du erloju-ertzik itxaron gabe. Aukerako ariketa egin baduzu, Mealy 1011 detektagailua ere aztertu duzu, eta detekzio laburra gordeta mantentzeak kameraz behatzeko zergatik laguntzen duen ikusi duzu.