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

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

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

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

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 access after alias all and architecture array assert attribute block body buffer bus case component configuration constant disconnect downto else elsif end entity exit file for function generate generic guarded if in inout is label library linkage loop map mod nand new next nor not null of on open or others out package port procedure process range record register rem report return select severity signal subtype then to transport type units until use variable wait when while with xor 1993-ban tovább szabványosították a VHDL nyelvet, ekkor kerültek be a következő szavak: group impure inertial literal postponed pure reject rol ror shared sla sll sra srl unaffected xnor

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- ;

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 and or nand nor xor Relációs = /= < <= > >= Aritmetikai I. + - & Aritmetikai II. + - x / mod rem Exp, abs, coml. xx abs not 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;

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.

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;

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 B C D F A B C D & & 1 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 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 process(a,b,c,d) 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.

entity multip2 is port(a0, A1, v: in bit; Y: out bit); end multip2; arhitecture structural of multip2 is Y <= (A0 and not(v)) or (A1 and v); end structural; arhitecture viselkedes of multip2 is 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;

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 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 process(clk,set,clear) 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;

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 bcd is process(i) case I is when "0000" => S <= "1111110"; when "0001" => S <= "0110000"; when "0010" => S <= "1101101"; when "0011" => S <= "1111001"; when "0100" => S <= "0110011"; when "0101" => S <= "1011011"; when "0110" => S <= "1011111"; when "0111" => S <= "1110000"; when "1000" => S <= "1111111"; when "1001" => S <= "1110011"; when others => S <= "0000000"; end case; end process; end viselk; Shifter entity shifter is port(

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 process(sel, INSH) 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;

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; utasítások;

end process címke; A é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.

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ó. A i B i =1 C i =1 S i & & & C i+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 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.

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); 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;

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 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. a n-1 b 0 0 a 4 b 0 0 a 3 b 0 0 a 2 b 0 0 a 1 b 0 0 a 0 b 0 a n-1 b 1 a n-2 b 1... a 3 b 1 a 2 b 1 a 1 b 1 a 0 b 1 a n-1 b 2 a n-2 b 2... a 3 b 2 a 2 b 2 a 1 b 2 a 0 b 2 a n-2 b 3... a 3 b 3 a 2 b 3 a 1 b 3 a 0 b 3 a n-1 b n-3............ a n-1 bn-1 a n-1 b 2 an-2 b n-2... a 3 b n-2 a 2 b n-2 a 1 b n-2 a 0 b n-2 1 a n-1 b n-1 a n-2 b n-1... a 3 b n-1 a 2 b n-1 a 1 b n-1 a 0 b n-1 a n-1... b n-1...... P 2n-1 P 2n-2 P 2n-3 P n+3 P n+2 P n+1 P n P 3 P 2 P 1 P 0 7. ábra A Baugh-Wooley szorzó kapcsolási rajza A strukturális VHDL kódja a következő:

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; 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) AND BM(2); A1B2 <= AM(1) AND BM(2); A2B2 <= AM(2) AND BM(2); A3B2 <= AM(3) AND BM(2); A4B2 <= AM(4) AND BM(2); A5B2 <= AM(5) AND BM(2); A6B2 <= AM(5) AND BM(2); A7NB2 <=AM(6) AND 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;

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);

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

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);

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; process 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ó

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; process(clk, reset) 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 process(clk) 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 process(clk) 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;

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; next_state_logic: process(clkbrd) 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; end; output_logic: process (state) case state is when t0 => CLKPHS1 <= '1'; PHS2 <= '0'; SEGED1 <= '0'; when t1 => CLKPHS1 <= '0'; PHS2 <= '1'; SEGED1 <= '1'; end case; end process;

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 process(clk,rst) 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; reg1: FOR i in 0 to 7 generate dff: dff4 port map (D(i), CLK, RST, Q(i)); end generate reg1; end structural;

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); 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ó

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); process(clkcnt) 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ó

Á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 K = 1 S0 S3 C = 1 S1 K = 0 C = 1 F = 0 F = 1 K = 1 S4 F = 0 C = 1 S2 C = 0 F = 1 F = 1 C = 0 K = 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

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; next_state_logic: process (clk, reset) 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) CASE state IS WHEN s0 => Y <= '0'; WHEN s1 => Y <= '0'; WHEN s2 => Y <= '0'; WHEN s3 =>

end CASE; end process; end VISELK; if (C = '1') then Y <= '1'; else Y <= '0'; end if; Memóriák FIFO RAM Egy adatbusz XX. ábra RAM egy adatbusszal Két adatbusz XX. ábra A RAM memória entitása

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 DATA <= ROM(ADDR); -- Olvasunk a memóriából

end beh; XX. ábra ROM szimulációja