Végh János Bevezetés a Verilog hardver leíró nyelvbe INCK??? előadási segédlet

Átírás

1 1 Debreceni Egyetem Informatikai Kara Végh János Bevezetés a Verilog hardver leíró nyelvbe INCK??? előadási segédlet V0.30@

2 Tartalomjegyzék (folyt) 2 Tartalomjegyzék I. Alapfogalmak 1.. A digitális tervezés 1.1..A terv 1.2..Testbench 1.3..Fordítás és szintézis II. Verilog 1.. Mi az a Verilog? 2.. Absztrakciós szintek 3.. A tervezési folyam 3.1..Be és kimenetek 3.2..Szinkron tervezés 3.3..Időzítési kényszerek 4.. A szintézis veszélyforrásai 5.. Előnyök III. Alapelemek 1.. A Hello Világ program Tartalomjegyzék

3 Tartalomjegyzék (folyt) Nyelvi elemek 3.. Hierarchia megvalósítása 4.. Testbench modul IV. Számok 1.. Számok, vezetékek és regiszterek 2.. Az idő kezelése 3.. További nyelvi elemek 4.. Regiszterek és vezetékek V. Always 1.. RTL always utasítás VI. Procedurák 1.. Procedurális utasítások VII. Órajel 1.. Always latch VIII. Operátorok 1.. Operátor 2.. Paraméterek Tartalomjegyzék

4 Tartalomjegyzék (folyt) Hierarchia IX. Automaták 1.. RTL always utasítás X. Aritmetika és számlálók 1.. Aritmetikai műveletek A. Nem-blokkoló értékadás 1.. Bevezetés 2.. Versenyhelyzetek a Verilogban 3.. Blokkoló Tartalomjegyzék értékadás 4.. Nemblokkoló értékadás 5.. Verilog kódolási útmutató 6.. A Verilog réteges eseménysora 7.. Ön-triggerelő always blokkok 8.. Csővezeték modellezés 9.. Blokkoló értékadás és egyszerű példák 10.. Szekvenciális visszacsatolás modellezése 11.. Kombinációs logika - használjon blokkoló érték-

5 Tartalomjegyzék (folyt) 5 Tartalomjegyzék adást 12.. Kevert logika használjon nemblokkoló értékadást 13.. Többszörös értékadás ugyanannak a változónak 14.. Városi legendák a nemblokkoló értékadásról

6 Tartalomjegyzék (folyt) 6

7 Alapfogalmak 7 fejezet I: Alapfogalmak A mindenütt jelenlevő digitális rendszereknek nem csak a száma, hanem (elektronikus értelemben) a mérete és összetettsége is folyamatosan nő. Ennek kezelésére viszonylag korán bevezették a számítógéppel segített tervezést (computer-aided design, CAD). A kezdeti primitív szimulációs és hardver generáló segédeszközök mára bonyolult, automatizált eszközkészletté váltak, amelyek verifikálást, magas-szintű szintézist, formális verifikálást, automatizált hardver előállítást és eszköz programozást tesznek lehetővé. Ennek a fejlődésnek nagy része az ún. hardver-leíró nyelveknek (hardware description languages, HDLs) köszönhető: az eszközök működését nagyrészt ezeken a nyelveken tervezik. Bár a mai hardver tervezés már szinte kizárólag HDL alapú, teljes lendülettel folyik jobb és absztraktabb nyelvek és leírási módszerek keresése. Jelenleg az egyik legelterjedtebben használt ilyen hardver leíró nyelv a Verilog. Tervezőmérnökök számára

8 nagyon hasznos, szinte kötelező ismerni. A nyelv ismeretéhez többékevésbé hozzátartozik a nyelven alapuló eszközök és módszerek használata is, így ezekről is szót kell ejteni. Ez a fejezet rövid bevezető a Verilog használatához és használati köréhez, valamint megismerkedünk az RTL szintézis fogalmával. 8

9 Szakasz 1: A digitális tervezés 9 1. A digitális tervezés folyamata Egy automatizált tervezési környezetben a tervezés folyamata azzal kezdődik, hogy különböző absztrakciós szinteken specifikáljuk elvárásainkat, és ott végződik, hogy előállítjuk a hálózat listát alkalmazás specifikus áramkörökből (application specific integrated circuits, ASIC), vagy elkészítjük egy felhasználó által definiált integrált áramkör (custom IC) tervét, vagy egy programozható logikai eszköz (programmable logic device, PLD) programját. Az I.1 ábra mutatja a folyamat lépéseit. A tervezés fázisában megadjuk a viselkedést leíró Verilog kódot, a modul példánykészítés módját Verilogban, a buszok és vezetékek leírását. A tervező mérnöknek kell elkészíteni a terv ellenőrzésére, valamint később a szintézis eredményének verifikálására szolgáló ún. testbench-et. A terv verifikálását szimulációval, assertion verification, formal verification útján, de általában a három keverékével, oldhatjuk meg. A terv validálása (ezt hívják szintézis előtti verifikálásnak is (presynthesis verification)) után a szintézis eljárásban a cél eszköz

10 Szakasz 1: A digitális tervezés 10 I.1. ábra. Programozható logikák tervezési folyama c 2006, [1]

11 Szakasz 1: A digitális tervezés 11 tényleges hardverévé lefordítjuk. Itt a "cél eszköz" lehet egy bizonyos, a felhasználó által programozható logikai eszköz (field programmable logic device, FPLD), egy külső forrásból származó ASIC, vagy éppen a felhasználó által tervezett IC. A szintézis folyamata után, de még a tényleges hardver előállítása előtt, egy másik szimulációt (postsynthesis simulation) is végzünk. Ebben a szimulációban ugyanazt a testbench-et használjuk, mint amit a szintézis előtti szimulálás során. Ilyen módon a terv viselkedési modelljét és a hardver modelljét ugyanazokkal az adatokkal vizsgáljuk. A kétféle szimuláció között csak részletességben van különbség. Ejtsünk pár szót az I.1 ábra blokkjairól, amelyeket a legtöbb Verilog alapú EDA környezet támogat A terv elkészítése A tervezés első lépése a terv elkészítése. Ebben a fázisban a tervet felülről lefelé haladva (top-down hierarchical fashion) írjuk le, Verilog nyelven. A teljes terv állhat kapu vagy

12 Szakasz 1: A digitális tervezés 12 tranzisztor-szintű komponensekből, a hardver modul magas szintű funkcionalitását leíró viselkedési részekből, vagy a sínrendszer szerkezetét leíró komponensekből. Mivel a magas szintű Verilog terveket általában olyan szinten írjuk le, amelyek rendszer regisztereket és a busz használatával azok közötti átvitelt írnak le, ezt a rendszer leírási szintet regiszter átviteli szintnek (register transfer level, RTL) nevezik. Ennek a szintnek pontos hardver megfelelői vannak, pl. procedurális utasítások, folytonos értékadás és példányosító utasítások. A Verilog procedurális utasításait használjuk magas szintű viselkedés leírására. Egy rendszert vagy komponenst procedurális módon ahhoz hasonlóan írunk le, ahogyan eljárásokat használunk egy szoftver nyelvben. Például, egy komponenst úgy írhatunk le, hogy megadjuk a bemenő feltételeit, a jelzőbit beállításokat, milyen eseményekre vár, hogyan monitorozhatjuk a kézfogó jeleket, és milyen kimeneteket produkál. Egy rendszer procedurális leírásához a Verilog if-else, case és hasonló, szoftver-nyelv szerű konstrukciókat használhatunk.

13 Szakasz 1: A digitális tervezés 13 A Verilog folytonos értékadások olyan utasítások, amelyek logikai blokkokat, buszokat és ki/beviteli összekötési specifikációkat tartalmaznak. Ezeket a nyelvi konstrukciókat logikai műveletekkel és feltételekkel kombinálva, komponenseket és rendszereket regiszter és busz fogalmakkal írnak le. A Verilog példánykészítő utasításait használhatjuk arra, hogy alacsonyabb szintű komponenseket használjunk magasabb szintű tervben. A Verilogban alacsonyabb szintű komponensekkel is leírhatjuk a rendszert, ahelyett, hogy viselkedési, funkcionális vagy összekötési specifikációt használnánk. Az ilyen komponensek skálája a kaputól vagy tranzisztortól a teljes processzorig terjedhet Testbench a Verilogban Egy Verilog nyelven megtervezett rendszer funkcionalitását még azelőtt szimulációval tesztelni kell, hogy a tényleges hardvert előállítanánk. A szimuláció ezen fázisában megkereshetők a tervezési hibák

14 Szakasz 1: A digitális tervezés 14 és a komponensek esetleges inkompatibilitása. A terv szimulációjához teszt adatok és a szimuláció eredményeinek megfigyelése szükséges. Ezt a folyamatot egy speciális Verilog modullal, a testbench modullal hajthatjuk végre. Egy Verilog testbench a nyelv magas szintű konstrukcióit használja adatok előállítására és a válasz monitorozására, sőt még a jelek kézfogásának tervezésére is. A testbenchben megtalálható a szimulált terv modul egy példánya. A Verilog szimulációs motorja együtt használja a testbench-et és a tervet. A különféle tervezési hibákat (hibás tervezési specifikáció, tervezői hiba, a részek helytelen használata, stb.) a terv validálásával találhatjuk meg. A terv szimulációval történő validálása a szintézis lépés előtt kerül sorra. Ezt a szimulációs fázist viselkedési, RT-szintű és szintézis előtti szimulációnak is nevezik. A terv RT szintjén már van órajel, de még nincsenek benne kapu és vezeték késleltetések. Ezen a szinten a szimuláció csak az órajelek szintjéig pontos, azaz nem kezeli a hazard szituációkat, versenyhelyzeteket, beállási és tartási problémákat, "szikrázásokat", és hasonló időzítési problémákat. Ennek a szimulációs típusnak fő előnye a sebessége, a tranzisztor vagy kapu szintű

15 Szakasz 1: A digitális tervezés 15 I.2. ábra. Szimuláció testbench és hullámforma szerkesztő használatával c 2006, [1]

16 Szakasz 1: A digitális tervezés 16 szimulációkhoz képest. Egy terv szimulálásához teszt adatok szükségesek, és általában a Verilog szimulációs környezetek különböző módszereket biztosítanak arra, hogy ezeket az adatokat a vizsgálandó tervre alkalmazzuk. A teszt adatokat előállíthatjuk grafikusan hullámforma szerkesztőkkel, vagy testbench használatával. Az I.2 ábra mutatja, hogyan állíthatunk elő teszt adatokat a szimulációs motor számára. A szimuláció kimenetei vagy hullámformák (vizuális analízis céljára) vagy (főként nagyobb tervek esetén) szöveg, további gépi feldolgozásra. Amikor egy Verilog testbench használatával tesztelünk, a testbench a tervből készít egy példányt és a testbench kód részeként teszt adatokat alkalmaz a készített terv példányra. Az I.3 ábra egy egyszerű számláló áramkört mutat, a hozzá tartozó testbench mellett, valamint a hullám formában megjelenített szimulációs eredményeket. Mint látható, a szimuláció validálja a számlálókör funkcionalitását: a számláló értéke minden egyes órajel impulzus hatására eggyel nő. Vegyük észre, hogy a számláló kimeneti értéke az órajel felfutó élével változik, nincs kapu késleltetés és terjedési idő. A szimuláció szerint a

17 Szakasz 1: A digitális tervezés 17 I.3. ábra. Verilog Szimuláció testbench használatával c 2006, [1]

18 Szakasz 1: A digitális tervezés 18 működés helyes, az órajel frekvenciától függetlenül. A tényleges hardver komponsek nyilvánvalóan kicsit eltérően viselkednek. A használt alkatrészek időzítésétől és késleltetésétől függően, nem-nulla késleltetés lép fel az órajel aktív éle és a számláló kimenete között. Ezen túlmenően, ha az órajel frekvencia túl gyors a terv kapui és tranzisztorai közötti adat továbbításhoz képest, az eredmény megjósolhatatlan. Az itt bemutatott szimuláció nem rendelkezik a szimulált hardver időzítésének részleteivel. Emiatt a kapu késleltetések miatti esetleges hardver időzítési problémákat sem tudjuk észlelni. Ez egy tipikus szintézis előtti, avagy magas szintű viselkedési szimuláció. Amit ellenőrizni tudunk, hogy számlálónk valóban binárisan számlál. Hogy a számláló milyen gyorsan tud működni és milyen órajel sebesség szükséges hozzá, azt csak azután vizsgálhatjuk, miután a tervet szintetizáltuk. Ahelyett, hogy manuálisan megvizsgáljuk az eredményeket és bonyolult testbench fejlesztést végzünk, megkövetelhetjük bizonyos feltételek fennállását, és azok teljesülésének ellenőrzését a szimulációs motorra bízzuk. Ennek érdekében magába tervbe ún. "assertion

19 Szakasz 1: A digitális tervezés 19 monitor" (követelmény teljesítés ellenőrzése) pontokat teszünk. A tervező elvárása, hogy ha a terv megfelelően működik, akkor bizonyos feltételeknek teljesülniük kell. Ezeket a feltételeket a terv lényegi tulajdonságainak tekintjük, és a tervező ilyen "assertion monitor"- okat fejleszt ki annak ellenőrzésére, hogy ezek a tulajdonságok nem sérülnek. Ezek a monitorok akkor lépnek működésbe, amikor az elvárt működés sérül, ezáltal figyelmezteti a tervezőt, hogy a terv nem az elvárások szerint működik. Egy speciális könyvtár, az Open verification library (OVL) számos ilyen monitort tartalmaz, amellyel a szokásos tervezési elvárásokat monitorozhatjuk. Emellett a tervező saját ilyen monitorokat is fejleszthet és használhat a testbench működtetése során. A formális verifikálás az a folyamat, amikor azt vizsgáljuk, hogy a terv rendelkezik-e bizonyos tulajdonságokkal. Amikor egy tervet befejezünk, a terv rendelkezik egy sor olyan tulajdonsággal, amelyek a helyes viselkedést tükrözik. Egy olyan eszköz, amelyik a formális verifikálást végzi, azt ellenőrzi, hogy a megadott tulajdonság minden körülmények között teljesül. Amennyiben olyan helyzetet találunk,

20 Szakasz 1: A digitális tervezés 20 ahol a tulajdonság nem teljesül, akkor a tulajdonság sérül. Az ilyen helyzetet ellenpéldának tekintjük. A lefedettséggel azt adjuk meg, hogy a tulajdonság vizsgálatával a teljes terv milyen részét tudjuk vizsgálni Fordítás és szintézis A szintézis a terv leírásból történő automatikus hardver generálás azon folyamata, amelyiknek egyértelmű hardver megfelelője van. A szintézisre szánt Verilog leírás nem tartalmazhat jel és kapu szintű időzítési specifikációt, fájl kezelést, és semmi olyan nyelvi konstrukciót, ami nem fordítható le szekvenciális vagy kombinációs logikai egyenletekké. Továbbá, a szintézisre szánt Verilog leírásnak bizonyos kódolási stílust kell követnie. A tervezési folyamatban, miután a tervet a szintézis előtti szimulációval sikerrel ellenőriztük, azt le kell fordítani, hogy egy lépéssel közelebb kerüljünk a tényleges hardverhez. Ehhez a tervezési folyamathoz a tényleges cél-hardver specifikációja is szükséges.

21 Szakasz 1: A digitális tervezés 21 I.4. ábra. A fordítás és szintézis folyamata c 2006, [1]

22 Szakasz 1: A digitális tervezés 22 Megadhatunk például egy bizonyos ASIC-et vagy egy programozható kaputömböt (field programmable gate array, FPGA) cél-hardverként. Amikor kiválasztjuk a cél-hardvert, annak technológiai fájljai (a részletes időzítési és funkcionális adatokkal) elérhetővé válnak a fordítási folyamat számára. A fordítási folyamat a terv különféle részeit egy közbülső formátumra fordítja (analízis fázis), összecsatolja valamennyi részt, előállítja a megfelelő logikát (szintézis fázis), elhelyezi a cél-hardver komponenseit és megtervezi az azokat összekötő útvonalakat, valamint előállítja az időzítés részleteit. Az I.4 ábra mutatja a fordítási folyamatot és az egyes fordítási fázisok eredményének grafikus ábrázolását. Mint látható, ennek a fázisnak a bemenete egy, különböző Verilog szinteket tartalmazó hardver leírás, a kimenete pedig egy olyan részletes hardver, amit FPLD programozásra vagy ASIC gyártásra használhatunk. A fordítás fázisai: Analízis Egy Verilogban megírt teljes terv állhat viselkedési Verilog leírásból, busz- és összekötés specifikációból, és egyéb

23 Szakasz 1: A digitális tervezés 23 Verilog komponensekből. Mielőtt a teljes tervet hardverré fordítanánk, azt analizálni kell, és annak valamennyi részét egységes formátumúvá tenni. Ez a fázis a Verilog kód szintaxisát és szemantikáját is megvizsgálja. Generikus hardver előállítás A terv egységes formátumúvá alakítása után a szintézis a tervet generikus hardver formátumúvá alakítja, ami logikai kifejezéseket és alapkapuk hálózatát jelenti. Logikai optimalizálás Miután a tervet logikai kifejezésekké alakítottuk, a szintézis következő fázisa a logikai optimalizálás. Ez a fázis felelős a konstans bemenetű kifejezések redukálásáért, a felesleges logikai kifejezések eltávolításáért, a logikai megosztást tartalmazó kétszintű és többszintű minimalizálásért. Ez nagyon számítás intenzív folyamat, és néhány segédprogram megengedi, hogy a felhasználó döntsön az optimalizálás szintjéről. Ennek a fázisnak a kimenete logikai függvények, táblázatos logikai megjelenítés, vagy primitív kapu hálózatok. Csatolás A logikai optimalizálás után a szintézis folyamat a

24 Szakasz 1: A digitális tervezés 24 cél-hardverről kapott információt használja arra, hogy eldöntse, melyik logikai elemek és cellák szükségesek a terv megvalósításához. Ez a folyamat a csatolás és ennek kimenete már FPLD, ASIC vagy felhasználói IC specifikus. Útvonal tervezés és elhelyezés Az útvonal tervezés és elhelyezés fázisban dől el a cellák helye a cél hardverben. Ezen cellák kimenő és bemenő vezetékezését a cél hardver vezeték csatornái és kapcsoló területei határozzák meg. Ennek a fázisnak a kimenete a használt hardverre jellemző és FPLD programozásra és ASIC gyártásra is használható. Egy szintézis példát mutat az I.5 ábra, ahol a I.3 ábrán bemutatott szimulációban szereplő számláló áramkört szimuláljuk. A terv Verilog kódján túl a szintézis eszköznek szüksége van a cél hardver specifikációjára is. A szintézis segédprogram kimenete a cél hardverben elérhető kapuk és flipflopok listája, valamint azok összekötései. A szintézis eszköz által automatikusan előállított grafikus ábrázolás is látható a I.5 ábrán. (Altera s Quartus II) Szintézis utáni szimuláció Amikor a szintézis elkészült,

25 Szakasz 1: A digitális tervezés 25 a szintézis segédprogram előállítja a cél-hardver komponensei teljes hálózati listáját és időzítéseiket. Ebben a listában találjuk meg az implementációban használt kapuk részleteit. Ugyanez a lista tartalmazza a vezetékezési késleltetéseket is. A hálózat lista különféle formátumokban érhető el. Ez a leírás szimulálható, és azt nevezik szintézis utáni szimulációnak. Az időzítési problémák, a megfelelő órajelfrekvencia valamint a verseny és a hazard szituációk csak a szintézis utáni szimulációban vizsgálhatók. Amint az I.1 ábrán látható, a szintézis előtti és utáni szimuláláshoz ugyanaz a testbench használható. A vezetékek és kapuk késleltetése miatt előfordulhat, hogy a tervező által várt és a szintézis utáni viselkedés eltér. Ebben az esetben a tervezőnek módosítania kell a tervet, hogy elkerülje a szoros időzítéseket és a verseny helyzeteket. Időzítés vizsgálat Amint az I.1 ábrán látható, a fordítási folyamat részeként, vagy bizonyos eszközökben a fordítási folyamat után, egy időzítés vizsgálat (Timing analyzis) is helyet kap. Ez állítja elő a legrosszabb esetre vonatkozó késleltetést,

26 Szakasz 1: A digitális tervezés 26 az órajel sebességet, a kapuk közötti késleltetést, valamint a beállási és tartási időket. Ennek a vizsgálatnak az eredménye táblázatokban és/vagy grafikonokban jelenik meg. A tervezők az áramkör sebességének becslésére használják az adatokat. Hardver előállítás A Verilog alapú automatizált tervezés utolsó fázisa a hardver előállítás. Ez a fázis állítja elő a hálózatlistát ASIC gyártáshoz, az FPLD-hez a programot, vagy a felhasználói IC elrendezését.

27 Szakasz 1: A digitális tervezés 27 I.5. ábra. Példa a szintézisre c 2006, [1]

28 A Verilog nyelvről 28 fejezet II: A Verilog nyelvről

29 Szakasz 1: Mi az a Verilog? Mi az a Verilog? Megjegyzés: A Verilog nem C Vigyázzunk vele: szintaxisa látszólag nagyon hasonlít a C nyelvre, de szemantikája nagyon eltér. A Verilog egy hardver leíró nyelv (Hardware Description Language); elektronikus áramkörök és rendszerek szöveges leírására szolgál. Elektronikus áramkörök tervezésére használják; szimulációval való verifikálásra, időzítés vizsgálatra, teszt jellegű analízisre, és logikai szintézisre Gateway Design Automation bevezeti Verilog-XL rendszert Cadence Design Systems megvásárolja a Gateway-t A Verilog HDL valamennyi jogát átruházzák az Open Verilog International-re (OVI, ma Accellera)

30 Szakasz 1: Mi az a Verilog? 30 II.1. ábra. A Verilog története. c 2001, Doulos [2]

31 Szakasz 1: Mi az a Verilog? 31 Megjegyzés: A Verilog HDL IEEE sztenderd, mégpedig a 1364 számú. A sztenderd dokumentum maga a Language Reference Manual (LRM); ezt tekintjük a Verilog HDL ősforrásának és hiteles definíciójának. Viszont, nem biztos, hogy abból érdemes megtanulni. Az IEEE 1364 sztenderd egy programozási interfészt is definiál (Programming Language Interface, PLI). Ez lényegében szoftver rutinok gyűjteménye, amelyek egy kétirányú interfészt biztosítnak más nyelvekhez (általában a C-hez). Ez a PLI teszi lehetővé, hogy a Verilog nyelvet és a Verilog segédprogramokat (szimulátor) testre szabjuk Az IEEE Standard 1364 közzététele "Verilog 2001" A jövő - Verilog-AMS, SystemVerilog

32 Szakasz 1: Mi az a Verilog? 32 Analog and Mixed-Signal Extension to Verilog A Verilog HDL története az 1980-as évekre nyúlik vissza, amikor egy Gateway Design Automation nevű cég kifejlesztett egy Verilog-XL nevű logikai szimulátort, és mellesleg azzal együtt egy hardver leíró nyelvet. Tehát eredetileg a Verilog szimuláció leírására és végzésére szolgált, a szintézis támogatása későbbi melléktermék. A Cadence Design Systems 1989-ben felvásárolta a Gateway-t, és azzal együtt a nyelvhez és a szimulátorhoz fűződő jogait ben a Cadence a nyelvet (a szimulátort nem!) közkinccsé tette, azzal a szándékkal, hogy az egy sztenderd, nem céghez kötődő nyelv legyen. Az erre a célra létrehozott nem profit orientált szervezet, az Open Verilog International (OVI) végezte el a Verilog nyelv IEEE sztenderdizálási eljárását ben (főként egy másik HDL, a VHDL nyelv növekvő sikerének hatására) lett a Verilog HDL IEEE 1364 sztenderd (Verilog-95). Az OVI 2000-ben egyesült a VHDL International-lel Accelera néven, és a továbbiakban a jövőbeli Verilog sztenderdeket koordinálja.

