Véges állapotú szekvenciális automaták tervezése VHDL hardverleíró

nyelven

A véges állapotú szekvenciális automaták absztrakt (elvont) modellek, amelyeknek

elemi belső memóriájuk van. Állapotokból épülnek fel, az állapotokat átmenetek kötik össze,
illetve az állapotokhoz vagy az átmenetekhez kimeneteket rendelhetünk hozzá. Az átmenetek
az órajellel szinkron módon valósulnak meg automatikusan az órajel valamelyik élére (a
gyakorlatokon általában az órajel felfutó élét használjuk) vagy valamely feltétel teljesülése
esetében.
Az alábbi ábra szemlélteti egy véges állapotú szekvenciális automata modelljét:
• bemeneti változók halmaza: X = {x0, x1, … xn-1}
• kimeneti változók halmaza: Z = {z0, z1, … zm-1}
• állapotok halmaza: S = {s0, s1, … sk-1}
• átmeneti függvény: f: X x S→S
• kimeneti függvény: g: X x S→Z vagy g: S→Z

X(t) Z(t)
S(t)

Ábra 1. Véges állapotú automata modellje

Tehát egy automata leírásához matematikailag 3 halmaz és két függvény szükséges:

A = {X, S, Z, f, g}
Két típusú véges állapotú szekvenciális automata implementálást különböztethetünk
meg, ezért van a két típusú kimeneti függvény:
• a Moore típusú automaták esetében
o az átmeneti függvény: s(t+1) = f(x(t), s(t))
o a kimeneti függvény: z(t) = g(s(t))
▪ a kimenetek az állapotokhoz vannak rendelve (a kimenetek
csak az adott állapottól függenek)
• Mealy típusú automaták esetében
o az átmeneti függvény: s(t+1) = f(x(t), s(t))
o a kimeneti függvény: z(t) = g(s(t), x(t))
▪ a kimenetek az átmenetekhez vannak rendelve (a kimenetek
függenek az adott állapottól és a bemeneti változóktól is)
A kimeneti függvény értelmezési tartományának a változása tükröződik a véges állapotú
szekvenciális automaták ábrázolásánál, illetve az implementálásnál is.

1
 𝑥ҧ 𝑥ҧ /0

S0/0 𝑥ҧ S1/1 S0 𝑥ҧ /0 S1

x x/1
x x/1
x/1
x

S3/0 x S2/1 S3 x/0 S2

𝑥ҧ 𝑥ҧ 𝑥ҧ /0 𝑥ҧ /1

Ábra 2. Moore típusú automatát szemléltető állapotgráf Ábra 3. Mealy típusú automatát szemléltető állapotgráf

S={S0, S1, S2, S3} – állapotok S={S0, S1, S2, S3} – állapotok

X={x} – bemeneti változó X={x} – bemeneti változó

