VHDL alapú tervezés. (nem a teljes változat) Írta : Dr. Hidvégi Timót egyetemi docens

VHDL alapú tervezés (nem a teljes változat)

Írta : Dr. Hidvégi Timót egyetemi docens

Automatizálási Tanszék, Széchenyi István Egyetem

VHDL alapú tervezés

Dr. Hidvégi Timót

BEVEZETÉS ......................................................................................................................................................... 4 A VHDL NYELV MEGADÁSA .......................................................................................................................... 5 A VHDL NYELV ELEMEI .......................................................................................................................................... 5 Kommentek .......................................................................................................................................................... 5 Fentartott szavak ................................................................................................................................................. 5 Adattípusok.......................................................................................................................................................... 6 Azonosítók ........................................................................................................................................................... 7 Logikai operátorok.............................................................................................................................................. 7 Változók............................................................................................................................................................... 7 Jelek..................................................................................................................................................................... 8 Konstansok .......................................................................................................................................................... 8 A VHDL PROGAM SZERKEZETE ............................................................................................................................... 8 Entitás.................................................................................................................................................................. 9 Architektúra......................................................................................................................................................... 9 Komponens ........................................................................................................................................................ 10 Kombinációs áramkör ......................................................................................................................................................10 Multiplexer.......................................................................................................................................................................11

Csomagok (Package)......................................................................................................................................... 12 FELTÉTELES SZERKEZETEK..................................................................................................................................... 13 “IF” szerkezet ................................................................................................................................................... 13 “CASE” szerkezet.............................................................................................................................................. 14 BCD konverter .................................................................................................................................................................14 Shifter...............................................................................................................................................................................14

CIKLUSOK .............................................................................................................................................................. 15 Loop ciklus ........................................................................................................................................................ 15 While.................................................................................................................................................................. 15 For..................................................................................................................................................................... 16 Kilépés a ciklusból............................................................................................................................................. 16 “exit” utasítás ...................................................................................................................................................................16 “next” utasítás ..................................................................................................................................................................16

PROCESSZEK .......................................................................................................................................................... 16 PÉLDÁK .............................................................................................................................................................. 17 KOMBINÁCIÓS ÁRAMKÖRÖK .................................................................................................................................. 17 Aritmetikai egység ............................................................................................................................................. 17 Összeadók ........................................................................................................................................................................17 Teljes összeadó ................................................................................................................................................................18 8 bites összeadó................................................................................................................................................................18

Szorzók .............................................................................................................................................................. 19 Előjelnélküli szorzó..........................................................................................................................................................19 Baugh-Wooley szorzó ......................................................................................................................................................20

SORRENDI ÁRAMKÖRÖK ......................................................................................................................................... 26 Tárolók .............................................................................................................................................................. 26 SR tároló ..........................................................................................................................................................................26 JK tároló...........................................................................................................................................................................26 D tároló ............................................................................................................................................................................27 T tároló.............................................................................................................................................................................28

Kétfázisú órajel ................................................................................................................................................. 29 Regiszterek ........................................................................................................................................................ 30 Regiszter ..........................................................................................................................................................................30 Shiftregiszter ....................................................................................................................................................................31

Számláló ............................................................................................................................................................ 31 Előreszámláló...................................................................................................................................................................31 Előre/Hátraszámláló .........................................................................................................................................................32 Programozható számláló ..................................................................................................................................................32

ÁLLAPOTGÉPEK...................................................................................................................................................... 33 Moore FSM ....................................................................................................................................................... 33 Mealy FSM ........................................................................................................................................................ 34



Dr. Hidvégi Timót

MEMÓRIÁK ............................................................................................................................................................ 36 FIFO.................................................................................................................................................................. 36 RAM................................................................................................................................................................... 36 Egy adatbusz ....................................................................................................................................................................36 Két adatbusz.....................................................................................................................................................................36

ROM .................................................................................................................................................................. 37



Dr. Hidvégi Timót

Bevezetés A bonyolultabb digitális rendszereket nem schematic-kal vagy állapotgráfokkal írják le a tervezők, hanem különböző (hardver)leíró (Hardware Description Languages, HDL) nyelvekkel. Több ilyen nyelv is létezik,ilyen például a “Verilog”, a “VHDL” és a “SystemC”. Ebben a jegyzetben csak a “VHDL” (VHSIC Hardware Description Language) nyelvvel foglalkozunk. A VHDL nyelvet 1980-ban fejlesztették ki az USA kormányának megbízásából. 1986-ban szabványosították (IEEE 1076.1). Törekedtem arra, hogy olyan példákat közöljek, amelyek közvetlenül lefordíthatók az FPGA tervezőprogramokkal. Tekintettel arra, hogy léteznek olyan alaputasítások a VHDL nyelvben, amelyek a konkrét digitális áramkörök megvalósításánál nem használhatók, ezért ezek is bemutatásra kerülnek. Ilyen például az “after”. Fontos megjegyezni, hogy a VHDL technológiafüggetlen.

1. ábra Áramkörök tervezési menete

A VHDL hardverleírónyelv megértését, készségszintű alkalmazásának elsajátítását kívánja a szerző, Dr. Hidvégi Timót


Dr. Hidvégi Timót


A VHDL nyelv megadása

A VHDL nyelv elemei A VHDL programozási nyelvben megtaláljuk azokat az elemeket, amelyek más programozási nyelveb is előfordulnak. Most ezeket mutatjuk be. Kommentek Ha megjegyzéseket, olyan sorokat tennénk a VHDL utasításaink közé, amely nem a program szerves része, akkor az a “--” utasítással tudjuk megtenni. entity komment is port(D: in bit; Y: out bit); -- Definiáltuk az entitást end komment;

Fentartott szavak Vannak olyan szavak a VHDL nyelvben, amelyeket nem használhatunk változókként, mert ezek a szavak a VHDL nyelv részét képezik. Ezek a következők: abs architecture body constant entity generic label nand of package register signal units while

access array buffer disconnect exit guarded library new on port rem subtype until with

after assert bus downto file if linkage next open procedure report then use xor

alias attribute case else for in loop nor or process return to variable

all begin component elsif function inout map not others range select transport wait

and block configuration end generate is mod null out record severity type when

1993-ban tovább szabványosították a VHDL nyelvet, ekkor kerültek be a következő szavak: group reject sra

impure rol srl

inertial ror unaffected

literal shared xnor

postponed sla

pure sll



Dr. Hidvégi Timót

Adattípusok A VHDL nyelvben a “bit” és a “bit_vector” típusokat nem kell külön definiálni a VHDL nyelvben. SIGNAL A1 : bit; SIGNAL A2 : bit_vector(7 downto 0); A1 <= ‘1’; A2 <= ‘00110011’;