33 Szakasz 1: Mi az a Verilog? 33 A felhasználók által igényelt javítások után lett az új sztenderd (Verilog 2001) Ez komoly változtatásokat és javításokat javasolt magához a Verilog nyelvhez és a PLI-hez. Ezzel egyidejűleg folyt a Verilog-AMS (analog and mixed signal extensions) fejlesztése is. A Verilog-2001 a Verilog-95 lényeges frissítését jelentette. Először is, explicit módon támogatja a (kettes komplemens) előjeles hálózatokat és változókat. Ezt megelőzően a kód íróknak figyelmes bit-manipulációkkal kellett előjeles műveleteket végezni (például, egy egyszerű 8-bites összeadásból származó átvitel bit helyes meghatározásához explicit Boole-algebrai leírás volt szükséges). Ugyanaz a függvény Verilog-2001 alatt sokkal tömörebben és egyértelműbben leírható a +, -, /, *, >>> operátorok valamelyikével. A generate/endgenerate konstrukció (A VHDL hasonló konstrukciójával megegyezően) lehetővé teszi, hogy a Verilog-2001 normál vezérlési operátorokkal (case/if/else) vezérelje példányok és utasítások létrehozását. Ezzel a konstrukcióval a Verilog-2001 úgy tud példányok tömbjének példányát létrehozni, hogy közben vezérelni

34 Szakasz 1: Mi az a Verilog? 34 tudja az egyes példányok közötti kapcsolatot. A fájl I/O-t számos új rendszer taszk segíti. Végül pedig pár szintaxis javítást is bevezettek, hogy a kód olvashatóságát javítsák (például always *, nevesített paraméter átértelmezés, C-stílusú függvény/task/modul fejzet deklaráció). A Verilog 2005 (IEEE Standard ) ehhez képest csak apróbb korrekciókat tartalmaz, pontosításokat és pár új nyelvi tulajdonságot (mint az uwire kulcsszó) tartalmaz. Manapság a legtöbb fejlesztőrendszer a Verilog-2001-en alapszik. (A SystemVerilog is egy Verilog-2005 bővítmény, amely sok új tulajdonságot és a verifikálást/tervezést segítő tulajdonságot tartalmaz.) Ha csak külön nem jelezzük, a Verilog és a Verilog HDL a továbbiakban a nyelvre és nem a szimulátorra vonatkozik. A Verilog HDL digitális elektronikus hardver specifikálására, tervezésére és leírására szánt nyelv. Rendszer szint A Verilog nem ideális a hardver-szoftver elkülönítés elvégzése előtti absztrakt rendszer-szintű szimulációra. A szimuláció ezen a szinten általában sztochasztikus,

35 Szakasz 1: Mi az a Verilog? 35 II.2. ábra. A Verilog használati köre c 2001, Doulos [2]

36 Szakasz 1: Mi az a Verilog? 36 a modellezés hatékonyságát, átbocsátóképességét, sorbanállást és a statisztikus eloszlásokat veszik figyelembe. A Verilognak van pár olyan rendszertaszkja és függvénye, amely támogatja a sztochasztikus modellezést és némi sikereket is ért el ezen a téren. Digitális a Verilog manapság a digitális hardver tervezési folyamatban sok mindenre használható, a specifikációtól a magas szintű funkcionális szimulációig, manuális tervezésre, logikai szintézistől a kapu-szintű szimulációig. A Verilog eszközök ezen a területen egy integrált tervezési környezetet biztosítanak. A Verilog használható részletes, implementáció szintű modellezésre, beleértve a kapcsolóelem-szintű szimulálást, időzítés analízist, és hiba szimulációt. Analóg A Verilog-AMS nyelv lehetővé teszi kevert (analóg és digitális) valamint tisztán analóg modellezést és szimulációt. Tervezési folyamat Az II.2 diagram az elektronikus tervező rendszer egy erősen egyszerűsített diagramját mutatja, a Verilog helyének megjelölésével. Az ábra középső része mutatja a

37 Szakasz 1: Mi az a Verilog? 37 tervezési folyamat fő részeit, ahol a Verilog jelentős befolyásoló szerepet tölt be.

38 Szakasz 2: Absztrakciós szintek Absztrakciós szintek Az II.3 ábra összefoglalja egy ASIC (azaz kaputömb, sztenderd cella tömb vagy FPGA) magas szintű tervezési folyamatát. A gyakorlatban az egyes bemutatott lépések kisebb lépésekre bonthatók, így elfedik a tervezés kisebb hibajavításaiban rejlő iterációkat. Első lépésként a Verilog-ot használjuk az egy vagy több ASICból álló teljes rendszerek modellezésére és szimulálására. Ez lehet a rendszer teljes funkcionális leírása, amely lehetővé teszi, hogy az ASIC/FPGA specifikációját még azelőtt validáljuk, mielőtt a részletes tervezést elkezdenénk. A másik lehetőség, hogy csak egy részleges leírásunk van, ami a rendszer bizonyos tulajdonságait absztrahálja, például egy hatékonysági modell, amit a hatékonyság szűk keresztmetszeteinek felderítésére használunk. Amikor a rendszer architektúrája és felosztása stabilizálódott, kezdődhet az egyes ASIC/FPGA elemek megtervezése, Verilogban, RTL szinten, és tartalmazza Verilog teszt esetek megírását is. Ez a két feladat kiegészíti egymást, és gyakran két különböző csapat végzi, annak biztosítására, hogy a specifikációt

39 Szakasz 2: Absztrakciós szintek 39 II.3. ábra. Absztrakciós szintek c 2001, Doulos [2]

40 Szakasz 2: Absztrakciós szintek 40 helyesen értelmezik-e. Az RTL Verilog-nak szintetizálhatónak kell lenni, ha automatikus logikai szintézist akarunk használni. A teszt esetek előállítása nagyon fontos feladat, rendszerességet és biztos mérnöki tudást követel: a végső ASIC minősége nagyon függ attól, hogy a teszt esetek mennyire fedik le a tervet. Ezután az RTL Verilog-ot szimuláljuk, hogy validáljuk a terv specifikációnak megfelelő funkcionalitását. Az RTL szimuláció általában egy-két nagyságrenddel gyorsabb, mint a kapu szintű szimuláció, és a tapasztalatok azt mutatják, hogy ez a gyorsaság úgy használható ki jobban, ha több szimulációt végzünk, és nem kevesebb időt töltünk vele. A gyakorlatban elég általános, hogy az ASIC/FPGA tervezési ciklusában az idő 70-80%-át az RTL szintű kódírással és szimulálással töltik, és csak 20-30%-át a kapuk szintetizálásával és verifikálásával. Bár valamennyi felderítő jellegű szintézist általában végeznek a tervezési folyamat elején, az architekturális döntésekhez és a Verilog szintézis mérnöki megértésének vizsgálatához szükséges pontos

41 Szakasz 2: Absztrakciós szintek 41 sebesség és terület adatok származtatása (a tényleges produkciós szintézis) általában csak akkor áll elő, amikor a funkcionális szimuláció befejeződik. Egyszerűen értelmetlen addig időt és energiát fektetni a szintézisbe, amíg a terv funkcionalitását nem ellenőriztük.

42 Szakasz 3: A tervezési folyam A tervezési folyam 3.1. A szintézis eszköz be- és kimenetei A szintézisre fókuszálva, a II.5 ábra azt mutatja be, hogy egy tipikus RTL szintézis eszközhöz milyen be-és kimenetek tartoznak. Bemenetek A szintézis eszköz bemeneteihez nem csak a Verilog forráskód tartozik, hanem a tervezési kényszerek, a határfeltételek valamint a szintézis paraméterei és vezérlése is. A tervezési kényszerek tartalmazhatják a maximális órajel frekvenciát és a maximális kapuszámot, a határfeltételek tartalmazhatják a kimeneti tüskékre adható kapacitív terhelést, és a szintézis paraméterei tartalmazhatják az optimalizálásra fordítható CPU időt. Kimenetek A szintézis eszköz kimeneteihez nem csak szintetizált terv (általában egy hálózatlista formájában) tartozik, hanem a szintetizált áramkör is, meg egy összefoglaló jelentés, aminek alapján a terv minőségére következtethetünk. Egy

43 Szakasz 3: A tervezési folyam 43 II.4. ábra. A tervezési folyam c 2001, Doulos [2]

44 Szakasz 3: A tervezési folyam 44 II.5. ábra. A tervezési folyam c 2001, Doulos [2]

45 Szakasz 3: A tervezési folyam 45 teszt szintézis eszköz automatikusan elkészíti a gyártáshoz szükséges teszt vektorokat is Szinkron tervezés Minden tárolás flip-flopokban történik, egyetlen külső órajellel. Az RTL szintézis, a tervező lánc többi tagjához hasonlóan, szinkron tervezést tételez fel. Számos, a szintézis alatt és után gyakran előforduló probléma, különösen az időzítési gondok, arra vezethetők vissza, hogy nem-szikron tervezési módszereket használtunk a Verilog terv készítésekor. Emiatt a szinkron tervezési módszerek megértése a sikeres RTL szintézis fontos alapköve. Egy tisztán szinkron terv tárolóelemeket (regisztereket) tartalmaz, amelyeket egy órajel éle vagy egy kombinációs logika triggerel. Mindent él-vezérelt flipflopokban tárolunk, amelyeket ugyanaz az órajel hajt meg. Valamennyi flip-flopban (a pipeline regisztereket kivéve) van reset jel.

46 Szakasz 3: A tervezési folyam 46 Nincsenek kombinációs visszacsatolási hurkok Kombinációs áramkörnek azt a digitális áramkört nevezzük, amelynek a pillanatnyi kimeneti állapot jellemzői a bemeneteinek pillanatnyi állapotától, és csak attól, függenek. A logikában bármiféle hurok (visszacsatolás) regisztereken keresztül történhet Időzítési kényszerek A szintézis eszközök olyan módon alakítják a Verilog leírást kapukká, hogy az átalakítás megőrzi a terv funkcionalitását. Ennek azonban csak akkor van gyakorlati jelentősége, ha a terv időzítése helyes, a szintézis pedig csak a szinkron terv funkcionalitását őrzi meg. A szintézis úgy őrzi meg a terv órajel szintű viselkedését, hogy optimalizálja a regiszterek közötti kombinációs logikát, hogy elérje a célul kitűzött órajel periódust. Az adat érkezési idejét úgy számolja, hogy megvizsgálja az összes lehetséges útvonalat a regiszterek között; az órajel érkezését az óra útvonalának követésével, a periódusidőt

47 Szakasz 3: A tervezési folyam 47 II.6. ábra. Szinkron tervezés c 2001, Doulos [2]

48 Szakasz 3: A tervezési folyam 48 II.7. ábra. Időzítési kényszerek c 2001, Doulos [2]

49 Szakasz 3: A tervezési folyam 49 független tervezési kényszernek tekinti, az összeállítást pedig a technológiai könyvtár definiálja. A tervezőnek kell számba vennie az elsődleges bemenetekre érkező külső jelek időzítési viszonyait, hogy azok ne sértsék a beállási és tartási időket, számításba véve az I/O padok által okozott és a tok belsejébe hatoláshoz szükséges időt. Sajnálatos, de nem lehetünk biztosak abban, hogy megvalósított tervünk a tényleges környezetben is működni fog, pusztán azért, mert a szintézis eszköz szerint az időzítés rendben van.

50 Szakasz 4: A szintézis veszélyforrásai A szintézis veszélyforrásai A szintézis nem csodaszer! Fontos, hogy mindenkinek, aki hozzákezd egy projekthez, reális elvárásai legyenek a szintézissel kapcsolatban. Pár megjegyzés alább. A szintézis eredménye nagyon függ attól, hogy a Verilog kód milyen stílusban van megírva. Meghatározott stílusra (style guide) van szükség. Nem elegendő, hogy a Verilog kód funkcionálisan helyes: olyan módon kell azt megírni, hogy a szintézis eszközt jó hardver készítésére irányítsa; ezen túlmenően a Verilog kódnak meg kell felelnie az illető szintézis eszköz sajátságainak. A jó stílus azonban a tervező felelőssége. Az RTL szintézis során a tervezőnek biztos kézzel kell irányítani a tervezést! A tervezési döntések nagy részét az ember hozza, a szintézis eszköz automatizálja a kapu-szintű megvalósítást. A szintézis eszközzel a rossz tervező még mindig rossz tervet készít, csak gyorsabban! Ha szemét a bemenet, szemét a

51 Szakasz 4: A szintézis veszélyforrásai 51 kimenet is A szintézis nem helyettesíti az emberi tudást és tapasztalatot. A tervezési gyakorlatban a szintézis olyan eredményt ad, amelyik megegyezik az emberi tervezőével vagy annál jobb. A szintézis jó eredményeket adhat, rövid idő alatt "kézi munka" szükséges ahhoz, hogy gyors vagy sűrű tervet tudjunk készíteni. Azokban a tervekben, amelyek a technológia gyorsasági vagy sűrűségi határait feszegetik, a szintézis magában gyakran nem elég jó, kézi beavatkozás is szükséges.

52 Szakasz 5: Előnyök Előnyök Végrehajtható specifikáció. Gyakran találkozunk olyan ASIC tervekkel, amelyek kezdetben megfelelni látszanak specifikációjuknak, de a rendszerbe beépítve nem működnek. A Verilog kétféle módon is tudja kezelni ezt a problémát: egy Verilog specifikáció már a tervezés megvalósítása előtt végrehajtható, hogy nagyobb megbízhatósági szintet érhessünk el, és a terv egy-két nagyságrenddel gyorsabban szimulálható, mint a kapu szintű leírás. Egy rész Verilog specifikációja képezheti az alapját annak a szimulációs modellnek, ami az illető részt egy nagyobb rendszer részeként szimulál (például, nyomtatott áramköri lap szimuláció). Ez attól függ, milyen pontosan kezeli a specifikáció az időzítés és inicializálás vonatkozásait. A specifikációt a rendszerrel összefüggésben is validálni kell Funkcionálisan el van választva az implementációtól. A magas szintű tervezési módszer használatával a terv funkcionalitása még a terv részletekbe menő megvalósítása előtt validálható.

53 Szakasz 5: Előnyök 53 A korai szimulálás lehetővé teszi, hogy korábban megtaláljuk a tervezési folyamatban rejlő hibákat, amikor azokat még egyszerűbb és olcsóbb javítani. Szimulálj gyakran és gyorsan. Figyelj a komplexitásra Találd meg a tervezési alternatívákat. A viselkedési és RTL szintézis eszközök használatával lehetővé válik a tervezési tér nagyobb részének megismerése olyan módon, hogy több alternatív megvalósítást próbálunk ki és a legjobbat választjuk. Legyen visszacsatolás. Készíts jobb terveket Automatikus szintézis és teszt generálás. A logikai áramkörök és a gyártási teszt vektorok automatikus generálása rövidítheti a tervezési ciklust. Ettől függetlenül, a rövidebb piacra kerülési idő elérésének legfontosabb komponense, hogy a Verilog tervek minél nagyobb része legyen kezdettől fogva helyes, elkerülendő a költséges újraindulásokat. Növeld a termelékenységet. Kerülj rövidebb idő alatt a piacra

54 Szakasz 5: Előnyök 54 Figyelj a beruházásodra. Sok cég úgy igyekszik anyagi érdekeit védelmezni, hogy eszköz és technológia függetlenséget remél a Verilog használatától. Lásd alább. Függetlenség a szimulációs eszköztől Igen! (A nem-determinisztikus viselkedés ellenére) Függetlenség a szintézis eszköztől Nem! Különböző alrendszerek, kódolási stílusok és optimalizáció Javasolt IEEE Std Eszközök A Verilog hardver tervek és teszt fixtúrák általában hordozhatók a tervező eszközök között, a tervező központok között és a projekt partnerek között. Bár a Verilog nyelv eredendően nem-determinisztikus (különböző szimulátorok elérő eredményre vezetnek bizonyos modellek esetén), nem szabad nem-determinisztikus kódot írni. Tehát biztosan számíthat arra, hogy a Verilog tanulás eredményeként nem fog valamely gyártó

55 Szakasz 5: Előnyök 55 egy eszközéhez kötődni, hanem válogathat az eszközök és platformok között. Emellett a különböző eszközök gyártói arra törekszenek, hogy minél jobb Verilog támogatást nyújtsanak eszközeiken. A fentiek igazak szimuláció esetén, azonban a szintézis eszközök másik történet: nincs egységes alrendszer vagy Verilog értelmezés szintézis esetén. Van egy javasolt IEEE sztenderd , ami biztosít egy sztenderd Verilog alrendszert, de annak megvalósítása is időbe telik. Függetlenség az ASIC technológiától Igen! Függetlenség az FPGA/CPLD technológiától Nem! A generikus kód rossz terület kihasználást és sebességet eredményez Meg kell érteni az eszköz architektúráját Technológia

56 Szakasz 5: Előnyök 56 A Verilog olyan módon teszi lehetővé a technológia fügetlen tervezést, hogy támogatja a felülről lefelé történő tervezést és logikai szintézist. Egy új technológiára való áttéréshez nem kell mindent elölről kezdeni vagy a specifikációt visszafejteni, ehelyett csak vissza kell térni a Verilog viselkedési leíráshoz, és azt az új technológiára implementálni: biztos lehet benne, hogy a helyes működés megmarad. Ez az eljárás követhető, pl. amikor egy FPGA tervet újra implementál ASIC gyanánt. A Verilog nagyon robosztusnak bizonyult abban, hogy terveket vigyünk át különböző FPGA technológiák között, de kevésbé sikeres FPGA és CPLD között. Az a generikus Verilog kódolási stílus, ami jól működik ASIC esetén, nem eredményez jó eszköz kihasználást és sebességet, amikor a cél programozható logikai eszköz. Hogy a legjobb eredményt érjük el programozható logikák esetén, alaposan meg kell érteni a cél eszköz architekturális tulajdonságait, és azokat be kell építeni a Verilog tervbe.

57 Szakasz 5: Előnyök 57

58 Alapelemek 58 fejezet III: Alapelemek Ebben a szakaszban megismerjük mindazokat a nélkülözhetetlen Verilog nyelvi alapelemeket, amelyek feltétlenül szükségesek ahhoz, hogy a legegyszerűbb feladatot meg tudjuk írni (és érteni).

59 Szakasz 1: A Hello Világ program A Hello Világ program Programlista III.1: A Hello Világ program (Nem minden platformon működik ebben az egyszerű alakban) module main ; i n i t i a l begin $display ("Hello world!") ; $finish ; end endmodule Nos, végül is programnyelvet tanulunk, így hát lássuk az elején, milyen lesz a minden programnyelven megszokott Hello Világ program, amelyet ezúttal Verilog nyelven írunk meg. Ha eléggé távolról nézünk rá a III.1 programlistára, észleljük a távoli rokonságot a C nyelvvel: pontosvessző van az utasítások végén, idézőjelben van a kiírandó szöveg, az elején ott szerepel a main kulcsszó.

60 Szakasz 1: A Hello Világ program 60 Ugyanakkor komoly eltéréseket is látunk: itt a program egység nem function, hanem module. Érthető, hiszen, mint korábban említettük, ezt a nyelvet elektronikus áramkörök tervezésére használjuk, itt a modul egy többé-kevésbé "kerek" egységet jelöl, itt ez lesz a fordítási egység. Látjuk azt is, hogy itt a {} zárójelek helyett kulcsszavakat használunk. Ez egyike a kevés, Pascal-os hatásnak. A kiírandó szöveg a $display argumentumaként szerepel. Természetesen kevés áramkörbe építenek mondjuk LCD kijelzőt ( ), így programunk nem mindenütt lesz futtatható. Pontosabban, kétféle programírásra kell felkészülnünk: lesz olyan, amit ténylegesen az ASIC/FPGA számára szánunk, és olyan, amit számítógépünkön, egy szimulációs környezetben fogunk használni. Ez a kiíratás csak az utóbbi rendszerben lehetséges. Ezt a "program" írásakor nagyon érdemes szem előtt tartani, és a forráskódot eleve úgy írni, hogy külön fájlokban szerepeljenek a csak a szimulátorban végrehajtható kódok. A segédprogramok vagy hibát jeleznek a nem odaillő utasításra, vagy figyelmen kívül hagyják azt (természetesen a fordítóprogram nem tudhatja, hol akarjuk a készített kódot futtatni).

61 Szakasz 1: A Hello Világ program 61 Még egy szokatlan elemmel hangolódhatunk a nyelvre: mivel az elektronikus elemek egymással párhuzamosan működnek, azt is meg kell mondanunk, hogy mikor fusson az illető "program" blokk. Ebben az esetben kezdetben (az áramkör bekapcsolásakor). Természetesen ez csak egy kis ízelítő. Most megismerkedünk pár nyelvi elemmel. Néhol teljes alaki és funkcionális azonosságot találunk a C nyelvi elemekkel. Ne feledjük, ez inkább csak esetleges: áramkört programozunk, nem pedig programot írunk!

62 Szakasz 2: Nyelvi elemek Nyelvi elemek Mivel hardver leíró nyelvet tárgyalunk, az alapegységnek és annak paramétereinek külön neve és szerepe van. Modul A modul egy hardver blokkot ábrázol, jól definiált kimenetekkel és bemenetekkel, valamint jól definiált feladattal, lásd.?? ábra és III.2 lista. A modul két részből áll. A port deklarációk a modul külső interfészét reprezentálják. A modul többi része egy belső leírás: a viselkedése, a szerkezete, vagy e kettő keveréke. Port A module kulcsszó után a modul neve áll (a példában AOI), majd a port nevek listája következik. Egy port egy IC lábnak, a kártya egy élcsatlakozójának, vagy egy logikai kommunikációs csatornának felel meg egy hardverblokk esetén. Az egyes port deklarációk egy vagy több port nevet tartalmaznak (például: A, B,...), továbbá megadják, hogy az információ melyik irányból folyhat át a portokon (input, output vagy inout).

63 Szakasz 2: Nyelvi elemek 63 Programlista III.2: Egy modul ami AND-OR-INVERT kaput ír le // Egy AND OR INVERT kapu module AOI (A, B, C, D, F) ; input A, B, C, D; output F; assign F = ~((A&B) (C&D) ) ; endmodule Ez a sor adja meg a funkcionalitást Az eddig látott Verilog szabályok: A C-vel megegyezően, egysoros és többsoros megjegyzések vannak. A // karakterek jelzik az egysoros megjegyzés (komment) kezdetét; a sor további része elhanyagolódik. Hagyományosan egysoros kommenteket használunk dokumentálásra; a többsorost pedig kódrészek átmeneti kiiktatására. Az utasításokat ";" zárja le. Érdemes soronként csak egyetlen utasítást írni, és az utasításokat bekezdésekkel úgy formázni, hogy az mutassa a kód szerkezetét.