Z={z} – kimenet (egyértelműen az Z={z} – kimenet (egyértelműen az

állapotokhoz van rendelve átmenetekhez van rendelve

A gyakorlati megvalósításnál két jól elkülönülő részt figyelhetünk meg: egy

állapotregisztert (reg) amelyik tartalmazza az aktuális állapot bináris kódját és kombinációs
logikai áramkör részt, amelynek a szerepe a következő állapot és a kimenetek értékeinek a
meghatározása az aktuális állapot és a bemeneti változók értékeinek a függvényében.
Az implementálásbéli különbség a két típusú véges állapotú szekvenciális automata
típus között egyértelműen látszik az alábbi két tömbvázlaton is. A Moore típusú automata
esetén a kimeneti változók értékeit meghatározhatjuk az állapotregiszter értéke alapján. A
kimeneti változók értékeinek a meghatározásához nincs szükség a bemeneti változók értékeire.

Ábra 4. Moore típusú véges állapotú szekvenciális automata tömbvázlata

A Mealy típusú véges állapotú szekvenciális automata implementálásnál a következő

állapot meghatározása ugyanaz, mint a Moore típusú automaták esetében, viszont a kimeneti

2
változók értékeit meghatározó kombinációs logikai áramkörnek szüksége van úgy az
állapotregiszter értékére, mint a bemeneti változók értékeire.

Ábra 5. Mealy típusú véges állapotú szekvenciális automata tömbvázlata

A VHDL modulok felépítése két jól elkülöníthető részt tartalmaz: az entitást és az

architektúrát.

Clk
VHDL MODUL
ENTITÁS
x0 z0
x1 z1

… …
ARCHITEKTÚRA
xn-1 zm-1

Ábra 7. Egy VHDL modul ki és bemenetei

Ábra 6. Egy VHDL modul felépítése

Az entitás rész tartalmazza a VHDL modul ki és bemeneti portjait. A bemenetek a

bemeneti változók halmazába foglalt változók X = {x0, x1, … xn-1} és az órajel, a kimeneteket
pedig a kimeneti halmazba foglalt változók Z = {z0, z1, … zm-1} képezik. Az entitás rész azonos
függetlenül, hogy Moore vagy Mealy típusú az automata.

3
 A Moore típusú automata VHDL modul megírása
A 2. Ábrán feltüntetett állapotgráf által leírt Moore típusú automata VHDL entitás része
a következőképpen írható meg:
𝑥ҧ

entity MOOREautomata is 00/0 𝑥ҧ 01/1

Port ( CLK : in STD_LOGIC;
x : in STD_LOGIC; x
Q0 : out STD_LOGIC; x
Q1 : out STD_LOGIC;
x
z : out STD_LOGIC);
end MOOREautomata;
11/0 x 10/1

𝑥ҧ 𝑥ҧ

Ábra 8. A Moore automata Schematic Editor szimbóluma

Az architektúra rész megadja az áramkör belső felépítését vagy működését, attól

függően, hogy milyen leírásmódban készült. Az architektúra rész tartalmazza az állapotok
kódolását bináris formában, illetve két állapotregisztert az aktuális és a következő állapotok
tárolására.

architecture Behavioral of MOOREautomata is

--az állapotok bináris kódolása

CONSTANT S0 : std_logic_vector (1 DOWNTO 0) :="00";
CONSTANT S1 : std_logic_vector (1 DOWNTO 0) :="01";
CONSTANT S2 : std_logic_vector (1 DOWNTO 0) :="10";
CONSTANT S3 : std_logic_vector (1 DOWNTO 0) :="11";

--az aktuális és a következő állapotokat tartalmazó állapotregiszterek deklarálása

SIGNAL aktualis, kovetkezo : std_logic_vector (1 DOWNTO 0);

4
 Ugyancsak az architektúra részben írjuk meg két különálló folyamatként a következő
állapot és a kimenet értékét meghatározását, illetve az aktuális állapotból a következő állapotba
való átlépést.

begin
-- órajel felfutó élét figyelő folyamat
PROCESS (CLK)
BEGIN
IF rising_edge(CLK) THEN
--órajel felfutó él detektálása esetén átlépteti az automatát az aktuális
állapotból a következő állapotba
aktualis <= kovetkezo;
END IF;
END PROCESS;

--Következő állapotot és kimenetet előállító folyamat

PROCESS (aktualis,x)
BEGIN
CASE aktualis IS
WHEN S0 => z <= '0';-- az állapotot ismerve, megadható a kimenet értéke
--a bemenetet megvizsgálva megadható a következő állapot
IF x='1' THEN kovetkezo <= S2;
ELSE kovetkezo <= S0;
END IF;
WHEN S1 => z <= '1';
IF x='1' THEN kovetkezo <= S2;
ELSE kovetkezo <= S0;
END IF;
WHEN S2 => z <= '1';
IF x='1' THEN kovetkezo <= S3;
ELSE kovetkezo <= S2;
END IF;
WHEN S3 => z <= '0';
IF x='1' THEN kovetkezo <= S1;
ELSE kovetkezo <= S3;
END IF;
WHEN OTHERS => z<='Z'; kovetkezo<="ZZ";
END CASE;
END PROCESS;
--a kimenetek felveszik az aktuális állapotregiszter értékeit
Q0 <= aktualis(0);
Q1 <= aktualis(1);
end Behavioral;

5
 A Mealy típusú automata VHDL modul megírása

A 3. ábrán feltüntetett állapotgráf által leírt Moore típusú automata VHDL entitás része
a következőképpen írható meg:
ENTITY MEALYautomata IS 𝑥ҧ /0
PORT ( CLK : in STD_LOGIC;
x : in STD_LOGIC;
Q0 : out STD_LOGIC; 00 𝑥ҧ /0 01
Q1 : out STD_LOGIC;
z : out STD_LOGIC); x/1
END;
x/1
x/1

11 x/0 10

𝑥ҧ /0 𝑥ҧ /1

Ábra 9. A Mealy típusú automata Schematic Editor szimboluma

Az architektúra rész tartalmazza az állapotok kódolását bináris formában, illetve két

állapotregisztert az aktuális és a következő állapotok tárolására. Ugyancsak az architektúra
részben írjuk meg két különálló folyamatként a következő állapot és a kimenet értékét
meghatározását, illetve az aktuális állapotból a következő állapotba való átlépést.

ARCHITECTURE BEHAVIOR OF MEALYautomata IS

--az állapotok bináris kódolása
CONSTANT S0 : std_logic_vector (1 DOWNTO 0) :="00";
CONSTANT S1 : std_logic_vector (1 DOWNTO 0) :="01";
CONSTANT S2 : std_logic_vector (1 DOWNTO 0) :="10";
CONSTANT S3 : std_logic_vector (1 DOWNTO 0) :="11";

--az aktuális és a következő állapotokat tartalmazó állapotregiszterek deklarálása

SIGNAL aktualis, kovetkezo : std_logic_vector (1 DOWNTO 0);

--a kimenet következő értékét tartalmazó jel deklarálása

SIGNAL kovetkezo_z : std_logic;

6
BEGIN
-- órajel felfutó élét figyelő folyamat
PROCESS (CLK, kovetkezo, kovetkezo_z)
BEGIN
IF rising_edge(CLK) THEN
--átlépteti az automatát az aktuális állapotból a következo állapotba
aktualis <= kovetkezo;
--kiadja a következo kimenetet
z <= kovetkezo_z;
END IF;
END PROCESS;

--Következo állapotot és kimenetet előállító folyamat

PROCESS (aktualis,x)
BEGIN
CASE aktualis IS
WHEN S0 =>
IF ( x='0' ) THEN
--a következő állapot és a kimenet is függ a bemenettől
kovetkezo<=S0;
kovetkezo_z<='0';
END IF;
IF ( x='1' ) THEN
kovetkezo<=S2;
kovetkezo_z<='1';
END IF;
WHEN S1 =>
IF ( x='1' ) THEN
kovetkezo<=S2;
kovetkezo_z<='1';
END IF;
IF ( x='0' ) THEN
kovetkezo<=S0;
kovetkezo_z<='0';
END IF;
WHEN S2 =>
IF ( x='0' ) THEN
kovetkezo<=S2;
kovetkezo_z<='1';
END IF;
IF ( x='1' ) THEN
kovetkezo<=S3;
kovetkezo_z<='0';
END IF;
WHEN S3 =>
IF ( x='0' ) THEN

7
 kovetkezo<=S3;
kovetkezo_z<='0';
END IF;
IF ( x='1' ) THEN
kovetkezo<=S1;
kovetkezo_z<='1';
END IF;
WHEN OTHERS => kovetkezo_z<='Z'; kovetkezo<="ZZ";
END CASE;
END PROCESS;

--a kimenetek felveszik az aktuális állapotregiszter értékeit

Q0<=aktualis(0);
Q1<=aktualis(1);

END BEHAVIOR;

A megírt VHDL modulok tesztelése kétféleképpen is elvégezhető.

Az első módszer a Schematic Editor használatát feltételezi. Az automata mellé szükség
van az órajel generáló modulra, illetve a hétszegmenses kijelző dekódoló moduljára, hogy az
aktuális állapot értékét kijelezzük. A 10. ábra szemlélteti a kapcsolási rajzot.

Ábra 10. A Moore automata teszteléséhez készített áramkör kapcsolási rajza

Az x bemenetet kapcsolóra, a z kimenetet egy fénykibocsátó diódára (LED) kötjük. Az

MCLK az FPGA lap master clock B8-as portjára van kötve, míg a szegmensek(7:0) kimenetek
a hétszegmenses kijelző CA, CB … DP katódjait hajtják meg.

8
 A lábkiosztásra vonatkozó megkötéseket tartalmazó .ucf állomány tartalma itt található:

# clock pin for Basys2 Board

NET "mclk" LOC = "B8"; # Bank = 0, Signal name = MCLK

# Pin assignment for DispCtl

# Connected to Basys2 onBoard 7seg display
NET "szegmensek<7>" LOC = "L14"; # Bank = 1, Signal name = CA
NET "szegmensek<6>" LOC = "H12"; # Bank = 1, Signal name = CB
NET "szegmensek<5>" LOC = "N14"; # Bank = 1, Signal name = CC
NET "szegmensek<4>" LOC = "N11"; # Bank = 2, Signal name = CD
NET "szegmensek<3>" LOC = "P12"; # Bank = 2, Signal name = CE
NET "szegmensek<2>" LOC = "L13"; # Bank = 1, Signal name = CF
NET "szegmensek<1>" LOC = "M12"; # Bank = 1, Signal name = CG
NET "szegmensek<0>" LOC = "N13"; # Bank = 1, Signal name = DP

# Pin assignment for LEDs

NET "z" LOC = "G1" ; # Bank = 3, Signal name = LD7

# Pin assignment for SWs

NET "x" LOC = "N3"; # Bank = 2, Signal name = SW7

9
 A tesztelés második lehetősége a tesztáramkör strukturális leírásmódjának az
elkészítése. Ebben az esetben az órajel, a MOOREautomata és a hexdisplay vhdl modulokat
külső komponensként deklaráljuk és port map hívásokkal írjuk meg az áramkör felépítését. A
tesztmodul be és kimenetei megegyeznek a 10. ábrán látható kapcsolási rajz I/O Markerekkel
jelölt ki- és bemeneteivel.

entity struktMoore_top_module is
Port ( mclk : in STD_LOGIC;
x : in STD_LOGIC;
z : out STD_LOGIC;
szegmensek : out STD_LOGIC_VECTOR (7 downto 0));
end struktMoore_top_module;

architecture Behavioral of struktMoore_top_module is

--külső komponensek deklarálása
component orajel is
Port ( reset : in std_logic;
clk_in : in std_logic;
clk_out : out std_logic);
end component;

component MOOREautomata is
Port ( CLK : in STD_LOGIC;
x : in STD_LOGIC;
Q0 : out STD_LOGIC;
Q1 : out STD_LOGIC;
z : out STD_LOGIC);
end component;

component hexdisplay is
Port( A : in std_logic; --LSB
B : in std_logic;
C : in std_logic;
D : in std_logic;--MSB
szegm : out std_logic_vector(7 downto 0));
end component;

--segédváltozók deklarálása
signal ora, Q0, Q1 : std_logic;

begin
--külső komponens hívások
U1: orajel port map('1', mclk, ora);
U2: MOOREautomata port map(ora, x, Q0, Q1, z);
U3: hexdisplay port map(Q0, Q1, '0', '0', szegmensek);
end Behavioral;

10