Látható ennél a kódrészletnél is, hogy a “bit_vector” egy egyszerű bit típus. Az “std_logic”-nak és az “std_logic_vector”-nak több értéke lehet, mint az előbb bemutatott típusoknak. Ezek a következők: • ‘0’ • ‘1’ • ‘Z’ • ‘-’ • ‘L’ • ‘H’ • ‘U’ • ‘X’ • ‘W’ Ennek a két típusnak az értékei nincsenek előre definiálva, ezért a következő sorok segítségével csatolni kell a VHDL programunkhoz. LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.ALL

Ha szeretnénk előjeles (signed) vagy előjel nélküli (unsigned) aritmetikát használni, akkor a következő sorokat is be kell írnunk a VHDL kódunk fejlécébe: USE IEEE.STD_LOGIC_SIGNED.ALL; USE IEEE.STD_LOGIC_UNSIGNED.ALL;

Ezekre láthatunk egy-egy példát: LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.ALL; SIGNAL A1 : STD_LOGIC; SIGNAL A2 : STD_LOGIC_VECTOR(7 downto 0); A1 <= ‘Z’; A2 <= ‘1101-’;


Dr. Hidvégi Timót


A következő típus az “integer” és a “real”. Ezzel tudunk megadni olyan objektumokat, amelyekkel aritmetikai műveleteket tudunk majd végezni. A “boolean”-nak két értéke lehet, ez a “true” és a “false”. A “type”-al tudunk különböző értékeket megadni egy változónak. Ezzel tudunk megadni például egy FSM-et. SIGNAL A1 : BOOLEAN; TYPE BYTE IS ARRAY(7 downto 0) of bit; -- Létrehozzuk a “byte” típust TYPE MEMORY_TYPE IS ARRAY(1 to 16) of byte; -- Definiáljuk a memóriát, mint -- tömböt SIGNAL MEMORY : MEMORY_TYPE; -- A “memory” változóhoz hozzárendeljük a 16 -- szavas, 8 bites memóriát MEMORY(4) <= ‘00110011’ -- A 4. memória címre 00110011-et írunk

TYPE state_type IS (s0, s1, s2, s3, s4); -- Megadjuk az FSM-nek 5 állapotát SIGNAL state: state_type; -- A “state” signalhoz hozzárendeljük -- az 5 állapotot

Azonosítók Az azonosítók olyan fenntartott szavak, amelyeket a felhasználó foglal le. Tartalmazhatnak számokat és betűket. Tartalmazhat még “_” karaktert is, a betűk és/vagy a számok között, de a változók végén nem állhat (“P_” hibás változónév). Viszont önálló karakterként jelenik meg, tehát a BIN_2 nem egyezik meg a BIN2-vel. Két vagy több “_” karakter nem lehet egymás mellett. A VHDL fordító érzéketlen a kis- és nagybetű használatára. Tehát a DF7A megegyezik a df7a-val vagy akár a Df7a-val. A változó nem kezdődhet számmal (hibás tehát pl.-ul a 3IN). Nem használhatunk speciális karaktereket (például: @) sem. Logikai operátorok Logikai Relációs Aritmetikai I. Aritmetikai II. Exp, abs, coml.

and = + + x xx

or /= / abs

nand < &

nor <=

mod not

rem

xor >

>=

Változók A változóknak az értékeit a kezdeti értékadás után megváltoztathatjuk. Ha a változónak nem adunk kezdeti értéket, akkor az adott típus legkisebb értékét veszi fel. Ha adunk értéket, akkor az azonnal kiértékelődik. variable azonosító : típus; variable p1 : integer;



Dr. Hidvégi Timót

variable busz : bit_vector(15 downto 0); summa := a + b + c; replusz := (R1 * R2)/(R1 + R2)

Jelek A jelek változókként viselkednek, de a szerepük az, hogy az egyes programrészeletek között továbbítsák az információt. A VHDL szimulátor minden jelhez egy naplót rendel. Ezáltal minden jelnek lesz múltja, jelene és jövője. A múlt nem csak egy konkrét érték lehet, hanem egy “jóslat” is. signal azonosító : típus signal p1 : bit; signal busz2 : bit_vector(7 downto 0);

Konstansok A konstansok értékének megadása után azok már nem változtathatók. constant azonosító : típus; constant i : integer := 23;

A VHDL progam szerkezete Egy áramkör VHDL leírása két, jól elkülöníthető részből, az entitásból és az architektúrális leírásból áll (1. ábra). Logikai áramkör

Entitás

Architektúra

Strukturális

Viselkedési

1. ábra A VHDL nyelv felépítése

Az architektúrális leírás tovább csoportosítható. Ez lehet viselkedési vagy strukturális. A viselkedési modell a rendszer funkcionális leírását adja meg. Ezt a modellt a “processek” alkotják, amelyek működése bármikor felfüggeszthetők. Ezek a processek konkurensek.



Dr. Hidvégi Timót

A strukturális modell segítségével kapuszinten tudjuk megadni az áramkörünket. Ezzel a megadási móddal hiearchikusan tudjuk az áramkörünket felépíteni. A digitális áramkörök általában hiearchikusan épülnek fel. Ezek a hiearchikusan elhelyezkedő modulok az entitások. A VHDL kód két részletre, az entitásra és az architektúrális leírásra osztható. Az entitásban megadjuk a megvalósítandó áramkör bemeneteit és a kimeneteit. Az architektúrális programrészletben az áramkör működését találjuk meg. Entitás Az entitás felépítése a következő : entity NÉV is generic (konstansok); port( bemenet neve : bemenet típusa; kimenet neve : kimenet típusa); end NÉV; A generic-nél olyan konstansokat tudunk megadni, amelyet az adott modul vezérlésénél, leírásánál használhatunk (pl.: hány bites a bemeneti adatbusz, stb.). A portoknál adjuk meg a modul bemeneteit és kimeneteit. entity pelda1 is generic (kesleltetes := 10 ns); port(A, B, Cin : in bit; S, Cout : out bit); end pelda1;

entity szamlalo is generic (szelesseg := 16); port(D : in bit_vector (szelesseg-1 downto 0); CLK, EN : in bit; S : out bit_vector (szelesseg-1 downto 0)); end szamlalo;

Architektúra A VHDL program architektúrális megadása függ attól, hogy milyen megadási módot használunk. Viselkedési leírás használatakor a szintaktis a következő: ARCHITECTURE architektúra-neve OF entitás-neve IS jelek deklarációja folyamatok definíciója függvények definíciója BEGIN processek leírások END architektúra-neve;



Dr. Hidvégi Timót