64 Szakasz 2: Nyelvi elemek 64 Az azonosítókban megkülönböztetjük a kis és nagybetűt. A felhasználó által definiált nevekben egyaránt lehetnek kis- és nagybetűk, de ezek különbözőnek számítanak. A kulcsszavak kisbetűsek Minden definíció és utasítás a modulba kerül Szójegyzék: assign A modul egy folyamatos értékadó utasítást tartalmaz, ami egyúttal a modul funkcióját is megadja. Azért nevezik folyamatosnak, mert a bal oldal folyamatosan frissül, hogy tükrözze a jobb oldali kifejezés értékét. A szimuláció során a folyamatos értékadó utasítás akkor hajtódik végre, amikor a jobb oldalon szereplő négy port, A, B, C és D valamelyikének értéke megváltozik. Általában véve, egysoros kommenteket (//) érdemes használnunk, még akkor is, ha több egymás utáni sort akarunk megjegyzésként

65 Szakasz 2: Nyelvi elemek 65 III.1. ábra. Az eddigi nyelvi szabályok c 2001, Doulos [2]

66 Szakasz 2: Nyelvi elemek 66 Szójegyzék: Operátor Ebben a példában a folyamatos értékadás három operátort használ, amelyek: &, és ~ sorjában bitenkénti és, vagy és nem műveletet jelentenek. Az operátorokat és kifejezéseket később tárgyaljuk. kezelni. Csak akkor használjunk blokk kommentet, ha nagyon sok sort akarunk megjegyzésként kezelni (pl. egy egész modult). Ez azért van, mert a blokk kommenteket nem lehet egymásba ágyazni: a belső blokk komment vége (*/) a külső komment végeként értelmeződik! A blokk kommenten belül azonban az egysoros kommentek a blokk komment részét képezik, lásd III.3 lista. A modulok, portok, stb. nevét azonosítónak nevezik. Az azonosítók bármilyen hosszúak lehetnek, és betűkből, számokból, aláhúzásjelből (_), valamint dollárjelből ($) állhatnak. Az első karakter csak betű vagy aláhúzás lehet.

67 Szakasz 2: Nyelvi elemek 67 Programlista III.3: Megjegyzések használata a Verilog programokban / Beágyazhatunk // ilyen egysoros kommenteket // többsoros ( blokk ) kommentbe / / Nem tehetünk azonban / blokk kommentet / másik blokk kommentbe / Programlista III.4: Azonosítók használata a Verilog programokban AB Ab ab ab // Ez mind más azonosító Y Y Y //Ezek pedig eltérőek G4X$6_45_123$ // Ez i s l e g á l i s 4plus4 $1 //Ez viszont hibás \4 plus4 \$1 \a+b$\%^& ( // Kivételes azonosítók

68 Szakasz 2: Nyelvi elemek 68 A kis- és nagybetűk különböznek, azaz ha két azonosítóban nem egyformán használjuk a kis- és nagybetűket, a két azonosító különböző lesz. Egy kivételes azonosító fordított törtvonallal (\) kezdődik és nemnyomtatódó karakterrel (betűköz, tabulátor vagy új sor) zárul. Nem nyomtatódó karakter kivételével bármit tartalmazhat. A kivételes azonosítókra a Verilog kódot előállító segédeszközök miatt van szükség, mivel ezek elnevezési konvenciói nagyon eltérőek lehetnek. Ilyenek például a séma szerkesztők és a szintézis eszközök. Kulcsszavak and default event function wire Nagyszámú olyan fenntartott azonosító van, amelyet nem használhatunk névként. Ezek teljes listája az III.1 táblázatban található. Az eddig tárgyalt modulok elég egyszerűek voltak ahhoz, hogy a bemenetek függvényében a kimenetet egyetlen folyamatos értékadással tudjuk megadni. A valódi modulok ennél sokkal bonyolultabbak,

69 Szakasz 2: Nyelvi elemek 69 III.1. táblázat. A Verilog fenntartott azonosítói and endfunction join pull0 supply0 wire always endprimitive large pull1 supply1 wor assign endmodule macromodule rcmos table xnor begin endspecify medium real task xor buf endtable module realtime tran bufif0 endtask nand reg tranif0 bufif1 event negedge release tranif1 case for nor repeat time casex force not mmos tri casez forever notif0 rpmos trian cmos fork notif1 rtran trior deassign function nmos rtranif0 trireg default highz0 or rtranif1 tri0 defparam highz1 output scalared tri1 disable if parameter small vectored edge ifnone pmos specify wait else initial posedge specparam wand edge inout primitive strength weak0 end input pulldown strong0 weak1 endcase integer pullup strong1 while

70 Szakasz 2: Nyelvi elemek 70 ott belső összekötésekre is szükség van. Hogy egy belső jelnek (l. III.5 lista betét ábrája) folyamatos értékadással értéket adjunk, a jelet először vezetékként kell deklarálnunk. Egy vezeték deklarációja ugyanolyan, mint egy porté (lásd III.5 lista), de típussal (wire), esetlegesen vektormérettel és egy névvel, vagy nevek listájával. (A vektorokkal kicsit később foglalkozunk) A portok alapértelmezetten vezeték típusúak, ezért az F wire deklarációja opcionális. A többi deklaráció viszont szükséges. Rövídítésként, egyetlen utasítással is tudunk egy vezetéket deklarálni és/vagy annak értéket adni. A két módszer között csak annyi a különbség, hogy az utóbbi csökkenti a programszöveg méretét, lásd III.6 lista. Egy vezeték értékadásakor a késleltetés a megfelelő folyamatos értékadás késleltetésével egyenértékű, nem pedig a vezeték késleltetésével. Emiatt szükség lehet arra, hogy a vezeték értékadást elválasszuk a folyamatos értékadástól, úgy, hogy a késleltetést nem az értékadáshoz, hanem a vezetékhez rendeljük. Ez azonban olyan

71 Szakasz 2: Nyelvi elemek 71 Programlista III.5: Egy modul ami AND-OR-INVERT kaput ír le; belső jelekkel module AOI (A, B, C, D, F) ; input A, B, C, D; output F; wire F; // Alapértelmezett wire AB, CD, O; // Ez viszont k e l l assign AB = A & B; assign CD = C & D; assign O = AB CD; assign F = ~O; // Az assign csak wire nek adhat értéket! endmodule

72 Szakasz 2: Nyelvi elemek 72 Programlista III.6: Az AND-OR-INVERT modul többszörös értékadással module AOI (A, B, C, D, F) ; input A, B, C, D; output F; / wire F; wire AB, CD, O; assign AB = A & B; assign CD = C & D; assign O = AB CD; assign F = ~O; / // Ezzel ekvivalens assign AB = A & B, CD = C & D, O = AB CD, F = ~O; endmodule

73 Szakasz 2: Nyelvi elemek 73 Programlista III.7: Az AND-OR-INVERT modul többszörös deklarációval module AOI (A, B, C, D, F) ; input A, B, C, D; output F; / wire AB = A & B; wire CD = C & D; wire O = AB CD; wire F = ~O; / // Ezzel ekvivalens wire AB = A & B, CD = C & D, O = AB CD, F = ~O; endmodule

74 Szakasz 2: Nyelvi elemek 74 finomkodás, amivel aligha találkozunk a gyakorlatban! Az III.6 lista a Verilog szintaxisának azt a tulajdonságát is illusztrálja, hogy egynél több deklaráció, példány vagy folyamatos értékadás esetén a műveletnek és a deklarált, példányosított vagy értéket kapó objektumnak ugyanolyan típusúnak kell lennie. Ebben az esetben vagy több (pontosvesszővel elválasztott) egyedi utasítást használunk, vagy pedig egyetlen utasításban több deklarációt vagy értékadást (vesszővel elválasztva), lásd III.7 lista. A net (összekötés) típus a Verilog három fő adattípusának egyike. A másik kettő a regiszter és a paraméter adattípus; ezeket később tárgyaljuk. Az összekötések az elektromos áramkör pontjai közötti elektromos összekötéseket ábrázolják. Az összekötéseknek 8 típusa van, ezek egyike a wire, lásd III.2 táblázat. A net alapértelmezett típusa a wire. A Verilog nyelvben van még hét másik féle típus is, amelyek másféle elektromos jelenségnek felelnek meg. A többi típus bizonyos egyedi esetek modellezésekor fontos. Használatukra példa:

75 Szakasz 2: Nyelvi elemek 75 III.2. táblázat. Az összekötések típusai wire, tri Ordinary net, tristate bus wand, triand Wired and wor, trior Wired or tri0 Pulldown resistor tri1 Pullup resistor trireg Capacitive charge storage supply0 Ground supply1 Power

76 Szakasz 2: Nyelvi elemek 76 wire a, b, c; // Alapertelmezett wand p,q,r; supply0 Gnd; Az összekötési lista definiálatlan nevei alapértelmezetten egybites vezetékként értelmeződnek, és nagy valószínűséggel, a összekötéseink 99 %-a wire típusú lesz.

77 Szakasz 2: Nyelvi elemek 77 Megjegyzés: Egyéb típusok wire, tri A wire (szinonimája a tri) vagy egy pont-pont közötti elektromos összeköttetést modellez, vagy egy több meghajtóval rendelkező háromállapotú buszt. Busz konfliktus esetén a vezeték értéke bx lesz. wand, wor A wand (szinonimája a triand) és a wor (szinonimája a wor) AND illetve OR kapuként viselkednek, amikor a hálózatban egynél több meghajtó van. tri0, tri1 A tri0 és tri1 összekötések úgy viselkednek, mintha a vezetékhez egy felhúzó vagy lehúzó ellenállást kapcsoltunk volna, azaz amikor a hálózatban nincs meghajtó, az összekötés 0-hoz vagy 1-hez lebeg. Hasonló esetben egy wire értéke z lenne. trireg A trireg összekötés kapacitív töltés tárolást és kisütést modellez. Amikor egy trireg összekötésen nincs meghajtó, az megőrzi előző értékét. trireg összekötéseket kapcsolószintű

78 Szakasz 3: Hierarchia megvalósítása Hierarchia megvalósítása A modulok hivatkozhatnak más modulokra, így egy hierarchiát hoznak létre. Az III.8 listán, a MUX2 modul hivatkozik az alacsonyabb szintű modulokra, és leírja a közöttük levő kapcsolatot. A betét ábrán egy 2:1 multiplexert látunk, ami egy AOI kapuból és két inverterből áll. A Verilog zsargonjában az alacsonyabb szintű modulra való hivatkozást egy modul példányosításának (példány készítésnek) hívják. Mindegyik példány független, egyidejűleg aktív kópiája az eredeti modulnak. (Másik hardver egység és nem szubrutin hívás!) Az egyes modul példányok tartalmazzák a modul nevét (pl. AOI vagy INV), a példány nevét (ami abban a modulban egyedi név) és egy port összekötés listát. A példánynak szükséges nevet adni, hogy ugyanazon modul több példányát meg tudjuk különböztetni, lásd a III.8 listán az INV modult. Az előző példában egy INV modult példányosítottunk. Valójában azonban nem kell saját inverter modult írnunk: a Verilog nyelvbe be

79 Szakasz 3: Hierarchia megvalósítása 79 Programlista III.8: Példa modul hierarchiára sorrendi leképezéssel module AOI (A,B,C,D, F) ;... endmodule module INV (A, F) ;... endmodule module MUX2 (SEL,A,B, F) ; input SEL, A, B; output F; INV G1 (SEL, SELB) ; // Modul példány AOI G2 (SELB,A, SEL,B,FB) ; // Sorrendi leképezés // SELB es FB implicit wire típusúak! INV G3 (FB, F) ; // Másik modul példány endmodule

80 Szakasz 3: Hierarchia megvalósítása 80 Programlista III.9: Példa modul hierarchiára név szerinti leképezéssel module AOI (A,B,C,D, F) ;... endmodule module INV (A, F) ;... endmodule module MUX2 (SEL,A,B, F) ; input SEL, A, B; output F; INV G1 (.A(SEL),. F(SELB) ) ; // Név szerinti leképezés AOI G2 (.A(SELB),.B(A),.C(SEL),.D(B),.F(FB) ) ; INV G3 (.F(F),.A(FB) ) ; // A sorrend nem számit endmodule

81 Szakasz 3: Hierarchia megvalósítása 81 Szójegyzék: Sorrendi leképezés A modul port összekötéseket sorrendben adjuk meg, és a sorrendet a példányosítandó modul első sorából származtatjuk. A lista első elemét a modul első portjához kapcsoljuk, és így tovább. (Ordered mapping) Programlista III.10: Példa modul hierarchiára primitívek használatával module MUX2 (SEL,A,B, F) ; input SEL, A, B; output F; not G1 (SELB, SEL) ; // Primitív példánya AOI G2 (SELB,A, SEL,B,FB) ; not ( F,FB) ; // A példány neve opcionális endmodule

82 Szakasz 3: Hierarchia megvalósítása 82 Szójegyzék: Implicit vezetékek Minden olyan nevet, amelyet port összekötés listában használunk, de nem deklarálunk sehol, a fordító implicit módon egybites vezetékként deklarál. Ez nagyon fontos nagyon sok hiba forrása lehet! van építve néhány beépített primitív, avagy kapu; lásd?? ábra és III.10 lista. Ezek a primitívek egyszerű logikai kapukat, háromállapotú puffereket, felhúzó és lehúzó ellenállásokat, valamint számos egyirányú és kétirányú kapcsolót modelleznek. A primitíveket kiterjedten használják kapuszintű és kapcsolószintű modellekben; például könyvtárak és felhasználó-definiálta ASIC áramkörök modellezésekor. Néha más alkalmakkor is hasznosan alkalmazhatunk primitíveket, bár általában előnyösebb folytonos értékadást használni.

83 Szakasz 3: Hierarchia megvalósítása 83 Szójegyzék: Név szerinti leképezés A portok helyes sorrendben való felsorolása mellett egy másik lehetőség a portok név szerinti leképezése. Itt a kapcsolat úgy jön létre, hogy (egy pontot elébe téve) megadjuk a modul portjának a nevét, és zárójelben odaírjuk annak a vezetéknek vagy regiszternek a nevét, amelyiket ahhoz a porthoz kell kapcsolni, lásd III.9 lista. Mivel itt portok nevét adjuk meg, nem lényeges, hogy azok milyen sorrendben jelennek meg. A név szerinti leképezést általában előnyben részesítik a sorrendi leképezéssel szemben, mert egyszerűbb megérteni és nehezebb hibázni. A primitíveket ugyanúgy használhatjuk, mint a modulokat, attól eltekintve, hogy nem szükséges nevet adni nekik. (Ha akarunk, azért adhatunk, lásd III.10 lista.) Emellett, primitívek esetén nem használhatunk név szerinti leképezést sem: ismernünk kell a portok

84 Szakasz 3: Hierarchia megvalósítása 84 sorrendjét. Segítségünkre van az a tény, hogy az output portok mindig megelőzik az input portokat. Ha sorrendi leképezést használunk, egy modul példány bizonyos portjait bekötetlenül hagyhatjuk olyan módon, hogy kihagyjuk azokat a bekötési listából. A helyet két egymás után tett vesszővel hagyhatjuk üresen. Név szerinti leképezés esetén kétféle módon is bekötetlenül hagyhatunk egy portot: teljesen elhagyjuk a portot a portot ugyan szerepeltetjük, de üresen hagyjuk a zárójelet A portok (és vezetékek) egyaránt ábrázolhatnak nemcsak egyes biteket, hanem buszokat (avagy vektorokat) is. Az III.12 listán és a betétz ábrában mutatott példában a SEL port egy kétbites busz, a nagyobb helyértékű bit (MSB) az 1. számú bit és a kisebb helyértékű bit (LSB) a 0.

85 Szakasz 3: Hierarchia megvalósítása 85 Programlista III.11: Példa be nem kötött portok használatára module AOI (A,B,C,D, F) ; input A, B, C, D; output F;... endmodule module... AOI AOI1 (W1,W2,,W3,W4) ; // Nincs bekötve a C port / Ezzel egyenertékű leírások : AOI AOI1 (.F(W4),.D(W3),.B(W2),.A(W1) ) ; AOI AOI1 (.F(W4),.D(W3),.B(W2),.A(W1),.C() ) ; / endmodule

86 Szakasz 3: Hierarchia megvalósítása 86 Programlista III.12: Példa vektor port használatára module MUX4 (SEL,A, B, C, D, F) ; input [ 1 : 0 ] SEL; // különálló input A, B, C, D; // input deklaráció output F; //... endmodule vagy Ezzel egyenértékűen, a SEL így is deklarálható: input [0:1] SEL; input [1:2] SEL; stb. Minden esetben a megadott tartomány bal oldali bitje az MSB, a tartományban szereplő aktuális értékek nem játszanak szerepet. A későbbiekben látni fogjuk, hogy a vektor elemei előjel nélküli számként értelmeződnek; ezért fontos figyelembe vennünk, hogy a baloldali bit

87 Szakasz 3: Hierarchia megvalósítása 87 a legnagyobb helyértékű. A Verilogban négyféle beépített logikai érték van. Az egybites értéket egy egybites egész literális ábrázolja. Ez az 1 értékből (az egybites hosszúság jelölésére), a b kombinációból (a bináris típus jelölésére), valamint a (0, 1, X vagy Z) betűk valamelyikéből áll. Szójegyzék: Verilog logikai érték 1 b0 - logikai 0, false, föld 1 b1 - logikai 1, true, tápfesz 1 bx - ismeretlen vagy inicializálatlan 1 bz - nagy impedanciájú, lebegő Egy vektor egyes bitjeit külön is kiolvashatjuk vagy azoknak értéket adhatunk, ha szögletes zárójelben megadjuk a bit számát. Például, V[7] a V vektor hetedik bitjét jelenti (ami ez esetben az MSB), lásd III.2 ábra. Ez a műveletet bitválasztásnak (bit select) is

88 Szakasz 3: Hierarchia megvalósítása 88 Szójegyzék: Logikai érték vektor A Verilog értékvektor egyszerűen logikai értékek sorozata (0, 1, X és Z). Az értéket megelőzi a vektor bitjeinek száma és a számrendszer alapjának jele. Például, 8 bxxxx0101 egy nyolcbites bináris érték. A vektor neve az egész vektort jelenti. nevezik. A reg [7:0] V deklaráció magyarázatát lásd alább. Egy rész kiválasztás egy vektor folytonos index tartományú részének kiválasztását jelenti, pl. V[2:5]. A részkiválasztásokat arra használjuk, hogy vektor egy részét kiolvassuk vagy annak értéket adjunk. A vektoros értékadás balról jobbra, bitenként hajtódik végre, így a W = V[2:5] értékadás eredménye W[3]=V[2], stb., lásd III.3 ábra. A W[1:0] = 2 b11; értékadás W[3] és W[2] értékét változatlanul

89 Szakasz 3: Hierarchia megvalósítása 89 III.2. ábra. Példa logikai érték használatára c 2001, Doulos [2]

90 Szakasz 3: Hierarchia megvalósítása 90 III.3. ábra. Példa vektor részének kiválasztására c 2001, Doulos [2]

91 Szakasz 3: Hierarchia megvalósítása 91 hagyja. Egy vektor értéktartománya egyaránt lehet növekvő (pl. [0:7]) és csökkenő (pl. [3:0]). A kiválasztott résztartomány csak ugyanolyan irányú lehet, mint amilyen az eredeti deklarációban szerepel. Így a W[0:1] kifejezés illegális, mivel W csökkenő irányú tartománnyal van deklarálva. Megengedett egyetlen bitet jelölő tartomány (pl. W[2:2]) kiválasztása is.

92 Szakasz 4: Testbench modul Testbench modul Egy teszt fixtúra olyan Verilog modul, amelyik egy terv szimulációs környezetét írja le. Általában teszt vektorok előállítására és az eredmények analizálására szolgáló kódot tartalmaz (vagy összehasonlítja az eredményeket az elvárt kimenettel). Tartalmazza a tesztelendő modul egy példányát is. Bár a teszt fixtúra a Verilog világban általánosan elfogadott kifejezés, a test bench is használatos ugyanilyen értelemben. A III.13 lista a MUX4 modul tesztelésére szolgáló teszt fixtúra szerkezetét mutatja. A teszt fixtúra tartalmaz két initial utasítást (az egyik a teszt stimulus tényleges használatát mutatja, a másikat az eredménytáblázat nyomtatására használjuk), valamint a vizsgálandó modul egy kópiáját. A teszt fixtúrák közös jellemzője, hogy nem tartalmaznak portokat. Az initial blokk a Verilog procedurális blokkjainak egyike (a másik az always blokk). A procedurális blokkokat viselkedés leírására használják, különböző szituációkban. A?? ábrán és a III.14

93 Szakasz 4: Testbench modul 93 Programlista III.13: A MUX4 modul tesztelésére szolgáló teszt fixtúra module MUX4TEST; // nincsenek portok... // deklarációk i n i t i a l... // A bemenő j e l e k leirása MUX4 M ( // A v i z s g á l t modul.sel(tsel),.a(ta),.b(tb),.c(tc),.d(td),.f(tf) ) ; i n i t i a l... // Az eredmények kiíratása endmodule

94 Szakasz 4: Testbench modul 94 listán az initial blokk a terv stimulusát avagy test patternjeit írja le. Az initial blokk végrehajtása a szimuláció kezdetekor indul (nulla időpontban) és a begin és end közötti utasítások felülről lefelé, sorban egymás után hajtódnak végre. #10 egy 10 egység hosszú eljárás késleltetés. Egy eljárás késleltetés a megadott periódusra felfüggeszti az initial blokk végrehajtását. Az egyes események végrehajtását nulla, egy vagy több késleltetés előzheti meg. Ezek az utasítás részei, nem kell utánuk pontosvesszőt írni (bár megengedett): #10 A = 0; ugyanaz, mint #10; A = 0; (kivéve, hogy az utóbbi két utasításnak felel meg) A SEL = 2 b00 és A = 0 utasítások procedurális értékadások. A Verilog lehetővé teszi, hogy az 1 b0 és 1 b1 formátumú számok helyett

95 Szakasz 4: Testbench modul 95 rövidítésként a 0 és 1 egész értékeket használjuk. Programlista III.14: Példa a tesztjelek előállítására // Egyszer hajtódik végre, f e l ü l r ő l l e f e l é i n i t i a l // Stimulus begin TSEL = 2 b00 ; #10 TA = 0 ; // 1 b0 röviden #10 TA = 1 ; #10 TSEL = 2 b01 ; #10 TB = 0 ; // Procedurális értékadás // ^ Procedurális k é s l e l t e t é s end Eddig csak vezeték (wire) típusú érték tárolással és továbbítással foglalkoztunk, ez a legelterjedtebb összekötési mód. Van azonban a Verilogban egy másik adattárolási mód is: a regiszter. A regiszter itt nem feltétlenül egy hardver regisztert (pl. flip-flop) jelent. Regisztereket használnak a viselkedés leírására a procedurális

96 Szakasz 4: Testbench modul 96 blokkokban (initial és always). A wire és register közötti választás szabálya egyszerű, mégis sok félreértésre ad okot: regisztert csak procedurális blokkokban használunk, és procedurális blokkokban csak regisztereknek adhatunk értéket, lásd III.15 lista. Az összekötések vagy folyamatos értékadással, vagy porton keresztül kapnak értéket. Regisztereket a reg kulcsszóval deklarálunk. Később majd más típusú regisztereket is látni fogunk. A második initial blokk végzi az eredmények analízisét. Ez az initial blokk tartalmaz egy $monitor rendszertaszk hívást. Bár a $monitor hívás csak egyszer szerepel (a 0 időpontban), a hívás létrehoz egy monitort, ami mindaddig aktív marad, amíg ki nem kapcsoljuk vagy a szimuláció be nem fejeződik. A $monitor hívás első argumentuma a $time rendszerfüggvény. A $monitor további argumentumai kifejezések. Valamennyi kifejezés értéke kiíródik, amikor azok valamelyike megváltozik. Egy szünet a listában (két egymás utáni vessző) hatására egy betűköz karakter íródik ki. A $monitor hívást tartalmazó initial blokk nem tartalmaz begin

97 Szakasz 4: Testbench modul 97 Programlista III.15: Példa regiszterek használatára module MUX4TEST; reg TA, TB, TC, TD; // egyfajta regiszter reg [ 1 : 0 ] TSEL; wire TF; i n i t i a l // Stimulus begin TSEL = 2 b00 ; #10 TA = 0 ; #10 TA = 1 ; #10 TSEL = 2 b01 ; #10 TB = 0 ;... end MUX4 M (.SEL(TSEL),.A(TA),.B(TB),.C(TC),.D(TD),.F(TF ) ) ;... endmodule

98 Szakasz 4: Testbench modul 98 és end sorokat. Ezek itt nem szükségesek, mivel az initial blokkban csak egyetlen utasításunk van (a $monitor hívás). Ettől függetlenül, kiírhatjuk azokat. Az első initial blokkban a begin és end szükségesek, mivel ott egynél több utasításunk van. Teszteléskor a vizsgált egységre megfelelő stimulusokat adunk és az vizsgáljuk, hogy az elvárt választ kapjuk-e. Ennek egyik módja eredménytáblázat kiíratása. A III.17 listán bemutatott program által kiírt eredménytáblázat (az előállított vizsgáló jeleket lásd a?? ábrán): Szójegyzék: Rendszertaszk A rendszertaszkok be vannak építve a Verilog nyelvbe (és a szimulátorba) és különféle hasznos funkciókat végeznek. A nevük mindig $ jellel kezdődik. A text fixtúra modulban deklarációk és utasítások vannak, de

99 Szakasz 4: Testbench modul 99 Programlista III.16: Példa eredmények kiíratására module MUX4TEST; reg TA, TB, TC, TD; reg [ 1 : 0 ] TSEL; wire TF; i n i t i a l // Stimulus begin #10 TA = 1 ; #10 TSEL = 2 b01 ; TSEL = 2 b00 ; #10 TA = 0 ; 0 0 XXXX X XXX XXX XXX X #10 TB = 0 ; end MUX4 M (.SEL(TSEL),.A(TA),.B(TB),.C(TC),.D(TD),.F(TF ) ) ; i n i t i a l // Kiíratás $monitor ( $time,,tsel,,ta,tb,tc,td,,tf) ; // A $monitor rendszer taszk, a $time rendszer függvény endmodule

100 Szakasz 4: Testbench modul 100 Szójegyzék: $monitor A $monitor rendszertaszk egy sornyi szöveget ír a szimulátor naplójába (ami egy ablak és/vagy egy fájl) minden alkalommal, amikor valamilyen esemény történik, azaz amikor az argumentumaként feltüntetett reg vagy wire típusú értékek valamelyike megváltozik. nincsenek portok. A modul három fő utasítása konkurrens (azaz egymással párhuzamosan hajtódnak végre); nem számít, milyen sorrendben írjuk le azokat. Másrészt viszont az adattípusokat (wire, reg, stb.) használat előtt deklarálnunk kell! Egy initial blokk egyetlen utasításnak tekintendő, még ha procedurális utasítások sorozatát tartalmazza is. Az első initial blokk utasításait a begin... end zárójelezi; a közöttük levő utasítások felülről lefelé, sorban hajtódnak végre.

101 Szakasz 4: Testbench modul 101 Szójegyzék: A $time rendszerfüggvény A rendszertaszkokhoz hasonlóan, a rendszerfüggvények is be vannak építve a Verilog nyelvbe (és szimulátorba). A rendszertaszkoktól eltérően, a rendszerfüggvények egy értéket adnak vissza, ebben az esetben azt a szimulált időt, amikor egy esemény kiváltotta, hogy a $monitor egy sort írjon ki (természetesen a szimulációs idő változása nem triggereli a $monitor rendszertaszkot). Mivel a második initial blokk csak egyetlen utasítást tartalmaz, a begin... end utasítások nem szükségesek.

102 Szakasz 4: Testbench modul 102 Programlista III.17: A teljes testbench modul module MUX4TEST; reg TA, TB, TC, TD; reg [ 1 : 0 ] TSEL; wire TF; i n i t i a l begin TSEL = 2 b00 ; #10 TA = 0 ; #10 TA = 1 ; #10 TSEL = 2 b01 ; #10 TB = 0 ; #10 TB = 1 ;... end MUX4 M (.SEL(TSEL),.A(TA),.B(TB),.C(TC),.D(TD),.F(TF ) ) ; i n i t i a l $monitor ( $time,,tsel,,ta,tb,tc,td,,tf) ; endmodule

103 Szakasz 4: Testbench modul 103

104 Számok, vezetékek, regiszterek 104 fejezet IV: Számok, vezetékek, regiszterek Ebben a fejezetben (az előző "gyorstalpaló" után) elkezdjük rendszerezetten megismerni a Verilog nyelv alapelemeit.

105 Szakasz 1: Számok, vezetékek és regiszterek Számok, vezetékek és regiszterek Erre a szakaszra azért érdemes odafigyelni, mert eddigi programozási tanulmányaink alatt fix bithosszúságú számokhoz szoktunk hozzá, és hogy egy bitnek csak kétféle értéke lehet. A Verilogban egyik sem teljesül. Programlista IV.1: Számok megadása a Verilogban // A számokban kis és nagybetűk felcserélhetők reg [ 7 : 0 ] V; // Bináris 111xx00 V = 8 b111xx000 ; // _ elhanyagolódik számokban V = 8 B111X_X000; // Binary 111xx00 V = 8 hff; // Hex = 8b 1111_1111 // Bevezető 0k adódnak a számhoz V = 8 o77 ; // Octal = 8b 00_111_111 V = 8 d10 ; // Decimal = 8b 0000_1010

106 Szakasz 1: Számok, vezetékek és regiszterek 106 A számokat nem bájt, word, stb méretűként, hanem tetszőleges hosszúságú bit vektorként ábrázoljuk. A vektor értékeket olyan egész literálisként írhatjuk fel, amelyik a 0, 1, X és Z karaktereket tartalmazza, előtte pedig a szélességet megadó számot (a bitek számát), valamint bináris számok esetén a b kombinációt (pl. 8 b0101xxxx), lásd IV.1 lista. Számok más számrendszerben való megadásához a o (oktális), d (decimális) vagy h (hexadecimális) kombinációt használhatjuk. A számok a hosszú számok tagolására, a jobb olvashatóság érdekében tartalmazhatnak aláhúzás karaktereket, ezek egyszerűen elhanyagolódnak. A számokban (a számrendszer alap és a számjegyek megadásakor is) egyaránt használhatunk kis- és nagybetűket. Ha nem adjuk meg egy szám valamennyi jegyét, a legnagyobb helyértékű bitek nullával töltődnek fel. Például, 8 o77 megfelelője 8 b00_111_111. Láttuk, hogy ha nem adjuk meg egy szám valamennyi jegyét, a legnagyobb helyértékű bitek nullával töltődnek fel. Azonban, ha a legnagyobb helyértékű bit X vagy Z, a hiányzó bitek ennek megfelelően X vagy Z értékekkel töltődnek fel. Így tehát 8 bx valójában a

107 Szakasz 1: Számok, vezetékek és regiszterek 107 Programlista IV.2: Számok csonkítása és kiterjesztése reg [ 7 : 0 ] V; // Bináris 111xx00 V = 8 bx; //8 bxxxxxxxx V = 8 bzx; //8 bzzzzzzzx // Nincs e l ő j e l k i t e r j e s z t é s! V = 8 b1 ; // 8b V = 1 hff; // 1 hff = 1 b1 ( csonkítás ) = 8 h01 ( k i t e r j e s z t é s )

108 Szakasz 1: Számok, vezetékek és regiszterek bxxxx_xxxx számot ábrázolja, 8 bzx pedig a 8 bzzzz_zzzx számot, lásd IV.2 lista. A reg és wire értékeket előjel nélküli egésznek kell tekinteni, még akkor is, ha kifejezésekben negatív számokat is használhatunk. Vigyáznunk kell, mert itt nincs előjelkiterjesztés. Általában véve, a Verilog csendben megcsonkítja vagy nullával feltölti a vektorokat, amikor rossz méretet adunk meg. Emiatt, az IV.2 programlistán mutatott példában 1 hff csonkított értéke 1 b1 (mivel a szám egy bitnyi széles), és az 1 b1 érték terjesztődik ki nyolc bitre, balról nullákkal kiegészítve (mivelhogy egy egybites értékkel (1 h...) adunk értéket egy 8-bites vektornak (V)). A Verilogban mindig nagyon vigyáznunk kell a vektorok csonkítására! Az eddigi példák jól láthatóan bináris számoknak tűntek (azaz csak a 0, 1, X és Z jegyeket tartalmazták). Az IV.3 programlistában bemutatott számok is binárisak, még ha ez kevésbé nyilvánvaló is. A 10 egy 32 bites decimális szám és nem egy kétbites bináris szám! A -3 is egy 32-bites decimális szám, és kettes komplemens formában

109 Szakasz 1: Számok, vezetékek és regiszterek 109 Programlista IV.3: Megtévesztő bináris számok // Megtévesztő számok reg [ 7 : 0 ] V; // Nem bináris V = 1 0 ; // 10 = d10 = 32 d10 = 32 b1010 => 8 b V = 3; // 3 = 32 hff_ff_ff_fd => 8 b1111_1101 V = "A" ; // ASCII = 8 d65 => 8 b értelmeződik. A Verilog azonban a V értékét előjel nélküli 8-bites értéknek (azaz 253-nak) tekinti. A stringek vektorokká alakításakor a karakterek 8-bites ASCII kódja szolgál alapul. Ha nem adunk meg semmit, a számok alapértelmezett szélessége 32 bit. (Szigorúan véve, az alapértelmezett értéket a szimulátor vagy szintézis eszköz implementációja határozza meg, ez azonban a gyakorlatban szinte mindig 32 bit.) Ez váratlan eredményekhez vezethet, ha 32 bitnél szélesebb wire vagy reg adatokkal dolgozunk.

110 Szakasz 1: Számok, vezetékek és regiszterek 110 Programlista IV.4: Számok, 32 biten túl // 32 b i t e t túllépő értékek kezelése reg [ 7 : 0 ] V; reg [ 6 3 : 0 ] R; // R[63:8] = 56 b0, R[ 7 : 0 ] = V (extended) R = V; // V = R[ 7 : 0 ] ( truncation ) V = R; // 64 h zzzzzzzz R = bz ; // 32 b i t az alapértelmezett

111 Szakasz 1: Számok, vezetékek és regiszterek 111 Az alsó példában az IV.4 programlistán az R, ami egy 64-bites érték, olyan szám értékét kapja meg, ami maga csak 32 bit szélességű. A számokat 64-bitre nullákkal terjesztjük ki. Megjegyezzük, hogy szám kiterjesztésekor X és Z értékeket csak a megadott vagy alapértelmezett méretig használunk; amikor egy értéket reg vagy wire változóhoz rendelünk, akkor nem. Más szavakkal: a Verilog fordító nem "nézi meg" az értékadás jobboldalát, amíg az X vagy Z értékekkel való kiterjesztés be nem fejeződött. Szójegyzék: $display A $monitor mellett a $display a másik rendszertaszk, amelyik a szimulátor naplófájljába írni tud. A $display csak egyszer ír a naplófájlba, közvetlenül a hívás után, és nem hoz létre egy folytonos monitort. A $display és a $monitor kimenete speciális karakterekkel formázható; a karaktereket string argumentumként adjuk át. Az egyes

112 Szakasz 1: Számok, vezetékek és regiszterek 112 Szójegyzék: $time $time olyan rendszer függvény, amelyik a szimulációs időt adja vissza. %b, %d formátumleírók a listában szereplő következő argumentum (megfelelően formátumozott) értékével helyettesítődnek. A formátumleíró stringek: %b bináris %o oktális %d decimális %h hexadecimális %s ASCII string %v érték és meghajtási erősség %t idő (lásd később)

113 Szakasz 1: Számok, vezetékek és regiszterek 113 %m modul példány \n újsor \t tab \" " \nnn nnn a karakter ASCII kódjának értéke, oktálisan \\ \ A fentiek a $display és $monitor által értelmezett formátumleírók. Escape karakterként a fordított törtvonalat használják. Ha stringben ilyen fordított törtvonalat kell kiíratnunk, a formátumot előíró stringben két egymás utáni fordított törtvonalat kell írnunk. Hasonlóképpen, ha literálisként egy kettős idézőjelet kell kiíratnunk, azt is egy fordított törtvonal után kell írnunk. (Egyébként a " a stringet lezáró karakterként értelmeződik.) Például, $display("the file is \"C:\\Files\\File.txt\"");

114 Szakasz 1: Számok, vezetékek és regiszterek 114 eredménye a szövegben The file is "C:\Files\File.txt" // Formátumozott k i v i t e l reg [ 3 : 0 ] TA, TB, TC, TD; reg [ 1 : 0 ] TSEL; wire [ 3 : 0 ] TF; Programlista IV.5: Formattált kimenet // A f e j z e t és az eredmény táblázat nyomtatása i n i t i a l begin $display (" ", "Time TSEL TA TB TC TD TF") ; $monitor ("%d %b %b %b %b %b %b", $time, TSEL, TA, TB, TC, TD, TF) ; end A $display és a $monitor kimenete speciális karakterekkel formázható; a karaktereket string argumentumként adjuk át. Az IV.5

115 Szakasz 1: Számok, vezetékek és regiszterek 115 programlistán bemutatott formattálás eredménye: Time TSEL TA TB TC TD TF A formázott argumentumokat kétféleképpen rendezhetjük el. Az egyik, hogy a sok formázó sztringet egyetlen hosszú sztringgé rendezzük össze, és azt követi a formázandó argumentumok listája. A másik, hogy az argumentumokat párokba rendezzük, ahol a párok egy formázó stringből és egy formázandó értékből állnak. Általában véve, a formázó sztringek számának meg kell egyeznie a formázandó kifejezések számával. Ha túl sok kifejezés van, az alapértelmezett formátum a decimális. Ha túl kevés, az hiba. Ez alól kivétel a %m, amihez nem szükséges kifejezés. A %m a modul azon példányának nevét írja ki, amelyikben a $display vagy $monitor utasítás megjelenik.

116 Szakasz 1: Számok, vezetékek és regiszterek 116 Programlista IV.6: Formattált kimenet // Egyetlen formátum sztring, megfelelő számú értékkel $display ("%b %b", Expr1, Expr2) ; // vagy ekvivalens módon: // Két formátum sztring, megfelelő számú értékkel $display ("%b", Expr1, " %b", Expr2) ; // Túl sok értékkel : Expr2 decimálisan íródik ki $display ("%b", Expr1, Expr2) ; // Túl kevés értékkel : hiba $display ("%b %b %b", Expr1, Exp2) ;

117 Szakasz 2: Az idő kezelése Az idő kezelése Programlista IV.7: Időskála timescale 1ns/100ps // időegység/pontosság module MUX4TEST;... i n i t i a l begin... #10 A = 4 b1110 ; // #10 = 10 ns = 100(x100 ps)... end i n i t i a l begin... $timeformat( 9, 1, "ns", 7) ; $monitor ("%t %b %b %b %b %b, %b", $realtime, SEL, A, B, C, D, F) ; end endmodule

118 Szakasz 2: Az idő kezelése 118 timescale Az eddig látott Verilog szimulációk során az idő dimenzió nélküli mennyiség volt. A szimulációt fizikai időegységekben szokás végezni, például picosec vagy nanosec egységeket használva. A Verilogban az időegységet a timescale fordítóprogram direktívával állíthatjuk be. A timescale direktíva esetén az első mennyiség az időegység, lásd IV.7 programlista. A Verilog forráskódban szereplő valamennyi késleltetés ennek az időegységnek többszöröse. A példában #10 egy 10 ns értékű procedurális késleltetést jelent. A második mennyiség a pontosság. A példában a pontosság 100ps, ami azt jelenti, hogy a késleltetések a legközelebbi 100 ps értékre kerekítődnek. Így #10 jelentése 10ns avagy ps egység. Ha a terv valamely moduljában van időskála, akkor a terv valamennyi moduljában meg kell azt adni; akkor is, ha a a modul nem is használ késleltetést. A követendő gyakorlat, hogy minden egyes modulban adjunk meg időskálát.

119 Szakasz 2: Az idő kezelése 119 Szójegyzék: direktíva Egy fordítóprogram direktíva fordított idézőjellel ( ) kezdődik, és a fordítónak ad utasítást a még hátralevő Verilog programkódra vonatkozóan. A timescale használatos a késleltetés időegységének megadására ("#10 jelentése 10ns"). Természetesen előfordulhat, hogy a terv valamely moduljának eltérő időskálája van. Ilyen esetben az első értéket az időegységet a fent leírt módon használjuk. A második érték a pontosság esetében a szimulátor kiszámítja a tervben szereplő legkisebb pontosságértéket, és mindenütt azt használja, elhanyagolva az egyedi pontosság értékeket. Néhány Verilog segédprogram lehetővé teszi, hogy egyidejűleg több fájlt fordítsunk. Ez ugyanaz, mintha a forrásfájlokat egymás mögé írnánk és az így kapott fájlt fordítanánk le. Egy olyan direktíva, mint a timescale, valamennyi ezután következő modult befolyásolja,

120 Szakasz 2: Az idő kezelése 120 valamennyi, egyidejűleg fordított fájl esetén, amíg újabb ilyen direktíva nem jelenik meg. Ez azt jelenti, hogy ha egyes modulokban van időskála, másokban meg nincs, akkor az utóbbiak saját időskálájukat az előzőleg fordított modulokból származtathatják. Azt láttuk, hogy ha a terv bármelyik moduljában van időskála, akkor minden modulban kell lennie. Egy modulnak adhatunk egy alapértelmezett időskálát úgy, hogy azt fordítjuk utolsóként. Programlista IV.8: Többszörös időskála; A modul timescale 1ns/1ns // időegység/pontosság module A (... ) ;... Programlista IV.9: Többszörös időskála; B modul timescale 10ns/10ns // időegység/pontosság module B (... ) ;...

121 Szakasz 2: Az idő kezelése 121 Programlista IV.10: Többszörös időskála; C modul // nincs időegység module C (... ) ;... A három modul fordítási sorrendjétől függ az időegység: verilog A.v B.v C.v sorrendben az időskála 10ns/10ns verilog B.v A.v C.v sorrendben az időskála 1ns/1ns verilog C.v A.v B.v sorrendben pedig hibát kapunk: nincs időskála A $timeformat négy paraméterének jelentése

122 Szakasz 2: Az idő kezelése 122 Programlista IV.11: Az időkiírás formátumának megadása timescale 1ns/100ps // Ez esetben #10 jelentése 10.0 ns k é s l e l t e t é s $timeformat( 9, 1, "ns", 7) ; $monitor ( "%t",... $realtime,... az az egység, amiben az időt ki kell írni, ahol -12 jelentése picoseconds, -9 nanoseconds, -6 microseconds, etc.; a kijelzendő decimális helyek száma; az idő után írandó sztring; a minimális kiírandó karakterszám. Ha szükséges, a mező balról betűközzel feltöltődik. Megjegyezzük, hogy a $timeformat lehetővé teszi, hogy az időket olyan egységben írjuk ki, ami eltér a timescale egységétől.

123 Szakasz 2: Az idő kezelése 123 Szójegyzék: $timeformat Amikor időket íratunk ki a $display és $monitor felhasználásával, a $timeformat használatával adhatjuk meg, hogyan kell az értékeket kiírni. A $timeformat a %t formátumleíróval használatos. A $timeformat tervenként csak egyszer hívható, így annak a teszt fixtúrában van a legjobb helye. Inkább a $realtime függvényt érdemes használni a $time helyett, mivel az utóbbi a késleltetés értékét a legközelebbi (egész) időértékre kerekíti. A példában #10 úgy íródik ki, mint 10ns, mivel a timescale direktíva ennyinek írja elő, és a $timeformat szerint az értéket nanoszekundumban kell kiírni, egy decimális jegyre, a "ns" utótag használatával, valamint annyi bevezető betűközzel, hogy összesen 7 karakter legyen, amibe a tizedespontot és az utótagot is bele kell érteni.

124 Szakasz 2: Az idő kezelése 124 Szójegyzék: $realtime A $realtime olyan rendszerfunkció, amelyik a pillanatnyi szimulációs időt valós számként adja vissza, annak a modulnak a timescale egységében, amelyikből hívtuk.

125 Szakasz 3: További nyelvi elemek További nyelvi elemek Programlista IV.12: Példa az always procedurális blokk használatára module ClockGen( Clock ) ; output Clock ; // a kimenet lehet regiszter reg Clock ; i n i t i a l Clock = 0 ; always #5 Clock = ~Clock ; endmodule... // Bináris számláló i n i t i a l Count = 0 ; always #10 Count = Count + 1 ;

126 Szakasz 3: További nyelvi elemek 126 Már találkoztunk a procedurális blokk egyik formájával, az initial utasítással. A procedurális blokk másik formája az always blokk. Egy always blokk nagyon hasonló egy initial blokkhoz, de nem csak egyszer hajtódik végre, hanem végrehajtása folyamatosan ismétlődik a szimuláció során. Amint a végére érünk, rögtön kezdi előlről, így egy végtelen ciklust definiál. A IV.12 programlista első részében a ClockGen modul az órajel hullámforma előállítására használ egy always blokkot. Aminek egy always blokkban értéket adunk, azt regiszterként kell definiálni. Megjegyezzük, hogy a Clock regiszternek két különböző procedurális blokkban is értéket adunk: az initial és az always blokkban is. Az initial blokk Clock értékét nullába állítja a szimuláció kezdetén. Ezután az always blokk újból értékeket ad a Clocknak. Ez az explicit inicializálás azért szükséges, mert a reg változók kezdeti értéke alapértelmezetten bx. A IV.12 programlista második példája azt mutatja, hogyan használhatunk egy always blokkot bináris számsorozat előállítására. Itt ismét csak egy initial blokkot használunk a Count kezdőértékének

127 Szakasz 3: További nyelvi elemek 127 előállítására. Amikor Count eléri a maximálisan lehetséges értéket (pl. 4 b1111 egy négy bites reg esetén), még egyet hozzáadva "átfordul" 0-ba és a számlálás újraindul. Programlista IV.13: A $stop és $finish direktívák hatása // Ez állandóan futni fog module ClockGen_test ; wire Clock ; ClockGen CG1_ ( Clock ) ; endmodule module ClockGen_Test ; wire Clock ; ClockGen CG1_ ( Clock ) ; i n i t i a l #100 $stop ; // töréspont i n i t i a l #200 $finish ; // kilépés endmodule

128 Szakasz 3: További nyelvi elemek 128 Megjegyzés: Az IV.13 programlistában Clock nem lehet regiszter, hanem csak vezeték. Ez azért van, mert ebben a modulban Clockot egy port hajtja meg, ami nem kap értéket a procedurális blokkon belül. A Clock ezért vezeték típusú, annak ellenére, hogy olyan porthoz van kötve, ami maga a ClockGen modulon belül található regiszter. A IV.13 programlistában mutatott példák a IV.12 programlistában bemutatott órajelgenerátor egy példányát használják. Ha egy terv az előző ábrán bemutatotthoz hasonló always utasításokat tartalmaz, fennáll annak a lehetősége, hogy a szimuláció a végtelenségig tart. Ezt megelőzendő, megmondhatjuk a szimulátornak, hogy csak egy véges ideig hajtódjék végre; megszakíthatjuk a szimulációt; vagy pedig töréspontot iktathatunk be a Verilog kódba. Amikor a $stop végrehajtódik, a szimuláció felfüggesztődik, azzal

129 Szakasz 3: További nyelvi elemek 129 Szójegyzék: $stop A $stop rendszertaszk töréspontok beiktatására használható. a céllal, hogy a továbbhaladás előtt egy interaktív hibakeresővel meg tudjuk vizsgálni a szimuláció állapotát. Szójegyzék: $finish A $finish rendszertaszk használható arra, hogy a szimulációból kilépjünk. A $finish például olyankor használható, amikor egy órajelgenerátort vagy egyéb végtelen ciklust tartalmazó szimulációt akarunk befejezni. Kilépési alternatívaként használhatjuk a szimulátor utasításait vagy grafikus interfészét.

130 Szakasz 4: Regiszterek és vezetékek Regiszterek és vezetékek Programlista IV.14: Regiszterek használata module UseRegs( outreg ) ; output [ 7 : 0 ] OutReg; // A deklarációknak reg [ 7 : 0 ] OutReg; // azonosnak k e l l lennie reg R; i n i t i a l R =... // regiszter legyen always OutReg = 8 b... // regiszter legyen endmodule A szakasz végefelé, nézzük meg részletesebben az összekötések és a regiszterek használatát, lásd IV.14 programlista. Az alapszabály két részből áll: regisztert kell használnunk, amikor initial és always

131 Szakasz 4: Regiszterek és vezetékek 131 blokkban értéket adunk; és valójában regisztereket csak ebben az összefüggésben kell használnunk. Ezt a szabályt kell követnünk még akkor is, ha az azt jelenti, hogy egy output portot reg-ként kell deklarálnunk. Ilyen esetben az output és reg deklarációknak egymásnak megfelelőnek kell lenniük, pl. ugyanaz az LSB és MSB legyen a két deklarációban. Vezetékeket akkor használunk, amikor nem kell regisztereket használnunk. Mint már láttuk, vezetékeket kell használnunk input portok és folyamatos értékadás esetén. Szintén egyszerű vezetékeket kell használnunk, amikor modulok vagy primitívek kimenetéhez kapcsolódunk. Skalár vezetékeket használhatunk implicit deklarációval is, de a vektorokat explicit módon deklarálni kell. A vezetékekre és regiszterekre vonatkozó szabályok azt jelentik, hogy ugyanazt a kapcsolatot vezetékként és regiszterként is modellezhetjük. Az IV.1 ábra és az IV.16 programlista szerinti példában a Top modulnak van egy R regisztere, ami a Silly modul S példányának InWire portjához van kapcsolva. Tudjuk azonban, hogy a

132 Szakasz 4: Regiszterek és vezetékek 132 Programlista IV.15: Vezetékek használata module UseWires( InWire, OutWire) ; input InWire ; // A bemeneteknek vezetéknek k e l l lenni output OutWire ; // A kimenet lehet vezeték wire [ 1 5 : 0 ] InternalBus ; //Belső vektor AnotherModule U1 ( InternalBus,... ) ; YetAnother U2 ( InternalBus,... ) ; not ( ImplicitWire, InWire) ; // A példány kimenete csak vezeték lehet and (AnotherWire, ImplicitWire,... ) ; assign OutWire =... // Az assign miatt vezeték k e l l endmodule

133 Szakasz 4: Regiszterek és vezetékek 133 Programlista IV.16: Modul határok és a reg/wire átmenet module Top; reg R; wire W1, W2; S i l l y S (. InWire(R), OutWire(W1), OutReg(W2) ) ;... endmodule module S i l l y (InWire, OutWire, OutReg) ; input InWire ; output OutWire, OutReg; reg OutReg; i n i t i a l OutReg = InWire ; assign OutWire = InWire ; endmodule

134 Szakasz 4: Regiszterek és vezetékek 134 IV.1. ábra. Modul határok és a reg/wire átmenet c 2004, Doulos Verilog

135 Szakasz 4: Regiszterek és vezetékek 135 modulok bemenetének vezeték típusúnak kell lennie. Hasonló módon, a Silly OutReg nevű kimenetének, ami regiszter, egy vezetékhez kell kapcsolódnia, amikor Silly példányosítódik. A színfalak mögött implicit folytonos értékadások történnek a modulok határán. Programlista IV.17: Inout port használata module UsesInOut(Data) ; inout [ 7 : 0 ] Data ; // inout nem lehet reg típusú reg [ 7 : 0 ] Data_reg ; always... = Data ; // Most éppen input always Data_reg = 8 b... ; // Ennek reg nek k e l l lenni assign Data = Data_reg ; // Az assign miatt wire k e l l endmodule Ez a korlátozás nem probléma bemenetek esetén, mivel bemenetet nem kell regiszterként deklarálnunk. Lehet azonban ilyen probléma az inout portokkal, mivel előfordulhat, hogy az always blokkban értéket akarunk adni egy inoutnak - a szabályok alapján viszont nem

136 Szakasz 4: Regiszterek és vezetékek 136 Szójegyzék: inout Egy inout port kétirányú, és az inputhoz hasonlóan, vezetéknek kell lennie, lásd IV.2 ábra. tudunk! Helyette, lásd IV.17 programlista, egy reg-et kell használnunk az always utasításban, majd egy folyamatos értékadást, hogy a reg értékét az inout-nak átadjuk. Regisztereket kell használnunk amikor initial utasításban értéket adunk amikor always utasításban értéket adunk Vezetéket kell használnunk amikor folyamatos értékadást használunk input és inout esetén amikor primitív példányt outputhoz vagy inout-hoz kapcsolunk

137 Szakasz 4: Regiszterek és vezetékek 137 IV.2. ábra. Inout port értelmezése c 2004, Doulos Verilog Az összekötések strukturális jellegűek, a regiszterek viselkedés jellegűek. A fentiek megjegyzésére az egyik módszer, hogy a vezetékek strukturális modellekben használatosak (netlist), a regiszterek pedig viselkedési modellekben. Egy folyamatos értékadást lényegileg strukturális utasításnak tekintünk.

138 Szakasz 4: Regiszterek és vezetékek 138 IV.3. ábra. Vezeték és regiszter kapcsolata c 2004, Doulos Verilog

139 Szakasz 4: Regiszterek és vezetékek 139

140 Always blokkok 140 fejezet V: Always blokkok

141 Szakasz 1: RTL always utasítás RTL always utasítás Programlista V.1: Az always utasítás két tipikus használati módja // Kombinációs always reg OP;... Esemény vezérelt or A or B or C) i f (SEL) OP = A and B; else OP = C; // Órajel vezérelt always reg Q;... Esemény vezérelt posedge Clock ) Q <= D; // Nem blokkoló értékadás Always

142 Szakasz 1: RTL always utasítás 142 A V.1 programlista és annak betét ábrája az always utasításra mutat két olyan példát, amelyek szintetizálhatók. Az első példa egy kombinációs logika leírására használt always utasítást mutat, a második pedig egy szekvenciális logikát (D flip-flop). Az always a Verilog egyik leghatékonyabb és legflexibilisebb utasításainak egyike, amelynek használatával egy rendszer bármely részét, bármilyen absztrakciós szinten leírhatjuk, a Boole-egyenletektől a regiszter szintű átviteleken át a komplex algoritmusokig. Eseményvezérlés és az always szó után a zárójelek között felsorolt nevek listáját eseményvezérlésnek (vagy érzékenységi listának, sensitivity list) is nevezik. Az always utasítás mindig végrehajtódik, amikor az eseménylistában felsorolt vezetékek vagy regiszterek akármelyike megváltozik. Csak reg változóknak adhatunk értéket egy always utasításban, emiatt mind az OP, mind a Q változót regiszterként kell definiálnunk. Azonban, csak Q szintetizálódik hardver regiszterként (flip-flop). A

143 Szakasz 1: RTL always utasítás 143 Megjegyzés: or Az or az eseménylistában nem logikai operátor; hanem az események elválasztására szolgáló szeparátor. Az első példában az azt jelenti, hogy "amikor SEL értéket vált vagy A értéket vált vagy B értéket vált vagy C értéket vált, hajtsd végre az always utasítást. A második példában az eseményvezérlés hatására az always utasítás akkor hajtódik végre, amikor a Clock jelnek felfutó éle van. Az órajelvezérelt always utasításokat később részletesen tárgyaljuk. Verilogban a reg kulcsszó nem feltétlenül olyasmit jelöl, aminek eredménye egy regiszter lesz. Órajelvezérelt always utasításokban a reg változók gyakran a nem-blokkoló értékadás (<=) operátor használatával kapnak értéket, amint majd később tárgyaljuk. A V.2 programlista és betét ábrája egy olyan always utasítást mutat, amelyik egy kombinációs logikai függvényt ír le. Az always

144 Szakasz 1: RTL always utasítás 144 Programlista V.2: Az always utasítás két tipikus használati módja or C2 or C3 or A or B) begin i f (~C1) F = A; else F = B; i f end (C2 & C3) F = ~F;

145 Szakasz 1: RTL always utasítás 145 utasítás két if utasítást tartalmaz. if Az első if utasítás C1 értékét teszteli, majd az értéktől függően a két lehetséges értékadás valamelyikét hajtja végre. Ha C1 értéke logikai egy, (azaz C1 értéke 1 b0), akkor ezt true értéknek tekinti és az első értékadást (F = A) hajtja végre. Ha C1 logikai nulla vagy ismeretlen, akkor ezt false értéknek tekinti és a második értékadást hajtja végre. Az else részt egy if utasítás után elhagyhatjuk. A második utasítás invertálja F értékét, ha C2 és C3 egyaránt magas logikai értékű, különben (ha akár C2, akár C3 értéke logikai alacsony szint) nem invertálja. Szintézis Az if utasításoknak a szintézis után egy multiplexer felel meg, minden, az if utasításban adott érték esetén. A multiplexer kiválasztó jelét a logikai kifejezés határozza meg, az adatokat pedig az értékadás jobb oldalán álló kifejezés. Ha egy regiszter bizonyos feltételek esetén nem kap értéket, akkor a régi érték adódik át a multiplexeren, mint a

146 Szakasz 1: RTL always utasítás 146 fenti második if utasítás mutatja. A Verilog modell és a szintetizált hardver közötti megfeleltetés nem egy-egy értelmű. Nevezetesen, reg F három vezetékként szintetizálódik. Ezen túlmenően, ha optimalizáljuk a logikát, az optimalizált tervben esetleg semmi olyat nem fogunk látni, ami az eredeti reg F deklarációnak megfelelne. Az if utasítás mindkét ágában egy utasításnak van helye. Ha egynél több utasítás szükséges, az utasításokat a begin és end utasítás zárójelek közé kell írni. A példában mindkét ágon két-két utasítás van, így mindkét ágon szükségesek a begin-end-ek. Az if utasítás beleértve az else ágat, és mindkét ágon az utasításokat egyetlen utasításnak számít. Emiatt a V.3 programlistán és annak betét ábráján bemutatott always utasításban nem szükségesek a begin-end utasítászárójelek (bár használhatók). Utasítás sorozatok vizsgálatát if utasítások egymásba ágyazásával érhetjük el. Ezt legjobb egymást követő else if utasítások sorozataként írni, amint az az ábrán is szerepel. Az egyes feltételeket sorban egymás