Ha strukturális megadást használunk, akkor a szintaktis a következő: ARCHITECTURE architektúra-név OF entitás-neve IS komponensek megadása jelek deklarációja BEGIN instance név: PORT MAP név leírások END architektúra-neve; Egy entitásnak több architektúrális megadása lehet.

Komponens Olyan modul, amelyeket más modulok felhasználhatnak az architektúra megadásához. Ahhoz, hogy a komponenseket tudjuk használni, deklarálni kell az “architecture” deklarációs részében. Ezután a komponens bementeit/kimeneteit megfeleltetjük az adott modul jeleinek, interfészeinek. component azonosító generic lista; port lista; end component; component count1 GENERIC (m : integer := 7); Port ( DCOUNT : in std_logic_vector(m downto 0); CLK : in std_logic; CLR : in std_logic; QCOUNT : out std_logic_vector(m downto 0)); end component;

Kombinációs áramkör Nézzük meg ezeket az egységeket részletesebben egy példa segítségével! Legyen egy egyszerű példánk, valósítsük meg a következő kombinációs áramkört megadó “F” függvényt!

F = AB + CD

Az entitás megadja a VHDL fordító számára, hogy az áramkör “dobozának” van négy bemenete (A, B, C, D) és egy kimenete (F). De azt már nem adja meg, hogy milyen egyenlet írja le a megvalósítandó logikai áramkört. Ezt az architektúrális leírással tudjuk megtenni.


A

A

B

B C

Dr. Hidvégi Timót


& 1

F

D

C D

F

&

2. ábra Az “F” függvényt megvalósító doboz (entitás) és a kapcsolási rajza (architektúrális megadása)

Látható volt az 1. ábrán, hogy az architektúrális megadásnak két változata van. A strukturális megadásnál “alkatrésszinten” (kapu- vagy tranzisztorszinten) adjuk meg az áramkörünk működési egyenletét. Tehát a konkrét áramkört írjuk le ebben a megadási módban. A viselkedési leírásnál viszont olyan programot írunk, amely nem a konkrét megvalósítandó áramkör egyenletét tartalmazza, hanem egy olyan eljárást, amely nem a logikai egenletet tartalmazza, hanem egy eljárást, amelynek a kimenete megegyezik a megvalósítandó függvény kimenetével. Nézzük meg ezeket a VHDL kódokat! Az első VHDL kód strukturális, felismerhetők a kombinációs áramkör építőelemei. entity fpelda is port (A, B, C, D : in bit; F : out bit); end fpelda; architecture struct of fpelda is begin F <= (A and B) or (C and not(D)); end struct;