147 Szakasz 1: RTL always utasítás 147 Programlista V.3: A begin-end utasításpár használata or A or B or C or D) begin // opcionális i f (SEL) begin // szükséges F = A; G = C; end // szükséges else begin // szükséges F = B; G = D; end // szükséges end // opcionális

148 Szakasz 1: RTL always utasítás 148 Programlista V.4: Egymásba ágyazott else-if utasítások hatása // Teljes "érzékenységi l i s t a " or C1 or C2 or A or B or C or D) i f (C0) F = A; else i f (C1) F = B; else i f (C2) F = C; else F = D;

149 Szakasz 1: RTL always utasítás 149 után megvizsgáljuk, amíg olyan értéket nem találunk, amelyik true értéket ad, ilyenkor az egymásba ágyazott if utasítások megfelelő ága hajtódik végre; azzal a mellékhatással, hogy a korábban említett feltételeknek elsőbbsége van a később említettekkel szemben. Programlista V.5: Egymásba ágyazott else-if utasítások hatása beginend nélkül // Akár így írjuk : i f (C1) i f (C2) F = A; else F = B; // Akár így : i f (C1) i f (C2) F = A; else F = B;

150 Szakasz 1: RTL always utasítás 150 Programlista V.6: Egymásba ágyazott else-if utasítások hatása beginend használatával // Ez viszont mást j e l e n t : i f (C1) begin i f (C2) F = A; end else F = B;

151 Szakasz 1: RTL always utasítás 151 Néha begin-end utasításokkal kell megmondanunk a Verilog fordítónak, hogy melyik if melyik else utasításhoz tartozik. A V.5 programlistán mutatott példában a két legfelső if utasítás, az eltérő bekezdési stílus dacára, azonos, lásd a betét ábrát. A második példában (V.6 lista és a betét ábra) a begin-end "elrejti" a belső if utasítást az else elől. A fordítóprogramok nem figyelik a bekezdési stílusokat! és nem is gondolatolvasással működnek! Ha egy reg változó csak bizonyos feltételek esetén kap értéket, akkor az más feltételek esetén megőrzi előző értékét. A hiányzó feltételt akár úgy is felfoghatjuk, mint azt a V.7 lista második felében látjuk. A Q kimenetnek mindenképpen értékkel kell rendelkezni, itt nincs tárolt előző érték, mint egy program változó esetén, ahol a megfelelő memória rekesznek van előző értéke. A szintézis eszközök ezt a helyzetet úgy kezelik, hogy beszúrnak egy transzparens latch tárolót a régi érték megőrzésére. Ez néha nem teljesen szándékunk szerint történik, amikor megpróbálunk egy kombinációs logikát procedurális blokkal leírni, és a szintézis eredményeként ilyen nemkívánt latch tárolókat is kapunk.

152 Szakasz 1: RTL always utasítás 152 Programlista V.7: Nem-teljes értékadás használata // Egy ilyen kód : Enable or Data) i f ( Enable ) Q = Data ; // valójában ezt j e l e n t i : Enable or Data) i f ( Enable ) Q = Data ; else Q = Q;

153 Szakasz 1: RTL always utasítás 153 V.1. ábra. Nem-teljes értékadás latch tároló nélkül c 2004, Doulos Verilog

154 Szakasz 1: RTL always utasítás 154 Bizonyos FPGA architektúrák nem tartalmaznak transzparens latchet. Ezért transzparens latch implementálásához aszinkron visszacsatolást kell használnunk, ennek használatát viszont nem minden FPGA támogatja; emiatt a Verilog kód megírása előtt érdemes a kiválasztott eszköz adatlapját megtekinteni. Szimuláció és szintézis esetén is az X értékkel való összehasonlítás eredménye mindig false. Mint a fenti ábrán látható, írhatunk olyan if utasításokat, amelyek figyelembe veszik a lehetséges X értékeket úgy, hogy explicit módon tesztelik a 0 és 1 értékeket. A harmadik feltételt azonban a szintézis eszközök elhanyagolják, mivel a hardver addigra már teljes mértékben le van írva. A gyakorlatban az RTL kódok nem tartalmaznak ilyenféle X kezelést, mivel X állapotokat általában nem állítunk elő, kivéve a "lényegtelen" értékek esetét. Az explicit X értékkel való értékadást a szintézis eszközök "lényegtelen" állapotként kezelik. Ez a szintézis eszközök számára lehetővé teszi, hogy hatékonyabban optimalizáljanak, de azzal a hátránnyal jár, hogy eltérhet az RTL modell illetve a szintetizált kapuk használatával végzett szimuláció eredménye. Ez egyszerűen

155 Szakasz 1: RTL always utasítás 155 Programlista V.8: Ismeretlen és lényegtelen értékek használata // Az X kezelését elkülönítjük a szintézis számára i f (A == 1 b0) F = 1 ; else i f (A == 1 b1) F = 0 ; else F = 1 bx ; // Csak a szimulációban használatos // Az X érték valójában "don t care" // Használatával elkerülhetjük a latcheket F = 1 bx; i f (A) F = 0 ; i f (B) F = 1 ; // viszont, a szimuláció eltérhet a szintézis eredményétől

156 Szakasz 1: RTL always utasítás 156 amiatt van, hogy egy RTL szimulációban F értéke lehet 1 bx, a szintetizált összekötéslista esetén azonban csak 1 b0 vagy 1 b1 lehet. A V.8 programlista bemutatja a == összehasonlító operátort is, amit kifejezésekben használunk két érték összehasonlítására. Az A == 1 b0 kifejezés értéke 1 b1 (TRUE), ha A értéke 1 b0; egyébként 1 b0 vagy 1 bx (FALSE). Az if utasítás alternatívájaként a Verilogban használhatjuk a feltételes operátort is. Az operátort használhatjuk initial és always utasításokban, valamint folyamatos értékadásokban is, lásd V.9 programlista. A feltételes operátor két karakterből (? és :) áll, és három operandusa van. Az ezt az operátort használó kifejezés értéke az első (a? előtti) operátortól függ. Ha ez az operandus TRUE (nem nulla), a kifejezés értéke a második (a? utáni) operandus. Ha az első operandus FALSE, a kifejezés értéke a harmadik (a : utáni) operandus értéke. Az operátor nagyon hasznos multiplexerek és háromállapotú pufferek modellezésére.

157 Szakasz 1: RTL always utasítás 157 Programlista V.9: A feltételes operátor használata // A háromoperandusú f e l t é t e l e s utasítás value = A? B: C; // egyenértékű a i f (A) value = B; else value = C; // kombinációval. Folytonos értékadásra (MUX) i s használható : assign F = SEL? A : B;

158 Szakasz 1: RTL always utasítás 158 Van a feltételes értékadás operátora és az if utasítás között egy nagyon fontos különbség, ami akkor válik láthatóvá, amikor a feltétel ismeretlen. Egy if utasításban szereplő ismeretlen feltételt false értékűnek tekintünk, és ilyenkor az if utasítás else ága hajtódik végre. A feltételes értékadás operátora esetén, ha az első operandus ismeretlen, a feltételes kifejezés értékét úgy kapjuk, hogy bitenként összehasonlítjuk a második és a harmadik operandust. Ahol a megfelelő helyeken levő bitek értéke azonos, az eredményben a megfelelő bit ez a közös érték lesz. Ahol az értékek különböznek, vagy azok egyike ismeretlen, az eredmény megfelelő bitje X lesz. A V.10 programlistán bemutatott példában az eredmény 4 b01xx, mivel a 4 b010x és 4 b0111 értékek két baloldali bitje megegyezik, a harmadik bit eltér, a jobboldali bitek egyike pedig X. A háromállapotú meghajtók Z értékadást tudnak megvalósítani, akár folyamatos értékadással, akár always utasítással, lásd V.11 programlista és betét ábrája. Amikor egy háromállapotú puffert egy inout porttal kapcsolatban használunk, sokkal könnyebb a bemutatotthoz hasonló módon folyamatos értékadást használni,

159 Szakasz 1: RTL always utasítás 159 Programlista V.10: A feltételes értékadás operátor használata // Ismeretlen f e l t é t e l esetén value = 1 bx? B: C; // jelentése NEM i f ( 1 bx) value = B; else value = C; // Ez az utasítás hajtódik végre // hanem a két operandus bitenkénti összehasonlítása, azaz value = 1 bx? 4 b010x : 4 b0111 ; // eredménye value = 4 b01xx

160 Szakasz 1: RTL always utasítás 160 mint always utasítást. Ez azért van így, mert az inout portok és összekötéseik összekötés (általában wire) típusúak, és a folyamatos értékadás cél objektuma vezeték. Programlista V.11: Tristate állapot megvalósítása // Nagy impedancia b e á l l í t á s a assign Op = Enable? Data : 1 bz; // vagy Enable or Data) i f ( Enable ) Op = Data ; else Op = 1 bz ;

161 Szakasz 1: RTL always utasítás 161

162 Procedurális utasítások 162 fejezet VI: Procedurális utasítások

163 Szakasz 1: Procedurális utasítások Procedurális utasítások case A case utasítás nagyon hatékony mód többutas elágaztatásra. A case utasítás elején egy kifejezéssel adjuk meg a lehetséges értékeket. A case utasítás végrehajtásakor annak pontosan egy, a kifejezés értékétől függő ága hajtódik végre. Ez az az ág lesz, amelyiknek a címkéje megegyezik a kifejezés értékével. A címkéket az utasításoktól kettőspont választja el. A default ág, ha jelen van, minden olyan esetre működésbe lép, amelyet valamelyik ág nem választ ki explicit módon. Nem feltétlenül szükséges azonban minden lehetséges esetnek egy ágat megfelelteni, azaz a default utasítás opcionális. A VI.1 programlistán bemutatott példában a default utasítás értelmetlen a szintézis számára, mivel SEL valamennyi lehetséges értéke megjelenik a case utasításban címkeként. A case utasítás útválasztója vektor vagy bármely érvényes Verilog kifejezés is lehet. Szintézis

164 Szakasz 1: Procedurális utasítások 164 A szintézis ugyanúgy kezeli a case utasítást, mint az if utasítást - a case utasításban szereplő minden egyes reg számára multiplexert generál. A case utasítás általános és kényelmes mód kombinációs logikák viselkedésének leírására, amíg a bemenetek száma nem túl nagy. FPGAk Érdemes figyelni arra, hogy bizonyos FPGA architektúrák esetén a bemenetek száma korlátozott (fanin limited), azaz az architektúra olyan logikai blokkokból épül fel, amelyeknek csak (kis) rögzített számú bemenete van. Ha a case utasításban ezt a határt túllépjük, a szintézis több logikai blokkot és logikai szintet fog használni. Lényeges javulást érhetünk el területkihasználás és időzítés szempontjából is, ha a logikával alkalmazkodunk az architektúrához. A VI.2 programlistán bemutatott példa a case utasítás újabb tulajdonságait mutatja meg. Két vagy több címke, vesszővel elválasztva (3 b001, 3 b010, 3 b100 :...), is tartozhat ugyanahhoz az ághoz. A kifejezés egy adott értéke esetén több utasítást is végrehajthatunk,

165 Szakasz 1: Procedurális utasítások 165 Programlista VI.1: A case utasítás használati módja or A or B or C or D) case (SEL) 2 b00 : F = A; 2 b01 : F = B; 2 b10 : F = C; 2 b11 : F = D; default : F = 1 bx; // Csak szimulálásra endcase ha az utasításokat egy begin... end blokkba zárjuk. Akárcsak az if utasítások esetén, itt is latch-ek generálódnak a szintézis során, ha egy regiszter nem teljes körűen kap értéket egy always blokkban. A casez utasítás a case egy variációja. Szintaxisuk és viselkedésük megegyezik, kivéve, hogy egy számban a Z érték egy nem érdekes értéket jelent. Emiatt a Z helyén a? karaktert használják, mivel az világosabban mutatja az utasítás jelentését.

166 Szakasz 1: Procedurális utasítások 166 Programlista VI.2: A case utasítás további tulajdonságai case (Code) 3 b000 : // I t t k e l l begin end begin P = 1 ; Q = 1 ; end 3 b001, 3 b010, 3 b100 : // Ezek alternatívák begin Q = 1 ; R = 1 ; end 3 b110, 3 b101, 3 b011 : R = 1 ; // Nincs minden lehetőség jelen OK endcase // Latch tárolókat hozhatunk l é t r e

167 Szakasz 1: Procedurális utasítások 167 wire A, B, C, D, wire [ 3 : 0 ] E; Programlista VI.3: A casez utasítás tulajdonságai ref [ 1 : 0 ] Op; or B or C or D or E) casez ({A, B, C, D, E}) // Összefűzés i s lehet // Az egyes eseteket sorrendben vizsgáljuk // Átfedés megengedett 8 b1??????? : Op = 2 b00 ; 8 b001??? 0 0 : Op = 2 b01 ; 8 b0? 1???? 0 : Op = 2 b10 ; 8 b0111?? 1 1 : Op = 2 b11 ; default : Op = 2 bxx; // X : nem fontos // így minden esetet kezelünk endcase // NEM endcasez casez 0 1 X Z X Z

168 Szakasz 1: Procedurális utasítások 168 A VI.3 programlistán bemutatott példában az első címke a case kifejezés bármely olyan értékének megfelel, amelyikben az MSB értéke 1; ez akkor áll elő, amikor A értéke 1. A második és a harmadik címke átfed. Például, 8 b megfelel mind a 8 b001???00 mind a 8 b0?1????0 értéknek. Az elsőnek van prioritása, így ebben az esetben Op a 2 b01 értéket kapja. A példában szereplő casez a következő módon írható fel if utasításokkal: if (A) Op = 2 b00; else if ( A & B & C & E[1] & E[0]) Op = 2 b01; else if ( A & C & E[0]) Op = 2 b10;

169 Szakasz 1: Procedurális utasítások 169 else if ( A & B & C & D & E[1] & E[0]) Op = 2 b11; else Op = 2 bxx; Összeillesztés (concatenation) Vegyük észre az összeillesztés hatását a case kifejezésben. A case kifejezés egy olyan vektor, amelynek elemeit kapcsos zárójelben ({}) soroljuk fel. Egy másik variáció a VI.4 programlistán látható, a casex, aminek hasonló koncepciója van, mint a casez utasításnak. A VI.3 és VI.4 ábrákon a betét táblázatokban látható a casez és casex utasítások igazságtáblázata. Mint mondottuk, Z bármilyen értéket elfogad egy casez utasításban; Z és X bármilyen értéknek megfelel egy casex utasításban.

170 Szakasz 1: Procedurális utasítások 170 wire A, B, C, D, wire [ 3 : 0 ] E; Programlista VI.4: A casex utasítás tulajdonságai ref [ 1 : 0 ] Op; or B or C or D or E) casex ({A, B, C, D, E}) casex 0 1 X Z 8 b1xxxxxxx: Op = 2 b00 ; 8 b010xxxxx: Op = 2 b01 ; b001xxx00: Op = 2 b10 ; b0111xx11 : Op = 2 b11 ; X default : Op = 2 bxx; // X es Z : nem fontos Z endcase // NEM endcasex

171 Szakasz 1: Procedurális utasítások 171 casez versus casex A casez utasítástól eltérően, a casex nem használható arra, hogy explicit módon felderítsünk X értékeket egy kifejezésben, mivel a case kifejezésben az X-ek és Z-k "wildcard" karakterként viselkednek (azaz, bármely értéknek megfelelnek). Emiatt casex használata nem javasolt, mivel ha egy kifejezés értéke a szimuláció során nem ismert (ami előfordulhat), az első címkét megfelelőnek találja és azt az értéket hajtja végre. Ugyanez a probléma merülhet fel a casez utasítással kapcsolatban, ha a case kifejezés Z-ket tartalmaz; ez viszont ritkábban fordul elő. A Verilog nyelv case utasításának szintaxisában szokatlan elem, hogy (az utasítás elején álló) case kifejezés lehet konstans is, és (belül) a "címkék " pedig változók is lehetnek, lásd VI.5 programlista! Egy ilyen stílusú case utasításban előfordulhat, hogy a case kifejezés egynél több címkének felel meg. Ilyen esetben felülről számítva az első megfelelőt használjuk. Más szavakkal, a case utasítást prioritás leírására használjuk, és ez egymásba ágyazott if-

172 Szakasz 1: Procedurális utasítások 172 Programlista VI.5: Prioritás enkóder case utasítás használatával // Prioritás enkóder : // A case választó ki fejezés állandó // a címkék a változó case ( 1 b1) A[ 0 ] : F = 2 b00 ; A[ 1 ] : F = 2 b01 ; A[ 2 ] : F = 2 b10 ; A[ 3 ] : F = 2 b11 ; endcase else utasításokkal egyenértékű, lásd VI.6 programlista. Ha egy case utasítás egymást kölcsönösen kizáró címkéket tartalmaz, akkor azt párhuzamosnak nevezzük; ha valamennyi lehetséges esetet lefedi, akkor pedig teljesnek, lásd VI.7 programlista és betét ábrája. Egy párhuzamos és teljes case utasítás egy vagy több multiplexerként realizálható. A szintézis eszközök általában automatikusan képesek felismerni a párhuzamos és teljes case utasításokat. Ahol

173 Szakasz 1: Procedurális utasítások 173 Programlista VI.6: Prioritás enkóder ekvivalens if utasítások használatával // Prioritás enkóder : // ekvivalens i f kifejezésekkel i f (A[ 0 ] ) F = 2 b00 ; else i f (A[ 1 ] ) F = 2 b01 ; else i f (A[ 2 ] ) F = 2 b10 ; else F = 2 b11 ;

174 Szakasz 1: Procedurális utasítások 174 Programlista VI.7: A parallel case programlista // auto parallel, auto f u l l case (A) // a case kifejezések kölcsönösen kizáróak 4 b0001 : F = 2 b00 ; 4 b0010 : F = 2 b01 ; 4 b0100 : F = 2 b10 ; 4 b1000 : F = 2 b11 ; // a default valamennyi lehetőséget figyelembe veszi // > nem hozunk l é t r e latch et default : F = 2 bxx ; endcase

175 Szakasz 1: Procedurális utasítások 175 a szintézist végző segédprogram nem képes felismerni, hogy a case címkék kölcsönösen kizárják egymást, ott egy prioritás enkódert szintetizál. Ha viszont tudjuk, hogy a címkék valójában kölcsönösen kizárják egymást, ezt az információt megadhatjuk a segédprogram számára, így az ott is multiplexert szintetizál. Programlista VI.8: Prioritás enkóder casez használatával // NOT parallel, auto f u l l case (A)// a case kifejezések NEM kölcsönösen kizáróak 4 b??? 1 : F = 2 b00 ; 4 b?? 1? : F = 2 b01 ; 4 b? 1?? : F = 2 b10 ; 4 b1??? : F = 2 b11 ; // a default valamennyi lehetőséget figyelembe veszi // > nem hozunk l é t r e latch et default : F = 2 bxx ; endcase A casez utasítás teljes (van default címkéje), de nem párhuzamos.

176 Szakasz 1: Procedurális utasítások 176 Például, ha A valamennyi bitje 1 lenne, ez valójában valamennyi címkére illene; így (csak) az első utasítás hajtódna végre, azaz így egy prioritás enkódert írna le. Programlista VI.9: "One-Hot" Dekóder megvalósítása casez használatával // onehotcase : case ( 0 b1) // synopsys parallel_case A[ 0 ] : F = 2 b00 ; A[ 1 ] : F = 2 b01 ; A[ 2 ] : F = 2 b10 ; A[ 3 ] : F = 2 b11 ; default : F = 2 bxx; endcase // ami ezzel egyenértékű : F [ 0 ] = A[ 1 ] A[ 3 ] ; F [ 1 ] = A[ 2 ] A[ 3 ] ; Tegyük fel, hogy az A rendelkezik azzal a tulajdonsággal, hogy

177 Szakasz 1: Procedurális utasítások 177 bármely időpillanatban valamennyi eleme (pontosan egy kivételével) nulla. Ezt a szintézis segédprogrammal közölnünk kell, különben szükségtelen logikát állít elõ. Szintézis direktíva Ennek egyik módja, hogy szintézis direktíva kerül a Verilog kódba. Ez egy olyan Verilog komment, amit a szimulátor elhanyagol (hiszen csak komment...), a szintézis segédprogram viszont elolvassa, sõt reagál rá (tehát mégiscsak több, mint komment). parallel_case A parallel_case direktíva a case utasításra vonatkozik, és azt mondja meg a szintézis segédprogramnak, hogy a case utasítás címkéi egymást kölcsönösen kizárják. full_case A full_case direktíva a case utasításra vonatkozik. Azt mondja meg a szintézis segédprogramnak, hogy a case utasítás a kiválasztó kifejezés összes lehetséges értékét lefedi.

178 Szakasz 1: Procedurális utasítások 178 Ezeket a direktívákat nagyon óvatosan kell használnunk, mivel ezek hatására a szintézis segédprogram és a szimulátor ugyanazt a Verilog kódot eltérően értelmezi! A következő direktívákat a legtöbb szintézis eszköz támogatja, bár kicsit eltérő szintaxissal // synopsys parallel_case // synopsys full_case // synopsys full_case parallel_case // synthesis parallel_case // synthesis full_case // synthesis full_case parallel_case // pragma parallel_case // pragma full_case // pragma full_case parallel_case

179 Szakasz 1: Procedurális utasítások 179 IEEE Az IEEE szabvány ezekre ilyen formát ajánl: // rtl_synthesis parallel_case // rtl_synthesis full_case // rtl_synthesis full_case, parallel_case A for ciklusok olyan szekvenciális utasítások, amelyeket gyakran használunk vektorokkal kapcsolatban. A ciklus belsejében található utasítások több alkalommal ismétlődnek, ahogyan azt a ciklus elején található iterációs séma előírja. A példában a ciklus négyszer ismétlődik, és a ciklusváltozó a 0, 1, 2 és 3 értékeket veszi fel. A ciklusparaméter a cikluson belül olvasható, de nem célszerű azt megváltoztatni. Az IEEE Verilog standard ugyan nem ragaszkodik ehhez a szabályhoz, de erősen ajánlatos betartani azt. A for ciklusok ismétlődő hardver strukturákként szintetizálódnak, feltéve, hogy a ciklushatárok rögzítettek. A VI.10 programlistán a

180 Szakasz 1: Procedurális utasítások 180 Programlista VI.10: for ciklus megvalósítása HW ismétléssel // for == HW ismétlése or B) begin G = 0 ; for ( I = 0 ; I < 4 ; I = I + 1) begin F[ I ] = A[ I ] & B[3 I ] ; G = G ^ A[ I ] ; end end

181 Szakasz 1: Procedurális utasítások 181 ciklusbeli első értékadás 4 AND kapuként szintetizálódna. A második értékadás kaszkád szerkezetű XOR kapukként szintetizálódik, mivel a cikluson belül az előző menetben adott érték használódik a következő menetben. Ebben az esetben az optimalizáló képes lenne az XOR-okat ágszerkezetűvé újra strukturálni, a késleltetési pályák kiegyensúlyozására. Bonyolultabb esetben azonban az optimalizálónak nem feltétlenül sikerül egy ilyen kaszkád szerkezetű logikát újrastrukturálni, különösen, ha aritmetikai operáció is szerepel benne, tehát ilyen ciklusokat nagyon figyelmesen kell megírnunk. A szintézis nem képes változó ciklushatárú ciklusokat kezelni, mivel a szintézer nem képes meghatározni, hogy a ciklus tartalmából hány példányt kell generálnia. Egy for ciklusváltozót (itt I) regiszterként kell deklarálnunk. Megpróbálhatnánk I-t reg [1:0]-ként deklarálni, mivel I-t arra használjuk, hogy 0-tól 3-ig számláljunk. Ez nem működne, mivel a regisztereket előjel nélkülinek tekintjük, és a két bittel ábrázolható legnagyobb szám 3. Az I = I + 1 értékadás I "átfordulását " (2 b = 2 b00) okozza, amikor I értéke maximális. Így aztán I értéke

182 Szakasz 1: Procedurális utasítások 182 Programlista VI.11: for ciklusváltozó deklarálása // for ciklusváltozó deklarálása // elvben 2 b i t elegendő, de 3+1 = 0 reg [ 1 : 0 ] I ; // nem elegendő reg [ 2 : 0 ] I ; // elég, DE for ( I = 3 ; I >= 0 ; I = I 1) // esetén már nem használhatunk reg et mindig négynél kisebb lenne, és a szimulált ciklus soha nem fejeződne be. A problémát itt úgy tudjuk megoldani, hogy I szélességét elegendően nagynak választjuk. Még ez sem működne azonban egy olyan ciklusban, ahol a ciklusváltozó értékét nem növeljük, hanem csökkentjük: mivel egy reg előjel nélküli, annak tartalma soha nem kisebb, mint nulla.

183 Szakasz 1: Procedurális utasítások 183 Programlista VI.12: for ciklusváltozó deklarálása // deklarálási eltérés : reg [ 3 : 0 ] F; // 4 bites, e l ő j e l nélküli integer I ; // 32 bites, e l ő j e l e s // ennek eredménye végtelen ciklus a ) for (F = 3 ; F >= 0 ; F = F 1) F[ I ] = A[ I ] & B[3 I ] ; // ez rendben van for ( I = 3 ; I >= 0 ; I = I 1) F[ I ] = A[ I ] & B[3 I ] ;

184 Szakasz 1: Procedurális utasítások 184 A Verilog rendelkezik egy olyan speciális regiszter típussal, amellyel matematikai egész értéket lehet ábrázolni. A Verilog integer adattípusában tárolt érték pontosan ugyanolyan, mint a reg [31:0] adattípusban tárolt érték, csak éppen az értékek másképpen kezelődnek minden olyan összefüggésben, ahol számokra van szükség; az integer értékek kettes komplemensű előjeles számokként értelmeződnek, a reg értékek pedig előjel nélküli számokként. A reg adattípust kell használnunk hardver ábrázolására, az integer adattípust pedig ciklusváltozóként és ott, ahol tisztán matematikai számra van szükség (pl. text fixtúrában számláló). A for ciklusutasításon túl, a Verilog három másik ciklusutasítással is rendelkezik: repeat, while és forever ciklusutasítással. A for ciklustól eltérően, ezeket a ciklusutasításokat nem-szintetizálhatónak tekintjük. Nagyon hasznosak azonban test fixtúrákban és magasszintű viselkedési modellekben. while Egy while ciklus mindaddig végrehajtódik, amíg a feltétel teljesül

185 Szakasz 1: Procedurális utasítások 185 Programlista VI.13: Egyéb ciklusutasítások // Szintézisre csak a for használható : for ( i n i t i a l i z e ; condition ; assignment )... // A masik három text fixturákba es algoritmus leírásra való while ( condition )... // Amig a f e l t é t e l t e l j e s ü l repeat ( expression )... // a megadott számúszor végrehajtódik forever... // végtelen ciklus

186 Szakasz 1: Procedurális utasítások 186 (azaz amíg annak értéke nem nulla). repeat Egy repeat ciklus (az ismétlési kifejezés értékétől függő) rögzített számúszor hajtódik végre. A repeat ciklusok ugyanúgy szintetizálhatók is lehetnek, mint a for ciklusok, de ezt nem mindegyik segédprogram támogatja. forever Egy forever ciklus feltétel nélkül hajtódik végre. Csak egy disable utasítással lehet megszakítani. A disable utasítás egy begin-end blokk végrehajtását állítja meg. Ennek hatása, hogy a disable végrehajtása után következő utasítás az éppen letiltott blokkot követő utasítás. Elnevezett blokk Hogy egy begin-end blokkot tiltani tudjunk, annak névvel kell rendelkeznie. Egy begin-end blokknak úgy adhatunk nevet, hogy a

187 Szakasz 1: Procedurális utasítások 187 Programlista VI.14: Blokk végrehajtás megszakítása // Blokk végrehajtás megszakítása begin : Outer // Named block forever begin : Inner // Named block... disable Inner ;... disable Outer ;... end end

188 Szakasz 1: Procedurális utasítások 188 begin kulcsszó után kettőspontot teszünk és odaírjuk a blokk nevét. A disable lehetőséget ad a ciklusokból való kilépésre, akár úgy, hogy a végrehajtást a soron következő iterációjával folytatjuk, akár teljesen befejezzük a ciklus végrehajtását (lásd a C nyelv continue és break utasítását, valamint a VHDL nyelv next és exit utasításait.) Ezt illusztrálja a VI.14 programlista, ahol a disable Inner hatására a ciklus következő iterációjával folytatjuk, a disable Outer hatására pedig teljesen befejezzük a ciklus végrehajtását. A disable arra is használható, hogy egy taszkból visszatérjünk, lásd később. Ha egy begin-end blokknak van neve, akkor azon belül is deklarálhatunk reg vagy integer típusú regisztert. Az így deklarált regisztert csak abban a blokkban lehet használni. Hatókör (Scope) A szoftver mérnökök a hatókör (scope) fogalmat használják erre a koncepcióra. Egy azonosító (pl. regiszter) hatóköre a programszöveg azon tartománya, amelyen belül az azonosító jellemzői hozzáférhetők. A példában reg Tmp hatóköre annak deklarációjától a begin-end

189 Szakasz 1: Procedurális utasítások 189 Programlista VI.15: Elnevezett blokk és a deklaráció // Named blockban deklarálhatunk reg et begin : blk reg Tmp; i f (~C1) Tmp = A; else Tmp = B; i f (C2 & C3) Tmp = ~Tmp; F = Tmp; end //... vagy egészeket i s begin : FourAnds integer I ; for ( I = 3 ; I >= 0 ; I = I 1) F[ I ] = F[ I ] & A[3 i ] ; end

190 Szakasz 1: Procedurális utasítások 190 blokk végéig terjed. Két vagy több azonosítót is deklarálhatunk azonos névvel, feltéve, hogy a deklarációk hatóköre eltérő. A Verilog négyféle hatókört definiál: modulok, elnevezett blokkok, taszkok és függvények. A VI.16 lista olyan always utasítást mutat, amit kombinációs logika szintéziséhez használnak. A példa a Verilog utasításainak széles körét használja: vektorokat, összeillesztést, for ciklust és disable utasítást. A betét ábra mutatja a szintetizált kapukat is, optimalizálás után. Egy always utasítás akkor szintetizálható kombinációs logikává, ha teljesülnek a következő feltételek: Az érzékenységi lista teljes. Más szavakkal, valamennyi kombinációs inputot fel kell sorolni az always utasítás elején utáni listában. Valamennyi kimenet értéket kap. Valahányszor egy always blokk végrehajtódik (azaz a bemenetek valamelyike megváltozik), valamennyi kimenetnek is értéket kell kapnia. Ha ez nem teljesül, akkor az nem kombinációs, hanem szekvenciális logika és a

191 Szakasz 1: Procedurális utasítások 191 reg [ 1 : 0 ] F; Programlista VI.16: Kombinációs always blokk or B or C or D) begin : Blk reg [ 3 : 0 ] R; R = {A, B, C, D} ; F = 0 ; begin : Loop integer I ; for ( I = 0 ; I < 4 ; I = I + 1) i f (R[ I ] ) begin F = I ; // Kilép a ciklusból disable Loop ; end end // Loop end

192 Szakasz 1: Procedurális utasítások 192 szintézis eredménye valószínűleg latch-eket fog tartalmazni. Nincs kombinációs visszacsatolás. Ez ismét csak aszinkron szekvenciális viselkedést eredményezne.

193 Szakasz 1: Procedurális utasítások 193

194 Órajelek és flip-flopok 194 fejezet VII: Órajelek és flip-flopok

195 Szakasz 1: Always latch always latch tárolóval Programlista VII.1: always latch tárolóval // latch kikényszerítésének "helyes" módja // t e l j e s érzékenységi l i s t a or D or A or B or SEL) i f (ENB) // nem t e l j e s értékadás begin Q = D; i f (SEL) F = A; else F = B; end // visszacsatolás nélkül Ez az always utasítás azt mutatja, hogyan kényszeríthetjük ki latch áramkörök használatát. Az egyetlen különbség a kombinációs logika előállításához képest, hogy szándékosan nem határozzuk meg a kimenet értékét a bemenet minden lehetséges változásának esetére.

196 Szakasz 1: Always latch 196 Hogy ez előre látható módon történjen, használjunk egy if utasítást, azaz a latch engedélyezési jelét feltételként, mint a példa mutatja. // Így csak kapuzunk Clock ) i f ( Clock ) Q = D; Programlista VII.2: Él-vezérelt Flip-Flop // Így viszont az élre reagálunk // Ugyanez van negedge esetén i s posedge Clock ) Q = D; Bár szimuláció alkalmával a VII.2 programlistán leírt áramkör korrekt módon D-flipflopként viselkedik, lásd a betét ábrát, a szintézis során (ha egyáltalán szintetizálható) transzparens latchet kapunk. Ez azért van, mert a szintézis eszközök nem-teljes eseményvezérlést feltételeznek, mivel D hiányzik a listából. Hogy flip-

197 Szakasz 1: Always latch 197 flopot állítsunk elő, a szintézis programnak a helyes funkcionalitásnál több útmutatásra van szüksége: a posedge vagy negedge kulcsszavak valamelyikének használatára. Flip-flopot akkor (és csak akkor) állítunk elő, ha az always utasítás tartalmazza a posedge or negedge kulcsszavak valamelyikét az eseményvezérlési listájában. A második példa a legegyszerűbb órajelvezérelt always utasítást mutatja: egy élvezérelt D flipflopot ír le, amelyet a Clock felfutó éle vezérel. A Verilog nem-determinisztikus A Verilog nyelv egyik jellemzője, hogy nem-determinisztikus. Más szavakkal, írhatunk olyan Verilog kódot, amelyik különbözõ szimulátorokon másként viselkedik. Ez nem valamelyik szimulátor hibája, hanem a Verilog nyelv tulajdonsága. A tulajdonság egy jellemző példája, amikor (az ábra szerint) különálló always utasításokkal írunk le flipflop-okat. Amikor egy

198 Szakasz 1: Always latch 198 Programlista VII.3: Szimulációs versenyhelyzetek elkerülése // Egyszerre olvassuk es írjuk b t! posedge clock ) b = a ; posedge clock ) c = b ; // A versenyhelyzet feloldása posedge clock ) begin tmpa = a ; #1 b = tmpa ; end posedge clock ) begin tmpb = b ; #1 c = tmpb; end // Nem ajánlott : ( (

199 Szakasz 1: Always latch 199 pozitív órajel fordul elő a szimuláció során, mindkét always utasítás végrehajtódik. Nem tudjuk megmondani, hogy a szimulátor melyik utasítást hajtja végre először. Ha az utasítások az ábrán bemutatott sorrendben hajtódnak végre, akkor először b értéke frissül, és b új értékével frissül c értéke. Így tehát b és c értéke azonos lesz. Másrészt viszont, ha az always utasítások fordított sorrendben hajtódnak végre (és a Verilog definíciójában semmi sem tiltja, hogy ez előfordulhasson), akkor c kapja meg b értékét, még mielőtt b értéke felfrissülne a értékével. A szintézis során kétségkívül két flipflop generálódik. Emiatt az RTL-szintű leírás szimulációs eredménye és a szintetizált kapuk eltérhetnek. Mindennek eredményeként tartási idő sértést tartalmazhat az RTL modell. A problémát úgy kerülhetjük el, hogy a mutatott módon átmeneti reg-eket és késleltetéseket helyezünk el az always utasításokban. Ez a módszer működhet (a szintézis ugyan elhanyagolja a késleltetéseket, de azok helyessé teszik a szimulációt); de nem elegáns.

200 Szakasz 1: Always latch 200 Programlista VII.4: Nem-blokkoló értékadás // Javasolt megoldás : // nem blokkoló értékadás posedge clock ) b <= a ; posedge clock ) c <= b ; // Ajánlott : ) )