A következő VHDL kód a viselkedési leírást tükrözi. entity fpeldav is port (A, B, C, D : in bit; F : out bit); end fpeldav; architecture viselk of fpeldav is begin process(A,B,C,D) begin if ((A=‘1’ and B=‘1’ and C=‘1’ and D=‘0’) then F <= ‘1’; else F <= ‘0’; end if; end process; end viselk;

Multiplexer Nézzük meg egy kétbemenetű multiplexer megadási módjait is. A multiplexer bemenetei: A0, A1, a kiválasztójel: v, a kimenet pedig az Y.



Dr. Hidvégi Timót

entity multip2 is port(A0, A1, v: in bit; Y: out bit); end multip2; arhitecture structural of multip2 is begin Y <= (A0 and not(v)) or (A1 and v); end structural; arhitecture viselkedes of multip2 is begin Y <= A0 when v = '0' else A1; end viselkedes;

Látható ennél az egyszerű példánál, hogy egy VHDL-es kódnál lehet több architecture rész is, de az entity csak egyszer fordulhat elő. Csomagok (Package) Az architektúra csak azokat az objektumokat láthatja, amelyeket az architektúrához tartozó entitásban definiáltak. Ha olyan objektumokat szeretnénk használni, amelyeket nem definiáltunk az entitásban, akkor csomagokat kell használnunk. A csomagok azokat a deklarációkat tartalmazzák, amelyeket a felhasználók írtak. A csomagokat nem tudjuk önállóan futtatni. A csomagoknak két része van, a deklarációs rész és a törzs. A csomagok törzse tartalmazza a különböző függvények és procedúrák implementációját, amelyeket a a csomag deklarációs részében adtak meg. Nézzük meg egy csomagnak a szintaktisát! PACKAGE package-név IS típus deklaráció; altípus deklaráció; jel deklaráció; változó deklaráció; konstans deklaráció; komponens deklaráció; függvény deklaráció; procedure deklaráció; END package-név; PACKAGE BODY package-név IS függvény definíció procedure definíció END package-név; Ha szeretnénk használni egy csomagot, akkor a “library” és a “use” utasítások segítségével hívhatjuk meg a szükséges csomagot. Erre láthatunk itt egy egyszerű példát: library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL;



Dr. Hidvégi Timót

Példaként nézzünk meg egy ROM típusú memóriát. use work.ROMS.all; entity ROM_5x8 is port(ADDR: in ROM_RANGE; DATA: out ROM_WORD); end ROM_5x8; architecture BEHAVIOR of ROM_5x8 is begin DATA <= ROM(ADDR); -- Olvasunk a memóriából end BEHAVIOR;

Feltételes szerkezetek A VHDL nyelvben a feltételes utasításoknak két csoportja létezik,az “if” és a “case”. Nézzük át ezeket! “IF” szerkezet A feltételnek boolean-nak kell lenni. Ha a feltétel igaz, akkor az “if” után álló valamennyi utasítás végrehajtódik. Ha hamis, akkor a vezérlés a következő feltételre ugrik. IF feltétel1 THEN utasítások1 ELSE utasítások2 END IF;

IF feltétel1 THEN utasítások ELSIF feltétel2 THEN utasítások ELSIF feltétel3 THEN ...... ELSE feltételn END IF;

Az “IF” szerkezetre láthatunk egy példát, ahol egy “D” flip-flopot valósítunk meg. entity dff is PORT (D, clk, enable, set, clear: in bit; Q: OUT bit); end dff; architecture viselk of dff is begin process(clk,set,clear) begin if (set = '1') then Q <= '1'; elsif (clear = '1') then Q <= '0'; elsif (enable = '0' ) then null; elsif (clk'event and clk = '1') then Q <= D; end if; end process;



Dr. Hidvégi Timót

end viselk;

A “null” utasításnak nincs semmilyen hatása. A megvalósított “D” flip-flop aszinkron törléssel és beírással rendelkezik, hiszen órajelvizsgálatot nem csinálunk, amikor a “set” és a “clear” jelek állapotait vizsgáljuk. “CASE” szerkezet Egyetlen választás sem lehet kétszer. Ha nem állítjuk fel az összes választási lehetőséget, akkor a kimaradt lehetőségeket az “others” szóval tudjuk egybefogni. CASE expression IS WHEN chices => sequential-statements; WHEN chices => sequential-statements; ..... WHEN OTHERS => sequential-statements; end CASE;

BCD konverter A “CASE” szerkezettel megvalósítottunk egy BCD/hétszegmenses konvertert. Látható, egyszerűbb a viselkedési leírás használata, mint a strukturálisé, hiszen nem kell felírni és egyszerűsíteni a különböző szegmensek egyenleteit. entity bcd is PORT ( I: in bit_vector (3 downto 0); S: out bit_vector (1 to 7)); end bcd; architecture viselk of begin process(I) begin case I is when when when when when when when when when when when end case; end process; end viselk;

bcd is

Shifter entity shifter is port(

"0000" "0001" "0010" "0011" "0100" "0101" "0110" "0111" "1000" "1001" others

=> => => => => => => => => => =>

S S S S S S S S S S S

<= <= <= <= <= <= <= <= <= <= <=

"1111110"; "0110000"; "1101101"; "1111001"; "0110011"; "1011011"; "1011111"; "1110000"; "1111111"; "1110011"; "0000000";



Dr. Hidvégi Timót

SEL: in bit_vector(1 downto 0); INSH: in bit_vector(7 downto 0); OUTPUT: out bit_vector(7 downto 0)); end shifter; architecture behav of shifter is begin process(SEL, INSH) begin case SEL IS when "00" => OUTPUT <= INSH(0) & INSH(7 downto 1); when "11" => OUTPUT <= INSH(6 downto 0) & INSH(7); when others => OUTPUT <= INSH; end case; end PROCESS; end behav;

Ciklusok A VHDL-ben három különböző ciklust használhatunk. Ezek a következők: loop, while, for. Loop ciklus A loop ciklus egy feltétel nélküli hurok. Addig tartózkodunk a cikluban, amíg a “next” vagy az “exit” utasítást nem használjuk. cimke: loop utasítások end loop cimke kivonas: loop s := s – a; end loop kivonas;

While A while ciklus magja addig hajtódik végre, amíg a feltétel igaz. címke: while feltétel loop utasítások end loop címke; kivonas: while (s /= 1) loop s := s – a; end loop kivonas;



Dr. Hidvégi Timót

For A for ciklus egy adott iterációt hajt végre a ciklus magjában. címke: for ciklusváltozó in tartomány utasítások end loop címke; kivonas for i in 1 to 5 loop s := s -5; end loop kivonas;

Kilépés a ciklusból Vannak olyan utasítások, amelyek segítségével a ciklusból ki tudunk lépni. Ez különösen a loop ciklusnál használható. Ha a “címke”-t elhagyjuk, akkor az aktuális ciklusból lépünk ki. A két kilépési lehetőség közös tulajdonsága, hogy a kilépés feltételhez köthető. “exit” utasítás Leállítja a ciklust, a vezérlés a ciklust követő utasításra kerül. exit címke when feltétel;

“next” utasítás A vezérlés a ciklus elejére kerül. next címke when feltétel;

Processzek A “process” szekvenciális programrész, amely a többi process-szel párhuzamosan fut. A szintaktisa a következő: címke: process (szenzitív lista) deklarációs lista; begin utasítások;



Dr. Hidvégi Timót

end process címke; A “begin” és az “end process” között lévő utasítások ciklikusan ismétlődnek. Az utasítások végrehajtása felfüggesztésre kerül, ha kiadjuk a “wait” utasítást. A folyamat addig áll, amíg egy adott esemény be nem következik. Ezt az eseményt a “wait”-nél állíthatjuk be. Ha nem adunk meg kifejezést, akkor a folyamat nem indul újra, végtelenségig várakozik. wait szenzitív lista vagy logikai feltétel vagy adott idő eltelte szenzitív lista : Addig várakozunk, amíg az adott jel értéke megváltozik. wait on CLK;

wait on RST, CLK, SET;

logikai feltétel : wait until RST = ‘1’; adott ideig : wait for 20 ns;

Példák Ebben a fejezetben néhány példa segítségével átismetéljük az előző fejezetek anyagát. Először bemutatunk egy 8 bites soros összeadót, amelyet teljes összeadókból építünk fel. Az összeadó felbontását könnyen megtudjuk változtatni. Kombinációs áramkörök Ebben a fejezetben azok a különböző alapáramkörök szerepelnek, amelyek nem tartalmaznak tárolóelemeket. Aritmetikai egység A digitális áramkörtervezésben, architektúrák készítésénél szinte elengedhetetlen az aritmetikai egységek használata. Ezért kapott szerepet ebben a jegyzetben. Bemutatásra kerül a teljes összeadó, a soros és a párhuzamos képzésű összeadó is rövid elméleti háttérrel. Összeadók Első lépésben az egybites teljesösszeadó kerül bemutatásra. Látható lesz, hogy ez az egység az aritmetikai egységeknél szinte elengedhetetlen, még a szórzómodult is ennek segítségével építjük fel.


Dr. Hidvégi Timót


Teljes összeadó A 8 bites összeadó egybites teljes összeadóból épül fel, amelynek a kapcsolási rajza az 3. ábrán látható. Ai =1

Bi

Si

=1

Ci

&

&

&

Ci+1

3. ábra A teljes összeadó

A teljes összeadó VHDL kódja a következő: entity fa1 is Port ( A, B, CIN : in bit; S, COUT : out bit); end fa1; architecture Behavioral of fa1 is begin S <= A XOR B XOR CIN; COUT <= (A AND B) OR (A AND CIN) OR (B AND CIN); end Behavioral;

A szimulációs eredmény az 4. ábrán látható.

4. ábra A teljes összeadószimulációs eredménye

8 bites összeadó A 8 bites összeadó VHDL kódjában megtalálható a teljes összeadó componensként. Látható tehát az, hogy a 8 bites összeadót hiearchikusan építettük fel.



Dr. Hidvégi Timót

entity add8bit is port ( A, B : in bit_vector(7 downto 0); CIN : in bit; S : out bit_vector(7 downto 0); COUT : out bit); end add8bit; architecture structural of add8bit is component fa1 Port ( A, B, CIN : in bit; S, COUT : out bit); end component; signal carry : bit_vector(8 downto 0); begin carry(0) <= CIN; add8: for i in 0 to 7 generate FA: fa1 port map (A(i), B(i), carry(i), S(i), carry(i+1)); end generate add8; COUT <= carry(8); end structural;

A nyolcbites összeadó szimulációjának az eredménye látható az 5. ábrán.

5. ábra A 8bites összeadó szimulációja

Szorzók Az aritmetikai egységek másik fontos eleme a szorzó. Ebben a jegyzetben csak a tömbszorzók megvalósítását nézzük át. Több tömbszorzótípus is létezik. Előjelnélküli szorzó Első esetben egy egyszerű szorzómegvalósítást nézzük meg. A szorzót, amelynek két négybites bemenete van, viselkedési leírással adjuk meg. library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL;


Dr. Hidvégi Timót


use IEEE.STD_LOGIC_UNSIGNED.ALL; entity szorzo1 is port(A, B : in std_logic_vector(3 downto 0); P : out std_logic_vector(7 downto 0)); end szorzo1; architecture viselk of szorzo1 is begin P <= A * B; end viselk;

A szorzó működését szimuláltuk, ennek eredménye látható az 6. ábrán.

6. ábra A szorzó szimlációja

Baugh-Wooley szorzó A Baugh-Wooley szorzó kettes komplemesű szorzó, amelynek a kapcsolási rajzát mutatja az 7. ábra. an-1 b0

an-2 b2

. . .

an-2 b3

a3 b3

. . .

an-1 bn-3

an-1

1

bn-1

.

an-2 bn-2

an-1 b2

an-1bn-1

.

.

. .

.

a3bn-1

. . .

0

a 2 b0

0

a 2 b1

a 1 b1

a 3 b2

a 2 b2

a1 b2

a 0 b2

a 2 b3

a 1 b3

a0 b3

. .

a3 bn-2

a2 bn-2

a1 bn-2

a2bn-1

a1bn-1

a0bn-1

.

a1 b0

0

a 0 b0

a 0 b1

.

a0 bn-2

. . .

an-2bn-1

a 3 b0

a 3 b1

. . .

an-1 b2

.

0

an-2 b1

an-1 b1

.

a 4 b0

0

an-1 bn-1

. . .

. . . P2n-1 P2n-2

P2n-3

. . . Pn+3

Pn+2

Pn+1

Pn

P3

P2

7. ábra A Baugh-Wooley szorzó kapcsolási rajza

A strukturális VHDL kódja a következő:

P1

P0



Dr. Hidvégi Timót

library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; -- Uncomment the following lines to use the declarations that are -- provided for instantiating Xilinx primitive components. --library UNISIM; --use UNISIM.VComponents.all; -- 8 bites Baugh-Wooley szorzó -- Készítette : Hidvégi Timót entity bw8x8 is Port ( AM : in std_logic_vector(7 downto 0); BM : in std_logic_vector(7 downto 0); P : out std_logic_vector(15 downto 0)); end bw8x8; architecture Behavioral of bw8x8 is component fa1 port (A, B, CIN : in std_logic; S, COUT : out std_logic); end component; signal CQ11,CQ12,CQ13,CQ14,CQ15,CQ16,CQ17, CQ21,CQ22,CQ23,CQ24,CQ25,CQ26,CQ27, CQ31,CQ32,CQ33,CQ34,CQ35,CQ36,CQ37, CQ41,CQ42,CQ43,CQ44,CQ45,CQ46,CQ47, CQ51,CQ52,CQ53,CQ54,CQ55,CQ56,CQ57, CQ61,CQ62,CQ63,CQ64,CQ65,CQ66,CQ67, CQ71,CQ72,CQ73,CQ74,CQ75,CQ76,CQ77,CQ78, CQ81,CQ82,CQ83,CQ84,CQ85,CQ86,CQ87,CQ88,CQ89, PS11,PS12,PS13,PS14,PS15,PS16,PS17, PS21,PS22,PS23,PS24,PS25,PS26,PS27, PS31,PS32,PS33,PS34,PS35,PS36,PS37, PS41,PS42,PS43,PS44,PS45,PS46,PS47, PS51,PS52,PS53,PS54,PS55,PS56,PS57, PS61,PS62,PS63,PS64,PS65,PS66,PS67, PS71,PS72,PS73,PS74,PS75,PS76,PS77,PS78, A7B7,A7,B7,NA7,NB7, A0B0,A1B0,A2B0,A3B0,A4B0,A5B0,A6B0,A7NB0, A0B1,A1B1,A2B1,A3B1,A4B1,A5B1,A6B1,A7NB1, A0B2,A1B2,A2B2,A3B2,A4B2,A5B2,A6B2,A7NB2, A0B3,A1B3,A2B3,A3B3,A4B3,A5B3,A6B3,A7NB3, A0B4,A1B4,A2B4,A3B4,A4B4,A5B4,A6B4,A7NB4, A0B5,A1B5,A2B5,A3B5,A4B5,A5B5,A6B5,A7NB5, A0B6,A1B6,A2B6,A3B6,A4B6,A5B6,A6B6,A7NB6, NA0B7,NA1B7,NA2B7,NA3B7,NA4B7,NA5B7,NA6B7 : std_logic; begin A0B0 <= AM(0) AND BM(0); A1B0 <= AM(1) AND BM(0); A2B0 <= AM(2) AND BM(0); A3B0 <= AM(3) AND BM(0); A4B0 <= AM(4) AND BM(0); A5B0 <= AM(5) AND BM(0); A6B0 <= AM(6) AND BM(0); A7NB0 <= AM(7) AND NOT BM(0);



A0B1 <= AM(0) AND BM(1); A1B1 <= AM(1) AND BM(1); A2B1 <= AM(2) AND BM(1); A3B1 <= AM(3) AND BM(1); A4B1 <= AM(4) AND BM(1); A5B1 <= AM(5) AND BM(1); A6B1 <= AM(6) AND BM(1); A7NB1 <= AM(7) AND NOT BM(1); A0B2 <= AM(0) A1B2 <= AM(1) A2B2 <= AM(2) A3B2 <= AM(3) A4B2 <= AM(4) A5B2 <= AM(5) A6B2 <= AM(5) A7NB2 <=AM(6)

AND AND AND AND AND AND AND AND

BM(2); BM(2); BM(2); BM(2); BM(2); BM(2); BM(2); NOT BM(2);

A0B3 <= AM(0) AND BM(3); A1B3 <= AM(1) AND BM(3); A2B3 <= AM(2) AND BM(3); A3B3 <= AM(3) AND BM(3); A4B3 <= AM(4) AND BM(3); A5B3 <= AM(5) AND BM(3); A6B3 <= AM(5) AND BM(3); A7NB3 <= AM(6) AND NOT BM(3); A0B4 <= AM(0) AND BM(4); A1B4 <= AM(1) AND BM(4); A2B4 <= AM(2) AND BM(4); A3B4 <= AM(3) AND BM(4); A4B4 <= AM(4) AND BM(4); A5B4 <= AM(5) AND BM(4); A6B4 <= AM(5) AND BM(4); A7NB4 <= AM(6) AND NOT BM(4); A0B5 <= AM(0) AND BM(5); A1B5 <= AM(1) AND BM(5); A2B5 <= AM(2) AND BM(5); A3B5 <= AM(3) AND BM(5); A4B5 <= AM(4) AND BM(5); A5B5 <= AM(5) AND BM(5); A6B5 <= AM(5) AND BM(5); A7NB5 <= AM(6) AND NOT BM(5); A0B6 <= AM(0) AND BM(6); A1B6 <= AM(1) AND BM(6); A2B6 <= AM(2) AND BM(6); A3B6 <= AM(3) AND BM(6); A4B6 <= AM(4) AND BM(6); A5B6 <= AM(5) AND BM(6); A6B6 <= AM(5) AND BM(6); A7NB6 <= AM(6) AND NOT BM(6); NA0B7 <= NOT AM(0) AND BM(7); NA1B7 <= NOT AM(1) AND BM(7); NA2B7 <= NOT AM(2) AND BM(7); NA3B7 <= NOT AM(3) AND BM(7); NA4B7 <= NOT AM(4) AND BM(7); NA5B7 <= NOT AM(5) AND BM(7); NA6B7 <= NOT AM(5) AND BM(7); --A7NB7 <= NOT AM(6) AND NOT BM(7); NA7 <= NOT A7;

Dr. Hidvégi Timót



Dr. Hidvégi Timót

NB7 <= NOT B7; P(0) <= AM(0) AND BM(0); -- Elso full-adder sor fa11: fa1 port map (A => A1B0,B => A0B1,CIN => '0',S => P(1),COUT => CQ11); fa12: fa1 port map (A => A2B0,B => A1B1,CIN => '0',S => PS12,COUT => CQ12); fa13: fa1 port map (A => A3B0,B => A2B1,CIN => '0',S => PS13,COUT => CQ13); fa14: fa1 port map (A => A4B0,B => A3B1,CIN => '0',S => PS14,COUT => CQ14); fa15: fa1 port map (A => A5B0,B => A4B1,CIN => '0',S => PS15,COUT => CQ15); fa16: fa1 port map (A => A6B0,B => A5B1,CIN => '0',S => PS16,COUT => CQ16); fa17: fa1 port map (A => A7NB0,B => A6B1,CIN => '0',S => PS17,COUT => CQ17); -- Masodik full-adder sor fa21: fa1 port map (A => PS12,B => A0B2,CIN => CQ11,S => P(2),COUT => CQ21); fa22: fa1 port map (A => PS13,B => A1B2,CIN => CQ12,S => PS22,COUT => CQ22); fa23: fa1 port map (A => PS14,B => A2B2,CIN => CQ13,S => PS23,COUT => CQ23); fa24: fa1 port map (A => PS15,B => A3B2,CIN => CQ14,S => PS24,COUT => CQ24); fa25: fa1 port map (A => PS16,B => A4B2,CIN => CQ15,S => PS25,COUT => CQ25); fa26: fa1 port map (A => PS17,B => A5B2,CIN => CQ16,S => PS26,COUT => CQ26); fa27: fa1 port map (A => A7NB1,B => A6B2,CIN => CQ17,S => PS27,COUT => CQ27); -- Harmadik full-adder sor fa31: fa1 port map (A => PS22,B => A0B3,CIN => CQ21,S => P(3),COUT => CQ31); fa32: fa1 port map (A => PS23,B => A1B3,CIN => CQ22,S => PS32,COUT => CQ32); fa33: fa1 port map (A => PS24,B => A2B3,CIN => CQ23,S => PS33,COUT => CQ33); fa34: fa1 port map (A => PS25,B => A3B3,CIN => CQ24,S => PS34,COUT => CQ34);



Dr. Hidvégi Timót

fa35: fa1 port map (A => PS26,B => A4B3,CIN => CQ25,S => PS35,COUT => CQ35); fa36: fa1 port map (A => PS27,B => A5B3,CIN => CQ26,S => PS36,COUT => CQ36); fa37: fa1 port map (A => A7NB2,B => A6B3,CIN => CQ27,S => PS37,COUT => CQ37); -- Negyedik full-adder sor fa41: fa1 port map (A => PS32,B => A0B4,CIN => CQ31,S => P(4),COUT => CQ41); fa42: fa1 port map (A => PS33,B => A1B4,CIN => CQ32,S => PS42,COUT => CQ42); fa43: fa1 port map (A => PS34,B => A2B4,CIN => CQ33,S => PS43,COUT => CQ43); fa44: fa1 port map (A => PS35,B => A3B4,CIN => CQ34,S => PS44,COUT => CQ44); fa45: fa1 port map (A => PS36,B => A4B4,CIN => CQ35,S => PS45,COUT => CQ45); fa46: fa1 port map (A => PS37,B => A5B4,CIN => CQ36,S => PS46,COUT => CQ46); fa47: fa1 port map (A => A7NB3,B => A6B4,CIN => CQ37,S => PS47,COUT => CQ47); -- Otodik full-adder sor fa51: fa1 port map (A => PS42,B => A0B5,CIN => CQ41,S => P(5),COUT => CQ51); fa52: fa1 port map (A => PS43,B => A1B5,CIN => CQ42,S => PS52,COUT => CQ52); fa53: fa1 port map (A => PS44,B => A2B5,CIN => CQ43,S => PS53,COUT => CQ53); fa54: fa1 port map (A => PS45,B => A3B5,CIN => CQ44,S => PS54,COUT => CQ54); fa55: fa1 port map (A => PS46,B => A4B5,CIN => CQ45,S => PS55,COUT => CQ55); fa56: fa1 port map (A => PS47,B => A5B5,CIN => CQ46,S => PS56,COUT => CQ56); fa57: fa1 port map (A => A7NB4,B => A6B5,CIN => CQ47,S => PS57,COUT => CQ57); -- Hatodik full-adder sor fa61: fa1 port map (A => PS52,B => A0B6,CIN => CQ51,S => P(6),COUT => CQ61); fa62: fa1 port map (A => PS53,B => A1B6,CIN => CQ52,S => PS62,COUT => CQ62); fa63: fa1



Dr. Hidvégi Timót

port map (A => PS54,B => A2B6,CIN => CQ53,S => PS63,COUT => CQ63); fa64: fa1 port map (A => PS55,B => A3B6,CIN => CQ54,S => PS64,COUT => CQ64); fa65: fa1 port map (A => PS56,B => A4B6,CIN => CQ55,S => PS65,COUT => CQ65); fa66: fa1 port map (A => PS57,B => A5B6,CIN => CQ56,S => PS66,COUT => CQ66); fa67: fa1 port map (A => A7NB5,B => A6B6,CIN => CQ57,S => PS67,COUT => CQ67); -- Hetedik full-adder sor fa71: fa1 port map (A => PS62,B => NA0B7,CIN => CQ61,S => PS71,COUT => CQ71); fa72: fa1 port map (A => PS63,B => NA1B7,CIN => CQ62,S => PS72,COUT => CQ72); fa73: fa1 port map (A => PS64,B => NA2B7,CIN => CQ63,S => PS73,COUT => CQ73); fa74: fa1 port map (A => PS65,B => NA3B7,CIN => CQ64,S => PS74,COUT => CQ74); fa75: fa1 port map (A => PS66,B => NA4B7,CIN => CQ65,S => PS75,COUT => CQ75); fa76: fa1 port map (A => PS67,B => NA5B7,CIN => CQ66,S => PS76,COUT => CQ76); fa77: fa1 port map (A => A7NB6,B => NA6B7,CIN => CQ67,S => PS77,COUT => CQ77); -- Plussz meg egy Full Adder a hetedik sorban fa78: fa1 port map (A => NA7,B => A7B7,CIN => NB7,S => PS78,COUT => CQ78); -- Nyolcadik full-adder sor fa81: fa1 port map (A => PS71,B => B7,CIN => A7,S => P(7),COUT => CQ81); fa82: fa1 port map (A => PS72,B => CQ81,CIN => CQ71,S => P(8),COUT => CQ82); fa83: fa1 port map (A => PS73,B => CQ82,CIN => CQ72,S => P(9),COUT => CQ83); fa84: fa1 port map (A => PS74,B => CQ83,CIN => CQ73,S => P(10),COUT => CQ84); fa85: fa1 port map (A => PS75,B => CQ84,CIN => CQ74,S => P(11),COUT => CQ85); fa86: fa1 port map (A => PS76,B => CQ85,CIN => CQ75,S => P(12),COUT => CQ86); fa87: fa1 port map (A => PS77,B => CQ86,CIN => CQ76,S => P(13),COUT => CQ87);



Dr. Hidvégi Timót

fa88: fa1 port map (A => PS78,B => CQ87,CIN => CQ77,S => P(14),COUT => CQ88); fa89: fa1 port map (A => '1',B => CQ88,CIN => CQ78,S => P(15),COUT => CQ89); end Behavioral;

Sorrendi áramkörök

Tárolók Ebben a fejezetben kerülnek bemutatásra a különböző tárolók VHDL leírásai. SR tároló Az SR tároló olyan elektronikai elem, amelynek két bemenete (S,R) van. A tároló igazságtáblázata a következő (XX. táblázat):

A VHDL kód: entity sr is port( S, R : in bit; Q : out bit); end sr; architecture viselk of sr is signal QF : bit; begin process begin if (S='1') and (R='0') then QF <= '1'; elsif (S='0') and (R='1') then QF <= '0'; elsif (S='0') and (R='0') then null; end if; Q <= QF; end process; end viselk;

JK tároló



Dr. Hidvégi Timót

A JK tároló olyan szinkron flip-flop, amelynek nincsen tiltott állapota. Az igazságtáblázata a következő (XX. táblázat):

entity jkff is port( j, k, clk, reset : in bit; q : out bit); end jkff; architecture viselk of jkff is signal ff : bit; begin process(clk, reset) begin if (reset = '0') then ff <= '0'; elsif (clk'event and clk = '1') then if (j='1') and (k='1') then ff <= not ff; elsif (j='1') and (k='0') then ff <= '1'; elsif (j='0') and (k='1') then ff <= '0'; end if; q <= ff; end if; end process; end viselk;

D tároló A”D” tároló igazságtáblázata (XX. táblázat) után találjuk a VHDL kódot (dff4). Az “RST bemeneti jel szinkron törlést valósít meg.

XX. táblázat “D” tároló

entity dff4 is port (



D, CLK, RST: in bit; Q: out bit); end dff4; architecture viselk of dff4 is begin process(CLK) begin if CLK'event and CLK='1' and RST='0' then Q <= D; elsif CLK'event and CLK='1' and RST='1' then Q <= '0'; end if; end process; end viselk;

XX. ábra

T tároló

XX. táblázat “T” tároló

entity tff is port ( D, CLK, RST: in bit; Q: out bit); end tff; architecture viselk of tff is begin process(CLK) begin if CLK'event and CLK='1' and RST='0' then Q <= not(D); elsif CLK'event and CLK='1' and RST='1' then Q <= '0'; end if; end process; end viselk;

Dr. Hidvégi Timót



Dr. Hidvégi Timót

Kétfázisú órajel Egy órajelből állítunk elő egy kétfázisú órajelet. library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity orajel2 is port(SWD, CLKBRD : in std_logic; CLKPHS1, PHS2, SEGED1 : out std_logic); end orajel2; architecture Behavioral of orajel2 is type state_type IS (t0, t1); signal state: state_type; begin next_state_logic: process(CLKBRD) begin if (CLKBRD'EVENT and CLKBRD = '1' and SWD = '1' and state = t0) then state <= t1; elsif (CLKBRD'EVENT and CLKBRD = '1' and SWD = '1' and state = t1) then state <= t0; else null; end if; end process; output_logic: process (state) begin case state is when t0 => CLKPHS1 <= '1'; PHS2 <= '0'; SEGED1 <= '0'; when t1 => CLKPHS1 <= '0'; PHS2 <= '1'; SEGED1 <= '1'; end case; end process; end;



Dr. Hidvégi Timót

XX. ábra A szimulációs eredmény

Regiszterek

Regiszter A következő VHDL kód egy nyolcbites regisztert ír le. entity reg8 is port (DIN : in bit_vector(7 downto 0); CLK, RST, ENG : in bit; QOUT : out bit_vector(7 downto 0)); end reg8; architecture viselk of reg8 is begin process(CLK,RST) begin if (CLK’event and CLK=’1’ and RST=’1’) then QOUT <= “00000000”; elsif (CLK’event and CLK=’1’ and RST=’0’) then QOUT <= DIN; end if; end process; end viselk;

A következő VHDL kód is egy nyolcbites regisztert ír le, de nem “IF”-es szerkezettel készült el a kód, hanem a “dff4” nevű “D” tároló leírását adjuk meg komponensként. Ezt a komponenst egy “FOR” ciklussal nyolcszor hivatkozzuk meg. entity reg8x2 is port ( D : in bit_vector(7 downto 0); CLK, RST : in bit; Q : out bit_vector(7 downto 0)); end reg8x2; architecture structural of reg8x2 is component dff4 Port ( D, CLK, RST : in bit; Q : out bit); end component; begin reg1: FOR i in 0 to 7 generate dff: dff4 port map (D(i), CLK, RST, Q(i)); end generate reg1; end structural;



Dr. Hidvégi Timót

Shiftregiszter A shift regiszter leírásakor szintén a “dff4” nevű “D” tárolót használjuk fel. entity shiftreg is port ( D : in bit; CLK, RST : in bit; Q : out bit_vector(7 downto 0)); end shiftreg; architecture structural of shiftreg is component dff4 Port ( D, CLK, RST : in bit; Q : out bit); end component; signal S : bit_vector(7 downto 0); begin dff0: dff4 port map (D, CLK, RST, S(0)); reg1: FOR i in 1 to 7 generate dff: dff4 port map (S(i-1), CLK, RST, S(i)); end generate reg1; Q <= S; end structural;

XX. ábra

Számláló A digitális áramkörtervezés elengedhetetlen része a számláló. Rengeteg fajtája létezik, szinkron, aszinkron, aszinkron/szinkron törlésű, stb. Előreszámláló



Dr. Hidvégi Timót

A következő VHDL kód olyan alapszámlálót ír le, amely engedélyező jellel és szinkron törléssel rendelkezik. library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; entity count2 is port(ENG, RST, CLKCNT : in std_logic; QCNT: out std_logic_vector(3 downto 0)); end count2; architecture Behavioral of count2 is signal SEGED : std_logic_vector(3 downto 0); begin process(CLKCNT) begin if (CLKCNT'EVENT and CLKCNT = '1' and ENG = '1' and RST = '0') then SEGED <= SEGED + 1; elsif (CLKCNT'EVENT and CLKCNT = '1' and ENG = '1' and RST = '1') then SEGED <= "0000"; else null; end if; QCNT <= SEGED; end process; end Behavioral;

XX. ábra A számláló szimuláció eredménye

Előre/Hátraszámláló

Programozható számláló


Dr. Hidvégi Timót


Állapotgépek Az állapotgépeknek két alaptípusa létezik. Megkülönböztetünk Moore és Mealy típusú állapotgépeket.

Moore FSM Legyen a következő példa, amelynek az állapotgépét az 8. ábra mutatja. C=0 C=1 S0

S1 F=0

F=1 K=1

0 K=

K=1

K=0

C=1 S4 F=0

S3

C=1 F=1

S2

C=0 F=1

C=0

8. ábra Moore típusú álapotgép

Ferde betűvel jelöltük az adott állapothpz tartozó kimenet értékét (pl.: S1 állapotban a kimenet értéke 1). A példában csak egy kimenet van (F), és az állapotgép két bemeneti változóval (C, K) vezérelhető. Ennek a példának a VHDL kódja a következő: LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.ALL; entity moorefsm is port ( CLK: in std_logic; CLR: in std_logic; C,K: in std_logic; F: out std_logic); end moorefsm; ARCHITECTURE viselk of moorefsm is TYPE state_type IS (s0, s1, s2, s3, s4); SIGNAL state: state_type; BEGIN next_state_logic: PROCESS (CLK, CLR) BEGIN IF (CLR = '1') THEN state <= s0; ELSIF (CLK'EVENT AND CLK = '1') THEN CASE state IS WHEN s0 => IF C = '1' THEN state <= s1; ELSE state <= s0; END IF; WHEN s1 =>



IF K = '0' THEN state <= s4; ELSE state <= s2; END IF; WHEN s2=> IF C = '1' THEN state <= s3; ELSE state <= s2; END IF; WHEN s3=> IF K = '1' THEN state <= s0; ELSE state <= s1; END IF; WHEN s4=> IF C = '1' THEN state <= s4; ELSE state <= s2; END IF; END CASE; END IF; END PROCESS; output_logic: PROCESS (state) BEGIN CASE state IS WHEN s0 => F <= '0'; WHEN s1 => F <= '1'; WHEN s2 => F <= '1'; WHEN s3 => F <= '1'; WHEN s4 => F <= '0'; END CASE; END PROCESS; END viselk;

Mealy FSM

Dr. Hidvégi Timót



XX. ábra Mealy típusú állapotgép

LIBRARY IEEE; USE IEEE.STD_LOGIC_1164.ALL; entity fsmmealy is port(clk: in std_logic; reset: in std_logic; C: in std_logic; Y: out std_logic); end fsmmealy; architecture VISELK of fsmmealy is type state_type IS (s0, s1, s2, s3); signal state: state_type; begin next_state_logic: process (clk, reset) begin if (reset = '1') then state <= s0; elsif (clk'event and clk = '1') then CASE state is WHEN s0 => if C = '1' then state <= s1; else state <= s0; end if; WHEN s1 => if C = '1' then state <= s2; else state <= s1; end if; WHEN s2=> if C = '1' then state <= s3; else state <= s2; end if; WHEN s3=> if C = '1' then state <= s0; else state <= s3; end if; end CASE; end if; end process; output_logic: process (state, C) begin CASE state IS WHEN s0 => Y <= '0'; WHEN s1 => Y <= '0'; WHEN s2 => Y <= '0'; WHEN s3 =>

Dr. Hidvégi Timót



if (C = '1') then Y <= '1'; else Y <= '0'; end if; end CASE; end process; end VISELK;

Memóriák

FIFO

RAM

Egy adatbusz

XX. ábra RAM egy adatbusszal

Két adatbusz

XX. ábra A RAM memória entitása

Dr. Hidvégi Timót



Dr. Hidvégi Timót

ROM A következő entitással (XX. ábra) rendelkező ROM típusú memória került megvalósításra.

XX. ábra A ROM memória entitása

package ROM2 is constant ROM_WIDTH: integer := 8;

-- Adatbitek száma

subtype ROM_WORD is bit_vector (1 to ROM_WIDTH); subtype ROM_RANGE is integer range 0 to 15; -- Memóriarekeszek -- száma type ROM_TABLE is array (0 to 15) of ROM_WORD; constant ROM: ROM_TABLE := ROM_TABLE'( ROM_WORD'("00000000"), ROM_WORD'("00000001"), ROM_WORD'("00000010"), ROM_WORD'("00000100"), ROM_WORD'("00001000"), ROM_WORD'("00010000"), ROM_WORD'("00100000"), ROM_WORD'("01000000"), ROM_WORD'("10000000"), ROM_WORD'("10000001"), ROM_WORD'("10000010"), ROM_WORD'("10000100"), ROM_WORD'("10001000"), ROM_WORD'("10010000"), ROM_WORD'("10100000"), ROM_WORD'("11000000")); end ROM2;

use work.ROM2.all; entity rom16x8 is port(ADDR: in ROM_RANGE; DATA: out ROM_WORD); end rom16x8; architecture beh of rom16x8 is begin DATA <= ROM(ADDR); -- Olvasunk a memóriából



end beh;

XX. ábra ROM szimulációja

Dr. Hidvégi Timót

VHDL alapú tervezés. (nem a teljes változat) Írta : Dr. Hidvégi Timót egyetemi docens

Recommend Documents