201 Szakasz 1: Always latch 201 A szimulációs versenyhelyzeteket az RTL (vagy "nem-blokkoló") értékadás operátorának (<=) használatával kerülhetjük el. (Ennek megfelelően a közönséges értékadás operátorát (=) "blokkoló" értékadásnak nevezik; ezeket a fogalmakat majd később tárgyaljuk.) A közönséges (blokkoló) értékadástól eltérően, egy nem-blokkoló (avagy RTL) értékadás nem frissíti azonnal a baloldalt álló reg értékét. Ehelyett, beütemez egy olyan eseményt, amelyik majd a szimulációs időlépés végén fordul elő. Így tehát a példában b és c mindaddig nem kapják meg új értéküket, amíg mindkét értékadás végre nem hajtódott. A VII.5 programlistán és betét ábráján bemutatott két példa azt mutatja, hogyan írhatunk le aszinkron bemenetű flipflopokat. Megjegyezzük, hogy az órajelnek és az aszinkron set/reset jelnek szerepelnie kell az érzékenységi listában, és mindkettőt el kell látni a posedge vagy negedge jelzők valamelyikével. Ez még akkor is igaz, ha a set vagy reset jel él-érzékeny. Ha ilyen jelzőt nem adunk hozzá, a modell szimulációja helytelen lesz.

202 Szakasz 1: Always latch 202 Programlista VII.5: Aszinkron értékadás és törlés posedge Clock or posedge Reset ) i f ( Reset ) Q1 <= 0 ; else Q1 <= D; posedge Clock or posedge Set ) i f ( Set ) Q2 <= 1 ; else Q2 <= D;

203 Szakasz 1: Always latch 203 Programlista VII.6: Szinkron és aszinkron akciók posedge Clock or posedge Reset ) i f ( Reset ) // Aszinkron reset Q <= 0 ; else i f (Load) // Szinkron betöltés Q <= Data ; else Q <= Q + 1 ; A VII.6 programlista és betét ábrája egy bonyolultabb, aszinkron resetelésű szinkron logikát mutat. Mint eddig is, a reset aktív éle és a clock aktív éle egyaránt szerepelnek az érzékenységi listában. Az aszinkron bemeneteket a szinkron viselkedés leírása előtt kell megvizsgálnunk. A minta:

204 Szakasz 1: Always latch 204 or active_async_edge) if ( async_is_active ) perform_async_operation else perform_synchronous_operation Ha FPGA-t tervezünk, az optimális eredmény eléréséhez szükségünk lesz arra, hogy a Verilog forráskódba architektúra-specifikus tulajdonságokat is beírjunk. Például, a Xilinx FPGA eszközeiben van egy STARTUP blokk, ami a dedikált globális set/reset hálózatot (dedicated global set/reset net, GSR) vezérli. Ha ezt működésbe hozzuk, a GSR az eszköz valamennyi flip-flopját beállítja vagy törli. A STARTUP blokk konfigurálható úgy, hogy a GSR az eszköz normál működése során is aktivizálható legyen. Az FPGA szintézis segédprogramok a GSR használatát általában automatikusan végzik. Vannak azonban olyan esetek, ahol az automatikus működtetés nem célszerű, és a globális resetelést explicit módon példányosítani kell, lásd VII.7 ábra.

205 Szakasz 1: Always latch 205 Programlista VII.7: Technológia-specifikus tulajdonságok // A szintézis számára " fekete doboz" module Block1 ( Clock, Reset, D, Q) ; input Clock, Reset, D; output Q;... // Technológia. specifikus komponens példány STARTUP Dummy(.GSR( Reset ) ) ; posedge Clock or posedge Reset ) i f ( Reset ) Q <= 0 ; else Q <= D;... endmodule

206 Szakasz 1: Always latch 206 A fenti Verilog kód a Xilinx STARTUP modul egy olyan példányát mutatja, ahol az első (GSR) input a Reset-hez kapcsolódik. Ez szimuláció esetén nem játszik szerepet, de megmondja a Xilinx helyfoglaló és útvonaltervező eszközeinek, hogy a reset útvonaltervezésekor használja a globális GSR-t. Sajnos, ez azt is jelenti, hogy a Verilog már nem technológiafüggetlen. Ezek a minták azt mutatják, hogyan hozhatunk létre kombinációs logikát, transparens latch tárolókat és flipflopokat a viselkedést leíró Verilog kóddal. Amikor szintetizálás céljából írunk Verilog kódot, az utasításoknak a fenti minták valamelyikét kell követniük. Az IEEE RTL szintézis standard definiálja, milyen mintákat kell a szintézis eszközöknek támogatni. Megjegyezzük, hogy kombinációs logikák esetén folyamatos értékadások is használhatók.

207 Szakasz 1: Always latch 207 VII.1. ábra. Szintézis minták c 2004, Doulos Verilog

208 Szakasz 1: Always latch 208 VII.2. ábra. Szintézis minták c 2004, Doulos Verilog

209 Szakasz 1: Always latch 209 Az RTL szintézis eszközök tipikusan az ábra szerinti két fázisban működnek. Az első fázisban (tipikusan HDL szintézis vagy fordítás) beolvassák a HDL forráskódot és átalakítják technológia-független strukturális ábrázolássá. Ez az ábrázolás általában olyan technológiafüggetlen primitívek hierarchikus hálózatából áll, mint NAND kapuk, D flipflopok, összeadók, multiplexerek, stb. A második fázis ezt a közbülső reprezentációt primitívek optimalizált hálózatává alakítja, amelyet egy speciális, cella alapú ASIC technológián (manapság leginkább CMOS kapu tömbökön és FPGAkon) alapuló könyvtárból vesz. A második fázis optimalizációt és leképzést is végez. Az optimalizálás egy többszintű Boole-minimalizáláson alapuló technika, ahol a Boole-egyenletek többszintű hálózatának szerkezetét úgy változtatják meg, hogy a használt terület (a közös Boole-tagok megosztásával) minimális legyen, és (a kritikus útvonalon levõ logikai szintek számának csökkentésével és gyorsabb cellák használatával) megfeleljen az időzítési követelményeknek. Az állapot kódolás (state encoding) technikáját használják arra, hogy véges állapot automatákat az

210 Szakasz 1: Always latch 210 állapotregiszter kódolásának változtatásával optimalizáljanak. VII.3. ábra. RTL szintézis c 2004, Doulos Verilog Egy RTL szintű leírásban valamennyi műveletet explicit módon

211 Szakasz 1: Always latch 211 órajelekkel szinkronizálni kell - ez az RTL munkamegfogalmazása. Az RTL lényege, hogy definiáljuk a regisztereket és az egyes órajelek alkalmával történő átviteleket a regiszterek között (azaz a kombinációs logikát). Az RTL szintézis eszközök a regiszterek létezését közvetlenül a Verilog forráskódból vonják le, néhány egyszerű szabály használatával. RTL optimalizálás Az RTL szintézis eszközök megtartják a Verilog nyelven megadott szerkezeteket. Más szavakkal, az RTL szintézis folyamata nem hoz létre és nem töröl regisztereket, azokat nem vonja össze, mozgatja és optimalizálja. Az RTL szintézis folyamata a regiszterek közötti kombinációs logikát optimalizálja. Néhány segédprogram az itt leírtaknál több funkciót is végez; például, mint később látni fogjuk sok (de nem mindegyik) segédprogram összevonja az egyenértékű flipflopokat. Amikor egy órajellel szinkronizált procedurális blokkban regeknek értéket adunk, azzal valószínűleg flipflopokat állítunk elő. Hogy a

212 Szakasz 1: Always latch 212 Programlista VII.8: Flip-flopok kikényszerítése reg Up; reg [ 1 1 : 0 ] Acc, nexta ; posedge SampleClock) begin i f (Up) begin nexta = Acc + Delta ; i f (nexta >= Max) Up <= 0 ; end else begin nexta = Acc Delta ; i f (nexta [ 1 1 ] == 1 b1) // nexta < 0 Up <= 1 ; end Acc <= nexta ; end

213 Szakasz 1: Always latch 213 szintézis során egy regből flipflop vagy vezeték lesz-e, az attól függ, hogyan használjuk. Azokból a regekből lesznek vezetékek, amelyeknek új értéket adunk, mielőtt azokat az egyes órajel ciklusokban olvasnánk (a fenti példában NextA). Azokból a regekből lesznek flipflopok, amelyeket azelőtt olvasunk, hogy bármelyik órajel ciklusban értéket kapnának (a fenti példában Up). Végezetül, azok a regek, amelyek nem-blokkoló értékadással kapnak értéket, feltétlenül flipflopokat generálnak. Hogy egy blokkoló értékadással flipflopot állítunk-e elő, az attól függ, hogy a reg értékét meg kell-e jegyezni az órajelek között. Ha egy aktív órajel hatására egy regnek azelőtt adunk értéket, mielőtt az értéket használnánk, akkor nem állítódik elő flipflop. Ha egy reg értékét azelőtt használjuk, mielőtt új értéket rendelnénk hozzá, akkor a felhasznált érték az lesz, amit az előző órajel hatására rendeltünk hozzá. Emiatt flipflopra van szükség. Nem-blokkoló értékadások esetén a flipflop előállítás szabálya egyszerű: mindig flipflop állítódik elõ.

214 Szakasz 1: Always latch 214 Programlista VII.9: Flip-flopok kikényszerítése - blokkoló értékadás // Write before read => no f l i p flop posedge Clock ) begin Tmp = ~(IP1 & IP2) ; OP1 <= Tmp IP3 ; end // Read before write => f l i p flop posedge Clock ) begin OP1 <= Tmp IP3 ; Tmp = ~(IP1 & IP2) ; end

215 Szakasz 1: Always latch 215 Programlista VII.10: Flip-flopok kikényszerítése - blokkoló értékadás // A nem blokkoló értékadás minding f l i p flopot hoz l é t r e posedge Clock ) begin Tmp <= ~(IP1 & IP2) ; OP1 <= Tmp IP3 ; end // Az értékadás sorrendje nem számít posedge Clock ) begin OP1 <= Tmp IP3 ; Tmp <= ~(IP1 & IP2) ; end

216 Szakasz 1: Always latch 216 Mivel nem-blokkoló értékadás használata esetén mindig flipflop állítódik elő, ajánlatos mindig nem-blokkoló értékadást használni, amikor flipflopokra van szükségünk. Megjegyezzük, hogy amikor nem-blokkoló értékadást használunk, az utasítások sorrendje nem számít, mivel nem-blokkoló értékadással értéket kapó reg-ek értéke nem azonnal frissül. Ha egy reg blokkoló értékadásban kap értéket, és azon az always blokkon kívül is használjuk, amelyben értéket kap, akkor flipflop generálódik, még akkor is, ha nem is kell tárolni a reg értékét az órajelek között. A fenti példában Tmp értékét folytonos értékadással kapja meg OP2, így flip-flop generálódik. Nem igazán célszerű azonban ilyen módon előállítani flipflopokat, mivel ilyenkor szimulációs versenyhelyzet állhat elő. Helyesebb a harmadikként megadott módon újraírni a kifejezést, mivel ebből világosan látszik, hogy

217 Szakasz 1: Always latch 217 Programlista VII.11: Flipflop előállítás - blokkoló értékadással // Olvasás e l ő t t i írás : => nincs FF posedge Clock ) begin Tmp csak az always belsejében Tmp = ~(IP1 & IP2) ; OP1 <= Tmp IP3 ; end // Reg az always en kívül : k e l l FF posedge Clock ) begin Tmp csak az always belsejében Tmp = ~(IP1 & IP2) ; OP1 <= Tmp IP3 ; end assign OP2 = Tmp; //Tanácsos így újraírni : posedge Clock ) begin Tmp <= ~(IP1 & IP2) ; OP1 <= Tmp IP3 ; end assign OP2 = Tmp;

218 Szakasz 1: Always latch 218 ebből flipflopot kell generálni nem áll elő szimulációs versenyhelyzet Programlista VII.12: Flipflop előállítás - blokkoló értékadással posedge CLOCK) begin i f (!RESET) COUNT = 0 ; else COUNT = COUNT + 1 ; OUT <= COUNT[ 7 ] ; end A flipflopok szintézisére vonatkozó fenti szabályokat követve 8 flipflopot állítunk elő reg COUNT, és egyet reg OUT esetén. Megjegyezzük azonban, hogy COUNT[7] és OUT értéke mindig azonos, így az azoknak megfelelő flipflopok D kimenete össze van kötve.

219 Szakasz 1: Always latch 219 Sok szintézis segédprogram lehetővé teszi, hogy a flipflopok D kimeneteit összekössük, és ebben a helyzetben valóban 9 flipflopot állítsunk elő. Más segédprogramok azonban automatikusan összevonják azokat a flipflopokat, amelyeknek a D kimenete össze van kötve, így csak 8 flipflop generálódik. Programlista VII.13: Flipflop előállítás - blokkoló értékadással posedge Clock ) begin Q <= Data ; QB <= not Data ; end A fenti példában Q és QB egyaránt flipflop! Óvatosnak kell lennünk RTL Verilog programunk írásakor, ha el akarjuk kerülni nem kívánt flipflopok használatát. A szintézis programok nagyon buták tudnak lenni, ha flipflopokról van szó. Nekünk kell eldöntenünk, hány flipflopra van szükségünk és azokat hogyan kell összeszervezni, és

220 Szakasz 1: Always latch 220 ennek megfelelően megírni a Verilog kódot. Programlista VII.14: Kézi optimalizálás posedge Clock ) Q <= Data ; assign QB =!Q; Hogy ebben a szituációban megszabaduljunk a nemkívánatos flipflopoktól, a Q és QB egyikének adhatunk értéket az órajelvezérelt always blokkon belül. A megoldás, hogy a QB értékadását az always blokkon kívülre visszük és folyamatos értékadássá tesszük, így elkerülhetjük a QB külön flipflopját. Ha Q és QB kimenetű flipflopok elérhetők a cél eszköz technológiájában, a szintézis eszköznek tudnia kell azokat használni. A legtöbb CPLD és FPGA eszköz esetén csak a Q kimenet elérhető, így ez az optimalizálás nem hajtódik végre.

221 Szakasz 1: Always latch 221

222 Operátorok 222 fejezet VIII: Operátorok

223 Szakasz 1: Operátor Operátorok Már találkoztunk bitenkénti operátorokkal, de csak skaláris operandusok esetén. Vektorok esetén a bitenkénti operációk külön-külön kezelik a vektor operandusok egyes bitjeit. Például, egy két vektorra vonatkozó bitenkénti and (&) vektor eredményt hoz létre, ahol az eredmény minden egyes bitje logikai and kapcsolatban van a két operandus megfelelő bitjeivel. Hasonlóképpen, egy vektor bitenkénti inverziója ( ) egyszerűen invertálja a vektor valamennyi bitjét; más szavakkal előállítja annak egyes komplemensét. Redukciós operátorok Eléggé zavaró módon, &, és ^ unáris redukciós operátorként is használhatók. Egy redukciós operátornak egyetlen vektor operandusa van, és egybites eredményt hoz létre. Például, az and (&) redukciós operátor egy vektor bitjeit hozza

224 Szakasz 1: Operátor 224 VIII.1. ábra. Bitenkénti és redukciós operátorok c 2004, Doulos Verilog

225 Szakasz 1: Operátor 225 and kapcsolatba. Az eredmény mindig 1 b0, hacsak nem minden egyes bit értéke 1. Az egyetlen valóban használható redukciós operátor ^, ami paritásbitet állít elő. A bitenkénti operátoroktól eltérően, a logikai operátorok logikai (bool) mennyiségeknek tekintik operandusaikat. Egy skalárt TRUE értékűnek tekintünk, ha az nem nulla, és FALSE értékűnek, ha nulla. Az X és Z értékű bitek ismeretlen értékűek (sem nem TRUE, sem nem FALSE). Egy logikai operátorokat tartalmazó kifejezés értéke lehet 1 b1 (TRUE), 1 b0 (FALSE) vagy 1 bx (ismeretlen). Amikor egy ismeretlen értéket vizsgálunk, például egy if utasításban, annak értékét FALSE-nak tekintjük. A not operátor (!) olyankor hasznos, amikor azt akarjuk megvizsgálni, hogy egy kifejezés értéke nulla-e. Megjegyezzük, hogy egybites mennyiségek esetén a &&, és! operátorok egyenértékűek a megfelelő &, és operátorokkal.

226 Szakasz 1: Operátor 226 VIII.2. ábra. Logikai operátorok c 2004, Doulos Verilog

227 Szakasz 1: Operátor 227 VIII.3. ábra. Összehasonlító operátorok c 2004, Doulos Verilog

228 Szakasz 1: Operátor 228 A Verilog kétféle egyenlőség operátort használ. A == és!= logikai egyenlőség operátorok vektorok értékét hasonlítják össze. Az ilyen összehasonlítás eredménye TRUE (ha az értékek megegyeznek), FALSE (ha nem egyeznek) vagy ismeretlen (ha valamelyik vektor X vagy Z értéket tartalmaz). === és!== a bitpozíciók egyenlőségét vizsgáló operátorok. Két vektor akkor és csak akkor egyenlő, ha valamennyi bitjük azonos, beleértve az X és Z értékű biteket is. == ugyanazt az eredményt adja, mint ===, valamint!= is ugyanaz, mint!==, ha az összehasonlított vektorokban nem szerepel X és/vagy Z értékű bit. Ettől eltérő esetben == és!= eredménye ismeretlen, míg === és!== határozott eredményt ad. Az {} összeillesztés operátort használjuk arra, hogy két vektort (vagy egybites értéket) egy hosszabb vektorrá illesszünk össze. A két vektor végpontját egymás után illesztjük, lásd a VIII.4 ábrán az F = {A, B}; értékadást, ahol A értékét az F baloldali nyolc bitjébe másolódik, B értéke pedig az F jobboldali bitjeibe. Megjegyezzük,

229 Szakasz 1: Operátor 229 VIII.4. ábra. Összeillesztés (Concatenation) c 2004, Doulos Verilog

230 Szakasz 1: Operátor 230 hogy hibának számít, ha egy összeillesztésben méret nélküli egész értéket használunk. Az ábra második része egy folyamatos értékadás bal oldalán használt összeillesztést mutat. A COUT vezeték fogadja az értékadás jobb oldalán álló összegből származó átvitel bitet. Ennek oka, hogy az (A + B + CIN) összeg szélességét az értékadás baloldalának ( {COUT, SUM} ) szélessége már megadja. A másolatkészítés operátora az összeillesztés operátorának kiterjesztése. Ez is kapcsos zárójeleket (pontosabban két párat) használ. A belsõ összeillesztés az első zárójel után megadott számúszor ismétlődik. A belső kapcsos zárójelek egy összeillesztést rejtenek: legálisak az olyan kifejezések is, mint {10{A,B}}. Az alsó ábra azt mutatja, hogyan írhatjuk le egy nyolc bites reg előjelének kiterjesztését 16 bitre. Ez az előjelkiterjesztés biztosítja, hogy a kisebb reg előeles értéke a kiterjesztés után is helyes legyen. A kettes komplemenst (előjeles számokat) használó Verilog modellekben

231 Szakasz 1: Operátor 231 VIII.5. ábra. Másolatkészítés (Replication) c 2004, Doulos Verilog

232 Szakasz 1: Operátor 232 gyakran van szükség előjelkiterjesztésre. Vegyük észre, hogy a wordnek értéket adó kifejezés egy {8{byte[7]}} másolat és egy egyszerű kifejezés (byte) összeillesztése. A léptető regiszterek is összeillesztéssel írhatók le, mint látható. Az értékadás jobb oldala egy nyolcbites vektor, amelynek SR[6] az MSB és SerialIn az LSB bitje; ezt az értéket kapja meg a baloldal (SR). Így SR[6] bemásolódik SR[7]be, SR[5] pedig SR[6]ba, stb, végül SerialIn pedig SR[0]ba. A Verilog két léptető operátorral rendelkezik: << balra léptet, >> pedig jobbra. A bal operandust a jobb oldalon megadott operandusnak megfelelő számú bittel eltolja. Az üresen maradó bitek nullával töltődnek fel. Ebben a példában az összeillesztés operátor felhasználásával az eltolás egyetlen utasítással írható le, de a shift operátor használatával két utasítás szükséges. Szigorúan véve, a fordítóprogram direktívái nem a Verilog nyelv részei, hanem a Verilog fordítóprogramnak szóló utasítások. A

233 Szakasz 1: Operátor 233 VIII.6. ábra. Léptető regiszterek (shift register) c 2004, Doulos Verilog

234 Szakasz 1: Operátor 234 VIII.7. ábra. Léptető operátorok (shift operators) c 2004, Doulos Verilog

235 Szakasz 1: Operátor 235 VIII.8. ábra. define és include c 2004, Doulos Verilog

236 Szakasz 1: Operátor 236 fordítóprogram direktíváit egy fordított egyes idézőjel (apostrophe, "back-tick", grave accent character) ( ) előzi meg, és ezek mindegyike külön sort alkot. Legyünk figyelemmel arra, hogy ez nem azonos a normál idézőjellel avagy a fordított vesszővel ( ), amit olyan számokban használunk, mint 8 bx. Egy Verilog forráskódban (és néhány segédprogram esetén még a fájl határokon túl is) egy fordítóprogram direktíva mindaddig hatályos, amíg egy másik fordítóprogram direktíva felül nem írja. define A define egy szöveges makrót deklarál. Egy szöveges makró egyszerűen egy karakter sztring. Amikor a makró név, amit szintén egy fordított apostrophe ( ) karakternek kell bevezetnie, megjelenik egy Verilog forráskódban, a fordítóprogram azt a megfelelő makró sztringre cseréli. Ne feledjük, hogy a makró sztring végén nincs pontosvessző (;). Ha lenne, azt egyszerűen a sztring részének kellene tekinteni és ennek megfelelően be is helyettesíteni! Ha megfelelelően használjuk, a define használatával Verilog forráskódunk könnyebben

237 Szakasz 1: Operátor 237 olvashatóvá és karbantarthatóvá válik. Ez a direktíva az ifdef direktívával kapcsolatban is használható, lásd később. include Az include utasítást kettős idézőjelek közé tett fájlnév követi. A fordítóprogram egyszerűen az include utasítás helyére írja a fájl tartalmát. Ez olyan, mintha egy szövegszerkesztõvel erre a helyre beillesztenénk a fájl tartalmát. Az include utasítás egy szokásos használata, hogy a definíciókat csak egyszer írjuk le és szükség szerint több helyen is felhasználjuk. ifdef Az ifdef feltételes fordítást tesz lehetővé, amikor is a Verilog forráskód bizonyos sorai csak bizonyos feltételek megléte esetén fordítódnak le. Az ifdef egyik felhasználása, hogy egy bizonyos alkalmazás tartalmazzon-e diagnosztikai kódot. Az ifdef utasítást egy szöveg makró neve követi. (megjegyezzük,

238 Szakasz 1: Operátor 238 VIII.9. ábra. ifdef c 2004, Doulos Verilog

239 Szakasz 1: Operátor 239 hogy amikor az ifdef utasításban használunk makrót, a fordított aposztróf nem szükséges.) Ha a makrót már definiáltuk, a következő utasítások egészen a következő endif utasításig lefordulnak, a makró aktuális értékétől függetlenül. else Amikor egy else direktíva is jelen van, az ifdef és else közötti részek fordulnak le, ha a makro definiálva van, különben pedig az else és endif közötti részek fordulnak le. Az ifdef utasítások egymásba ágyazhatók Egy Verilog utasítássorban definiálhatunk egy define makrót, és esetleg értéket is adhatunk neki. A részletek a használt Verilog szimulátortól függenek. A fenti példa a Cadence Verilog-XL szimulátor esetére vonatkozik.

240 Szakasz 2: Paraméterek Paraméterek A paramétereket modulokban definiáljuk, és azok megőrzik értéküket a szimuláció során. Deklarációkban és kifejezésekben a paraméterek a literális konstansok helyett használhatók. A paraméterek és a define makrók általában felcserélhetők. A paraméterek jobban használhatók, míg a define makrók globálisak is lehetnek. A paraméterek felülírhatók, lásd később. Íme néhány példa, ahol paramétereket használunk a literális értékek helyett. Helyes gyakorlat, hogy fontos literális konstansoknak (ezeket néha "mágikus számnak " is nevezik) nevet adunk. Ettõl Verilog kódunk egyszerűbben olvashatóvá és karbantarthatóvá válik. Erre a célra mind define makrók, mind paraméterek használhatók. Vegyük észre a másolat használatát, amikor új értéket adunk a BusWire változónak. Paraméternév nem használható egy szám méretének megadására, helyette az ábrának megfelelően használjunk

241 Szakasz 2: Paraméterek 241 VIII.10. ábra. Paraméterek c 2004, Doulos Verilog

242 Szakasz 2: Paraméterek 242 VIII.11. ábra. A paraméterek használata c 2004, Doulos Verilog

243 Szakasz 2: Paraméterek 243 másolatkészítést. A modulokat általában hardver blokkok vagy teszt fixtúrák ábrázolására használjuk. A modulokat használhatjuk arra, hogy összetartozó értékeket (pl. paramétereket) egy helyre csoportosítsunk, amikre azután hierarchikus nevekkel hivatkozhatunk. A hierarchikus neveket úgy képezzük, hogy a paraméter neve elé írjuk a modul nevét (Codes) és egy pontot. Például, Codes.Add a Codes modul Add paraméterére hivatkozik. Ezt a modult a terv többi részében szimuláljuk, azt sehol sem kell példányosítani. Megjegyezzük, hogy a szintézis eszközök általában nem támogatják a hierarchikus neveket. A módszer egy alternatívája az include direktíva használata. A paraméter meghatározásokat egy különálló fájlban is elhelyezhetjük és az include direktíva használatával beszúrhatjuk ott, ahol az szükséges.

244 Szakasz 2: Paraméterek 244 VIII.12. ábra. Paraméterek használata más modulokban c 2004, Doulos Verilog

245 Szakasz 2: Paraméterek 245 VIII.13. ábra. Paraméterek egy különálló fájlban c 2004, Doulos Verilog

246 Szakasz 2: Paraméterek 246 Megjegyezzük, hogy (a C #define utasításától eltérően) az include utasítások a modulon kívül és azon belül is elhelyezhetők. Ez a Decode modul az input paraméter szélességére az A, az output szélességére a F paramétert használja. Az OutWidth paramétert Width értékéből származtatjuk, és a Width és Polarity paraméterek után deklaráljuk, aminek okát rövidesen látni fogjuk. Van egy, a dekóder polaritását megadó paraméter is: ha Polarity értéke 1, a modul egy "one-hot" dekódert ír le (egy bit 1 értékű, az összes többi nulla); ha Polarity értéke 0, egy "one-cold" dekódert írunk le. Figyeljük meg a másolás használatát, hogy F valamennyi bitjét 1 értékűvé állítsuk, amikor Polarity értéke 0. A paraméterek ilyen használata megkönnyíti a modul részleteinek módosítását - csak a paraméterek értékét kell megváltoztatnunk. Amit szintén érdemes észrevenni, hogy bár a Verilogban nincs hatványozás ("power of") operátor a kettő hatványai leírhatók a balra léptető operátor használatával.

247 Szakasz 2: Paraméterek 247 VIII.14. ábra. Paraméterezett modul c 2004, Doulos Verilog

248 Szakasz 2: Paraméterek 248 VIII.15. ábra. Paraméterek felülírása c 2004, Doulos Verilog

249 Szakasz 2: Paraméterek 249 Amikor egy paramétereket tartalmazó modult példányosítunk, azok értékét felülírhatjuk a (#) operátor használatával. A fenti példában #(4, 0) azt jelenti, hogy a D1 példány esetében Width (a Decode modulban deklarált első paraméter) a 4 értéket kapja 1 helyett; a második paraméter, Polarity pedig a 0 értéket kapja. A Decode többi példánya változatlan marad. Figyeljünk arra, hogy ne írjunk felül olyan származtatott paramétereket, mint OutWidth: a modul példánya nem fog helyesen működni! Ezért kell a származtatott paramétereket a felülírható paraméterek után deklarálni. A név szerinti leképezés (ami akkor használható, amikor vezetékeket és reg-eket portokhoz kapcsolunk egy modul példányban) nem használható paraméter felülírás esetén. defparam Paramétereket a defparam használatával is felülírhatunk. A defparam utasítások általában a paraméterek hierarchikus nevét

250 Szakasz 2: Paraméterek 250 VIII.16. ábra. defparam c 2004, Doulos Verilog

251 Szakasz 2: Paraméterek 251 használják.

252 Szakasz 3: Hierarchia Hierarchia Mint már láttuk, a paraméterekre hierarchikus nevükkel is hivatkozhatunk. Valójában a modul hierarchián belül akárhonnét hivatkozhatunk bármely, névvel rendelkezõ Verilog objektumra. Ez lehetővé teszi, hogy Verilog modulokba és elnevezett blokkokba betörhessünk, azaz az ezekben deklarált adatokat kívülről, portok és argumentumok nélkül használjuk. Ez általában nagyon rossz gyakorlat, kivéve a teszt fixtúrákat, ahol rendkívül hasznos. Egy adat teljes hierarchikus neve a legfelső modul nevével kezdődik, majd a hierarchiában lefelé haladva, a példány nevek és blokk nevek következnek. Egy hierarchikus nevet úgy is képezhetünk, hogy a modul példány vagy az elnevezett blokk nevével kezdünk. Például, egy teszt fixtúrában egy $display utasítás úgy hivatkozhat a szimulált terv hierarchiájában az adatokra, hogy hierarchikus neveket használ. Egy Verilog szimulációban egynél több felső szintű modul is

253 Szakasz 3: Hierarchia 253 VIII.17. ábra. Hierarchikus nevek c 2004, Doulos Verilog

254 Szakasz 3: Hierarchia 254 lehet! Két ilyen hierarchia egymással hierarchikus neveket használva kommunikálhat. Az ábrán az Annotate modulban levő nevek a terv Test nevű felső szintű moduljában levő paraméterekre hivatkoznak. Az eddig látott hierarchikus nevek mind teljes, vagy pedig lefelé irányuló hivatkozások voltak: Ezek a hierarchikus nevek vagy a felső szintű modulból indulnak vagy pedig annak a modulpéldánynak a nevével vagy a modulbeli blokk nevével, amelyben a hierarchikus nevet használjuk. A Verilog a felfelé irányuló név hivatkozásokat is támogatja. Ez azt jelenti, hogy olyan modulra vagy elnevezett blokkra is hivatkozhatunk, amelyik a hierarchiában magasabban helyezkedik el, a modul példányának nevét, a modul nevét vagy egy blokk nevét használva.

255 Szakasz 3: Hierarchia 255 VIII.18. ábra. Felfelé irányuló név hivatkozások c 2004, Doulos Verilog

256 Szakasz 3: Hierarchia 256

257 Automaták 257 fejezet IX: Automaták

258 Szakasz 1: RTL always utasítás RTL always utasítás IX.1. ábra. Véges állapotú automaták c 2004, Doulos Verilog

259 Szakasz 1: RTL always utasítás 259 A véges állapotú automata a digitális logikai áramkörtervezés hasznos segédeszköze. Mint a neve is mutatja, egy véges állapotú automata (Finite State Machine, FSM) olyan digitális logikai áramkör, amelynek véges számú belső állapota van. A FSM bemeneteinek értékét és pillanatnyi állapotát használja arra, hogy meghatározza kimeneteinek értékét és következő állapotát. Csak a szinkron állapotgépekkel foglalkozunk, ahol az állapot az órajel aktív élének hatására változik. Egy véges állapotú automata hardverként egy állapotregiszterből, valamint a következő állapot kiszámítására szolgáló kombinációs logikából és a kimenetek értékének kiszámítására szolgáló kombinációs logikából áll. Moore kimenetek A Moore kimenetek csak az automata pillanatnyi állapotától függenek, azaz a kimenetek csak akkor változnak, amikor az automata állapotot vált. Mealy kimenetek A Mealy kimenetek az automata pillanatnyi állapotán kívül

260 Szakasz 1: RTL always utasítás 260 a bemenetek pillanatnyi értékétől is függenek, azaz a bemenetek értékének megváltozása (valamennyi kombinációs késleltetés után) a kimenetek megváltozását okozhatja, anélkül, hogy meg kellene várnunk a következő állapotátmenetet. Egy véges állapotú automatát jól ábrázolhatunk az IX.2 ábra szerinti állapotátmenet diagramokkal. A diagramon szereplő "buborékok" az automata különböző belső állapotait ábrázolják. A buborékokat összekötő nyilak az állapotátmeneteknek felelnek meg, a nyilakhoz fűzött magyarázó szövegek (pl. Start = 1) pedig azokat a bemeneti feltételeket adják meg, amelyek hatására az adott állapotátmenet végbemegy. Az egyes állapotoknak megfelelő buborékoknak van egy szimbolikus neve (pl. Idle) és szerepelnek bennük az abban az állapotban érvényes kimeneti értékek. Ezek Moore kimenetek, mivel a kimeneti érték csak attól az állapottól függ, amelyben az automata éppen van. A Mealy kimenő értékeket az átmenetet ábrázoló nyilakhoz fűzött szövegben mutatnánk. Az állapotdiagramok használata néha előnyösebb, mint a rövid leírásoké. Például, azok az átmenetek, amelyek nem egy másik állapot-

261 Szakasz 1: RTL always utasítás 261 IX.2. ábra. Véges állapotú automaták c 2004, Doulos Verilog

262 Szakasz 1: RTL always utasítás 262 ból, hanem egy pontból indulnak (pl. Reset = 1), globális átmenetek. Ezeknek magasabb a prioritása, mint a többi bemeneti feltételnek, és hatásukra az automata bármelyik másik állapotból közvetlenül a megadott állapotra ugrik. Egy másik jelölésbeli rövidítés, hogy ezen az állapotátmenet diagramon a kimeneteket nulla alapértelmezett értékűnek tekintjük. A diagram csak a nem-nulla értékű kimeneteket mutatja explicit módon. A Verilog nyelven általában úgy írunk le egy véges állapotú automatát, hogy egy always utasításba case utasításokat teszünk. Az automata állapotát egy állapotregiszterben tároljuk, és valamennyi lehetséges állapotot paraméter értékekkel írunk le. Inicializálás A véges állapotú automatákat explicit módon inicializálni kell egy reset jellel. Enélkül nincs garancia arra, hogy az automata valamiféle ismert állapotba kerül, így az állapotot egyenlőségét sem vizsgálhatjuk. A véges állapotú automatát a most adott leírás szerint egy órajel

263 Szakasz 1: RTL always utasítás 263 Programlista IX.1: Az automata állapotainak explicit megadása parameter Idle = 2 b00, Go1 = 2 b01, Go2 = Az 2 állapotgépben b10 ; reg [ 1 : 0 ] State ; kell reset... lehetőségnek lenni posedge Clock or posedge Reset ) i f ( Reset ) begin State <= Idle ; F <= 0 ; G <= 0 ; end else case ( State ) Idle : i f ( Start ) begin State <= Go1; F <= 1 ; end Go1 : begin State <= Go2; F <= 0 ; G <= 1 ; end Go2 : begin State <= Idle ; G <= 0 ; end endcase

264 Szakasz 1: RTL always utasítás 264 IX.3. ábra. Az automata felépítése c 2004, Doulos Verilog

265 Szakasz 1: RTL always utasítás 265 vezérelt always utasítás, a State állapotvektort ábrázoló Verilog regiszterek, valamint az F és G kimenetek írják le. A szintézis ezekhez a regiszterekhez flip-flopokat állít elő, amelyek biztosítják, hogy mind az állapotátmeneteket, mind a kimenetek értékét az órajel szinkronizálja. A kimenetek esetén azonban nemkívánatos lehet a flip-flopok jelenléte! A tankönyv szerinti Moore automata csak az állapotvektort tartalmazó regiszterekből, a következő állapotot dekódoló kombinációs logikából és az adott állapotból származó kimenetekből áll. A nemkívánatos flipflopok kiküszöbölésére át kell írnunk a Verilog kódot. A flip-flopok kiküszöbölésére a leírást legalább két always utasítással kell megvalósítanunk. Ennek elérésre különböző módszerek vannak, a két leginkább használatosat az előző és a következő ábrák tartalmazzák. Az IX.2 listán szereplő kód az előző állapotgép egy olyan kódolását mutatja, amelyik két always utasítást használ. Az első leírja az állapotvektort és az állapotátmeneteket, a másik pedig a kimenet dekódoló logikát. Mivel a kimeneti always utasítás így már tisztán

266 Szakasz 1: RTL always utasítás 266 Programlista IX.2: Az automata állapotainak explicit megadása parameter Idle = 2 b00, Go1 = 2 b01, Go2 = 2 b10 ; reg [ 1 : 0 ] State ;... posedge Clock or posedge Reset ) i f ( Reset ) State <= Idle ; else case ( State ) Idle : i f ( Start ) State <= Go1; Go1 : State <= Go2; Go2 : State <= Idle ; endcase... State ) begin F = 0 ; G = 0 ; i f ( State == Go1) F = 1 ; else i f ( State == Go2) G = 1 ; end

267 Szakasz 1: RTL always utasítás 267 kombinációs, az extra flip-flopok eltűnnek. Az állapotautomaták leírásának egy másik szokásos stílusa, hogy a kombinációs logikából eltávolítjuk a regisztereket. Az IX.3 listán mutatott példa ugyanazt az állapotgépet mutatja. Ebben egy always utasítás írja le az állapotregisztereket, egy másik pedig a következő állapotot és a kimenetet dekódoló logikát. Ebben az esetben egy további regiszter, NextState, szükséges ahhoz, hogy a kombinációs always utasítás tudjon kommunikálni az órajelvezérelt always utasítással. Mivel a NextState állapot State és Start kombinációs függvénye, annak teljesen meghatározottá kell válnia az always blokkban (különben latch áramkörökre van szükség). A NextState = State értékadás biztosítja, hogy ilyen latch áramkörökre ne legyen szükség. Ez az utasítás a szimulációt nem befolyásolja: csak arra kell, hogy a szintézis eszközök megfelelõen értelmezzék az always blokkot. A "szeparált kimenetdekódolás" stílus egy lehetséges előnye, hogy a következő állapotot és a kimenetet dekódoló logika közös részeit nem

268 Szakasz 1: RTL always utasítás 268 Programlista IX.3: Regiszterek eltávolítása a kombinációs logikából parameter Idle = 2 b00, Go1 = 2 b01, Go2 = 2 b10 ; reg [ 1 : 0 ] State, NextState ;... posedge Clock or posedge Reset ) i f ( Reset ) State <= Idle ; else State <= NextState ;... State or Start ) begin F = 0 ; G = 0 ; NextState = State ; case ( State ) Idle : i f ( Start ) NextState = Go1; Go1 : begin F = 1 ; NextState = Go2; end Go2 : begin G = 1 ; NextState = Idle ; end endcase end

269 Szakasz 1: RTL always utasítás 269 kell duplikálni, ezáltal a kód rövidebbé és az optimalizáló munkája egyszerűbbé válik. A "szeparált kimenetdekódolás" stílus egy lehetséges hátránya, hogy a szimuláció kevésbé hatékonnyá válik, ha a következõ állapot logikája a bemenetektől is függ (ez nem áll fenn az előbbi esetben), mivel ilyenkor további alkalmakkor is végre kell hajtani a kombinációs always utasítást, amikor egy bemenet megváltozik. Mindkét leírási stílus korrekt viselkedést és korrekt szintézist eredményez, mindkettőnek vannak követői. Ízlés szerint bármelyiket választhatjuk. Néha teljesen ki akarjuk küszöbölni a kimenet dekódoló logikát a véges állapotú automata tervéből, és ennek érdekében az egyes állapotok állapotvektorának kódolását az állapot kimeneti értékeivel egyenértékűvé tesszük. Ennek elérésére megfelelő kódolást kell kidolgoznunk és megfelelően deklarálni az állapotparamétereket. Végül pedig, az állapotvektor bitjeit át kell másolnunk a kimenetekbe. Az FPGA-ban megvalósított FSM esetén általában jó választás a

270 Szakasz 1: RTL always utasítás 270 Programlista IX.4: Kimeneti dekódolás nélkül parameter Idle = 3 b100, Go1 = 3 b010, Go2 = 3 b001 ; reg [ 2 : 0 ] State ;... posedge Clock or posedge Reset ) i f ( Reset ) State <= Idle ; else case ( State ) Idle : i f ( Start ) State <= Go1; Go1 : State <= Go2; default : State <= Idle ; endcase assign F = State [ 1 ] ; assign G = State [ 0 ] ;

271 Szakasz 1: RTL always utasítás 271 Programlista IX.5: Regiszterek eltávolítása a kombinációs logikából parameter Idle = 0, Go1 = 1, Go2 = 2 ; reg [ 2 : 0 ] State ; posedge Clock or posedge Reset ) i f ( Reset ) begin State <= 3 b000 ; State [ Idle ] <= 1 b1 ; end else begin State <= 3 b000 ; case ( 1 b1) // synopsys parallel_case State [ Idle ] : i f ( Start ) State [Go1] <= 1 b1 ; else State [ Idle ] <= 1 b1 ; State [Go1] : State [Go2] <= 1 b1 ; State [Go2] : State [ Idle ] <= 1 b1 ; endcase end State ) begin F = State [Go1 ] ; G = State [Go2 ] ; end "Manual output decoding"

272 Szakasz 1: RTL always utasítás 272 "one-hot state encoding", mivel az jól illik az FPGA felépítéséhez. Az IX.5 programlistán valójában nem is "one-hot state encoding" technikát használunk, de a szintézis eszköz ezt nem ismeri fel és teljesen dekódolja az állapot flip-flop értékeket az állapot előállítására. A példában az Idle, Go1 és Go2 paraméterek már nem az állapotok flip-flop értékei, hanem a megfelelő állapot-flipflop pozíciója az állapot-flipflopok között. Például, az Idle állapotban State[Idle] értéke 1 b1 lesz, továbbá State[Go1] és State[Go2] értéke egyaránt 1 b0. Az IX.5 listán bemutatott példa egy konstans (1 b1) case kifejezéssel működő case utasítást használ, ahol a változó case értékek a State bitjei. A parallel_case direktíva azt közli a szintézis eszközzel, hogy a (State[Idle], State[Go1] or State[Go2]) case kifejezésnek csak egyetlen értéke felel meg az 1 b1 case kifejezésnek, azaz a kódolás "onehot". Megjegyezzük, hogy a kimeneteket manuálisan kódoljuk. Az IX.6 ábrán az első kód kevéssé hatékony logikát eredményez, mivel a szintézis eszköz nem fog "one-hot" kódolást feltételezni. Amint

273 Szakasz 1: RTL always utasítás 273 Programlista IX.6: Regiszterek eltávolítása a kombinációs logikából State ) begin F = 0 ; G = 0 ; i f ( State == Go1) F = 1 ; else i f ( State == Go2) G = 1 ; end Ez a kód kevéssé hatékony logikát eredményez State ) begin Használhatjuk viszont a parallel_case directívát F = 0 ; G = 0 ; case ( 1 b1) // synopsys parallel_case State [Go1] : F = 1 ; State [Go2] : G = 1 ; endcase end

274 Szakasz 1: RTL always utasítás 274 a második kódrészlet mutatja, használhatunk azonban egy másik case utasítást, egy parallel_case direktívával, az állapotlogika always blokkjában használthoz hasonló módon. Egy szintézis eszköz az egyes állapotokat általában az állapot nevének megfelelő paraméterek értékének felhasználásával kódolja. Bizonyos szintézis eszközök felismerik, hogy egy állapotgépre vonatkozik a leírás, és a kódolást automatikusan ennek megfelelőre módosítják. Más eszközök akkor módosítják a kódolást, ha bizonyos szintézis direktívák vagy pragmák jelen vannak a Verilog kódban. A fenti példa egy olyan szintaxist mutat, amelyet a Synopsis szintézis eszközök használnak arra, hogy az eszközöknek engedélyezzék az állapotkódolás megváltoztatását. Más eszközök hasonló szintaxist támogatnak, lásd a megfelelő dokumentációkat. Az új kódolás (a target technológiától függően) vagy bináris, vagy "one-hot" lesz. Bináris esetén a paraméterlista első állapota lesz a bináris 0, a következő a bináris 1 és így tovább. A "one-hot" kódolás esetén állapotonként van egy flip-flop, és minden egyes állapotban csak

275 Szakasz 1: RTL always utasítás 275 IX.4. ábra. Állapotkódolás c 2004, Doulos Verilog

276 Szakasz 1: RTL always utasítás 276 egyetlen flip-flop lehet 1 állapotú. Sok szintézis eszköz lehetővé teszi a felhasználóknak, hogy standard kódolási módszerekből (Gray, One Hot, Adjacency, Random, LFSR, stb) válasszanak, Sok eszköz kínál egy automatikus kódolási módszert, amelyik "okos" algoritmusok alapján a "legjobb" kódolást választja. A gyakorlatban azonban a legjobb megoldást a mérnöki tapasztalat eredményezi, a kódolást kézzel kiválasztva. (Ebben a példában a // synopsys enum States direktíva azt közli a szintézis eszközzel, hogy a Idle, Go1 és Go2 paraméterek az enum típusú States tagjai. Ezután a reg State típusát megadhatjuk States típusúként. Ez azt jelenti, hogy ez a változó csak a Idle, Go1 és Go2 értékek valamelyikét veheti fel nem adhatunk numerikus értéket, csak ezeket a paraméter neveket. A másik direktíva - // synopsys state_vector State - azt közli a segédprogrammal, hogy State egy állapotgép állapotvektora. A segédprogram ezt automatikusan feldolgozza. Megjegyezzük, hogy paraméter deklarációban vektor értéktar-

277 Szakasz 1: RTL always utasítás 277 tományt megadni az IEEE 1364 Verilog standard szerint nem megengedett. Néhány szintézis eszköz viszont ezt megköveteli, így a legtöbb segédprogram támogatja ezt a nyelvi kiterjesztést. Amikor egy állapotgépet hardverben valósítunk meg, az állapotok száma 2N lesz, ahol N az állapotvektor bitjeinek száma. Ha az állapotgépnek 2N állapotnál kevesebb állapota van, a fennmaradó állapotok nem érhetők el az automata normál logikai működése során. A bekapcsoláskor azonban az automata kerülhet az elérhetetlen állapotok valamelyikébe is, vagy eljuthat ilyen állapotba szélsőséges működési feltételek hatására. Don t care Ha nem definiáljuk, hogy az állapotgép hogyan viselkedjék egy elérhetetlen állapotban, a szintézis eszköz kihasználhatja azt a tényt, hogy a tervező számára nem fontos, mi történik ilyen állapotban. Másrészt viszont, ha ellenőrizni szeretnénk az állapotgép viselkedését elérhetetlen állapotokban (pl. közvetlenül ide jutni reset állapotban), akkor annak viselkedését explicit módon meg kell adnunk

278 Szakasz 1: RTL always utasítás 278 IX.5. ábra. Elérhetetlen állapotok c 2004, Doulos Verilog

279 Szakasz 1: RTL always utasítás 279 IX.6. ábra. Elérhetetlen állapotok vezérlése c 2004, Doulos Verilog