Beágyazott rendszerek a mérnöki gyakorlatban Molnár, András Turóczi, Antal Stojcsics, Dániel Léczfalvy, Ádám Kelemen, József Somlyai, László

Beágyazott rendszerek a mérnöki gyakorlatban Molnár, András Turóczi, Antal Stojcsics, Dániel Léczfalvy, Ádám Kelemen, József Somlyai, László

Beágyazott rendszerek a mérnöki gyakorlatban írta Molnár, András, Turóczi, Antal, Stojcsics, Dániel, Léczfalvy, Ádám, Kelemen, József, és Somlyai, László

Tartalom I. könyv. Digitális technikai alapáramkörök labormérése... 1 1. Bevezetés... 4 2. A mérés során használt eszközök... 5 2.1. Spartan 3 FPGA család... 5 2.1.2.1.1. Kapcsolómátrix... 6 2.1.2.1.2. Órajel... 6 2.1.2.1.3. Konfigurálható logikai blokk... 6 2.1.2.1.4. Lookup table (LUT)... 8 2.1.2.1.5. Erőforrások... 10 2.2. Digilent Basys 2 Spartan-3E FPGA Board... 11 3. Xilinx ISE fejlesztő rendszer... 14 3.1. Első mintafeladat elkészítése kapcsolási rajz alapú tervezés... 16 3.1.3.1.1. Kapcsolási rajz készítése... 19 3.1.3.1.2. A kapcsolás ellenőrzése szimulációval... 21 3.1.3.1.2.3.1.2.1. Szimulációs fájl készítése... 21 3.2. Makró hozzáadása meglévő projekthez... 26 3.2.3.2.1. Példa kapcsolási rajz alapú makró készítésére... 26 3.2.3.2.2. Kapcsolási rajz alapú saját makró módosítása... 28 3.2.3.2.3. Kapcsolási rajz alapú saját makró hozzáadása projekthez... 30 3.2.3.2.4. VHDL alapú saját makró hozzáadása projekthez... 30 3.3. Kapcsolási rajz elkészítése a makró használatával... 30 3.4. A kapcsolás hardveres ellenőrzése... 32 3.4.3.4.1. A konfigurációs fájl letöltése az FPGA-ba... 35 3.5. Az órajel bemenet prellmentesítése... 35 4. Egyszerű kombinációs hálózatok... 36 4.1. Multiplexer, demultiplexer... 36 4.1.4.1.1. Multiplexer... 36 4.1.4.1.1.4.1.1.1. 2 bemenetű multiplexer... 36 4.1.4.1.1.4.1.1.2. 4 bemenetű multiplexer... 37 4.1.4.1.2. Latch... 41 4.1.4.1.3. Korrekt flip-flop órajel engedélyezés... 41 4.1.4.1.4. Demultiplexer... 42 4.1.4.1.5. Laborfeladat... 43 4.1.4.1.5.4.1.5.1. Alkalmazandó műszerek és eszközök... 44 4.2. Kódolók... 44 4.2.4.2.1. Komparátorok (Magnitude Comparators)... 44 4.2.4.2.2. Enkóderek... 46 4.2.4.2.3. Prioritáskódoló (priority encoder)... 47 4.2.4.2.4. Dekóder... 50 4.2.4.2.4.4.2.4.1. 4-ről 1-re dekóder engedélyező jellel... 50 4.2.4.2.5. Laborfeladat... 51 4.2.4.2.5.4.2.5.1. Alkalmazandó műszerek és eszközök... 52 4.3. Összeadó áramkör... 52 4.3.4.3.1. Teljes összeadó (full adder)... 53 4.3.4.3.2. BCD összeadó... 56 4.3.4.3.3. Laborfeladat... 57 4.3.4.3.3.4.3.3.1. Alkalmazandó műszerek és eszközök... 57 4.4. Aritmetikai és Logikai Egység (ALU)... 57 4.4.4.4.1. ALU blokkvázlata... 58 4.4.4.4.2. ALU műveletvégző egységei... 58 4.4.4.4.3. Laborfeladat... 62 4.4.4.4.3.4.4.3.1. Alkalmazandó műszerek és eszközök... 64 4.5. Shift regiszter... 64 4.5.4.5.1. Léptető regiszterek... 64 4.5.4.5.1.4.5.1.1. Soros-párhuzamos átalakító... 64 4.5.4.5.1.4.5.1.2. Párhuzamos-soros átalakító... 65 iii

Beágyazott rendszerek a mérnöki gyakorlatban 4.5.4.5.1.4.5.1.3. Jobbra-balra léptető regiszter... 65 4.5.4.5.1.4.5.1.4. Barrel shifter... 65 4.5.4.5.2. Egyéb alkalmazások shift-regiszterrel... 66 4.5.4.5.2.4.5.2.1. Lifo... 66 4.5.4.5.2.4.5.2.2. A Johnson számláló... 68 4.5.4.5.2.4.5.2.3. Soros összeadó... 68 4.5.4.5.3. Laborfeladat... 69 4.5.4.5.3.4.5.3.1. Alkalmazandó műszerek és eszközök... 69 5. Négybites CPU tervezés... 70 5.1. Bevezetés... 70 5.1.5.1.1. Számítógépes architektúrák... 70 5.1.5.1.2. Utasításkészlet... 71 5.1.5.1.3. A labormérés alatt megépítendő CPU architektúrája... 71 5.1.5.1.4. A CPU utasításainak felépítése... 72 5.1.5.1.4.5.1.4.1. Az A és B regiszter bemenetének kiválasztása (Register input select)... 73 5.1.5.1.4.5.1.4.2. ALU vezérlése (ALU control)... 75 5.1.5.1.4.5.1.4.3. Ugró utasítások, a programszámláló megváltoztatása (Branch control)... 77 5.1.5.1.4.5.1.4.4. Egyéb vezérlő jelek... 80 5.1.5.1.4.5.1.4.5. Az utasítások felépítése... 82 5.1.5.1.4.5.1.4.6. Mnemonik... 82 5.1.5.1.4.5.1.4.7. A CPU teljes utasításkészlete... 82 5.1.5.1.5. Laborfeladat... 83 5.1.5.1.5.5.1.5.1. Alkalmazandó műszerek és eszközök... 83 5.2. Órajel forrás, programszámláló, utasításregiszter, kijelzés... 83 5.3. ALU és regiszterek... 90 5.4. Kimeneti regiszterek, memória, ugró utasítás... 97 5.5. Programkód írás... 106 II. Könyv. Gadgeteer... 110 6.... 112 6.1. Kiknek szól a tananyag?... 112 6.2. Miért.NETGadgeteer?... 112 6.3. Szükséges előismeretek... 112 7. Bevezetés a.net Gadgeteer használatába... 113 7.1..NET Gadgeteeralkalmazások készítéséhez szükséges eszközök... 113 7.2. FEZ Spider Starter Kit... 113 7.3. A FEZ Spider demóapanel használata... 116 7.4. Jelölések a demópanelen... 116 7.5. Jelölések a próbamodulokon... 117 7.6. A demópanel csatlakoztatása PC-hez... 117 7.7. Egy egyszerű Gadgeteer program elkészítése... 118 7.8. Felkészülést segítő kérdések... 123 8. Stopper alkalmazás készítése.netgadgeteer-el... 125 8.1. A feladat célja... 125 8.2. A projekt létrehozása... 125 8.3. Az eszköz elkészítése... 126 8.4. Az program megírása... 128 8.4.8.4.1. Stopper osztály készítése... 128 8.4.8.4.1.8.4.1.1. A főprogram elkészítése... 132 8.5. A program futtatása... 134 8.6. Felkészülést segítő kérdések... 134 9. Fényerő szabályozó lámpa érintő kapcsoló.netgadgeteer használatával... 135 9.1. A feladat célja... 135 9.2. A projekt létrehozása... 135 9.3. A program megírása... 136 9.4. A teljes forráskód... 141 9.4.9.4.1. Felkészülést segítő kérdések... 143 10. SD kártya olvasó.net Gadgeteer használatával... 144 10.1. A feladat célja... 144 iv

Beágyazott rendszerek a mérnöki gyakorlatban 10.2. A projekt létrehozása... 144 10.3. A program megírása... 145 10.4. A teljes forráskód... 152 10.5. Felkészülést segítő kérdések... 154 10.6. Felhasznált irodalom... 154 Irodalomjegyzék... 155 v

Az ábrák listája 2.1. A Spartan-3 család belső felépítése [2]... 5 2.2. Az órajel hálózat részei [1]... 6 2.3. A szeletek elhelyezkedése a CLB-ben [2]... 6 2.4. A szeletek összetevői [2]... 7 2.5. LUT... 8 2.6. Kapcsoló mátrix összeköttetések [2]... 10 2.7. A részegységek FPGA-n belüli tömbszerkezete [2]... 10 2.8. Digilent Basys 2 Spartan-3E FPGA panel [3]... 11 2.9. Az Adept program konfigurációs felülete... 11 2.10. Kapcsolók, nyomógombok és hétszegmenses kijelzők [3]... 12 3.1. A tervezés menete [1]... 14 3.2. Új projekt létrehozása... 16 3.3. Új projekt létrehozása... 17 3.4. A Project Navigator részei... 18 3.5. A Symbols segédablak és a használt alkatrészek... 19 3.6. Szimulációs fájl hozzáadása a projekthez... 21 vhd-1.../section/src/codetestbrench1.vhd... 22 vhd-2.../sections/src/codetestbrench2.vhd... 23 3.7. A szimuláció eredménye a Xilinx ISE Simulator hullámforma ablakában.... 25 3.8. Kijelzés formátuma... 25 3.9. További jelek hozzáadása... 26 3.10. Kapcsolási rajz módosítása... 26 3.11. Elkészült makró kiválasztása... 27 3.12. Top modul... 27 3.13. Kimenet... 28 3.14. Kapcsolási rajz alapú makró módosítása... 29 3.15. Módosított szimbólumfájl... 29 3.16. Makró szerkesztés... 30 3.17. 8 bites számláló kapcsolási rajza... 31 3.18. 8 bites számláló fájlok... 31 vhd-3.../sections/src/codetestbrench3.vhd... 31 3.19. 8 bites számláló szimulációs eredmény... 32 3.20. A Basys2_100_250General.ucf fájl... 33 vhd-4.../sections/src/codeucfclk4bit.vhd... 33 3.21. UCF... 34 vhd-5.../sections/src/codeucfclkprell.vhd... 35 3.22. A teszt.sch kapcsolási rajz módosítása... 35 4.1. Két bemenetű multiplexer kapcsolási rajza... 36 4.2. Két bemenetű multiplexer logikai rajza... 36 4.3. Négy bemenetű multiplexer logikai rajza... 37 4.4. Négy bemenetű multiplexer kapcsolási rajza... 38 4.5. 16 bemenetű multiplexer tervezése kisebb multiplexerek felhasználásával... 39 4.6. Look-up table megvalósítása multiplexer segítségével... 40 4.7. Latch... 41 4.8. Korrekt flip-flop órajel engedélyezés... 42 4.9. Négy kimenetű demultiplexer... 42 4.10. Négy kimenetű demultiplexer kapcsolási rajza... 43 4.11. 2-szer 4-bites komparátor blokkrajza... 44 4.12. Magnitude Comparator egy áramköri megvalósítása... 45 4.13. 8_to_3 enkóder egy áramköri megvalósítása:... 47 4.14. 8 bites prioritáskódoló rajzjele... 48 4.15. 8 bites prioritáskódoló blokkrajza... 49 4.16. A 8 bites prioritáskódoló megvalósítása 2 4 bitesből... 49 4.17. 4-ről 1-re dekóder blokkrajza... 50 4.18. 4-ről 1-re dekóder engedélyező jellel egy áramköri megvalósítása... 51 4.19. Félösszeadó áramkör kapcsolási rajza... 52 vi

Beágyazott rendszerek a mérnöki gyakorlatban 4.20. Teljes összeadó egy megvalósítása... 53 4.21. Teljes összeadó egy megvalósítása... 54 4.22. Teljes összeadó megvalósítása félösszeadó áramkörök segítségével... 55 4.23. 4 bites összeadó áramkör... 55 4.24. BCD összeadó... 56 4.25. A laborgyakorlat során megépítésre kerülő ALU blokkvázlata... 58 4.26. ALU... 62 4.27. Gyűrüs számláló... 64 4.28. Shift regiszter... 64 4.29. Shift regiszter párhuzamos adatbemenettel... 65 4.30. Jobbra-balra léptető regiszter... 65 4.31. Fast, Compact Barrel Shifter with Encoded Shift Control... 65 4.32. LIFO... 66 4.33. Johnson számláló... 68 4.34. Shift Register Applications Example:... 69 5.1. Intel 80486-os processzor... 70 5.2. Neumann és Harvard számítógép architektúra... 71 5.3. A laborgyakorlatok alatt épített négybites CPU blokkvázlata... 71 5.4. Az utasítások felépítése... 82 5.5. Az utasítások felépítése... 82 5.6. Utasításkészlet... 82 5.7. A mintaprogram mnemonikjai és utasításkódjai... 86 5.8. Ki-bemeneti egységek... 86 5.9. A CPU műveletvégző egysége és regiszterei... 90 5.10. A mintaprogram mnemonikjai és utasításkódjai... 92 5.11. Ki-bemeneti egységek... 92 5.12. A processzor blokkvázlatának részlete... 98 5.13. A mintaprogram mnemonikjai és utasításkódjai... 101 5.14. Ki-bemeneti egységek... 101 5.15. Fordító program felépítése... 107 5.16. Mintaprogram for ciklusra... 107 vhd-6.../sections/src/codefor.vhd... 108 5.17. Mintaprogram for ciklusra, hibaüzenettel... 108 7.1. FEZ Spider Starter Kit... 113 7.2. FEZ Spider demópanel... 114 7.3. "Piros modul"... 116 7.4. Csatlakozó aljzat a demópanelen... 116 7.5. Csatlakozó aljzat a próbamodulon... 117 7.6. Demópanelhez kapcsolt piros modul... 117 7.7. Új projekt létrehozása... 118 7.8. A létrehozni kívánt Gadgeteer projekt opciói... 118 7.9. A létrehozott Gadgeteer projekt... 119 7.10. A demópanel csere után... 120 7.11. Próbamodulok a grafikus tervezőben... 120 7.12. A demópanelra bekötött nyomógomb... 121 7.13. A bekötött alkatrészek... 121 7.14. A programkódot tartalmazó fájl kiválasztása... 121 7.15. a program futtatás közben... 123 8.1. Új projekt létrehozása... 125 8.2. Projekt tulajdonságainak beállítása... 125 8.3. Stopper készülék tervező nézetben... 126 8.4. Új elem létrehozása a projektben... 128 8.5. Új osztály hozzáadása a projekthez... 128 8.6. Az új kódfájlban elhelyezett osztálydefiníció... 129 8.7. A stopper állapotátmenet diagramja... 131 8.8. Aprogram futtatás közben... 134 9.1. A Visual Studio 2010 új.netgadgeteer projekt... 135 9.2. az összekötött rendszer... 136 9.3. Teljesen kikapcsolt lámpa... 139 9.4. 7%-os kitöltésű lámpa... 140 vii

Beágyazott rendszerek a mérnöki gyakorlatban 9.5. Teljesen felkapcsolt lámpa... 141 10.1. A Visual Studio 2010 új.net Gadgeteer projekt... 144 10.2. az összekötött rendszer... 145 10.3. a kezdőképernyő... 147 10.4. a beolvasás folyamatábrája... 147 10.5. csak txt-re keresés... 150 10.6. minden fájlra keresés... 151 10.7. nincs találat... 152 viii

A táblázatok listája 2.1. A függvény igazságtáblázata:... 8 4.1. Egybemenetű multiplexer igazságtáblázata... 36 4.2. Kétbemenetű multiplexer igazságtáblázata... 37 4.3. Magnitude Comparator igazságtáblázata... 44 4.4. Magnitude Comparator egyszerűsített igazságtáblázata... 45 4.5. 8-ról 3-ra enkóder igazságtáblázata... 46 4.6. 4 bites prioritáskódoló igazságtáblázata, (4.1), (4.2), (4.3)... 47 4.7. 8 bites prioritáskódoló igazságtáblázata, (4.4), (4.5), (4.6), (4.7)... 48 4.8. 4-ről 1-re dekóder igazságtáblázata... 50 4.9. Portkiosztás... 51 4.10. A két bites félösszeadó igazságtáblázata, (4.8), (4.9)... 52 4.11. A két bites teljes összeadó igazságtáblázata, (4.10), (4.11)... 53 4.12. Az ALU kimeneti jelei a vezérlőjeleinek függvényében... 59 4.13. Portkiosztás... 62 4.14. Johnson számláló igazságtáblázata... 68 5.1. Az A és B regiszter bemenetének kiválasztása... 73 5.2. ALU vezérlő jelei... 75 5.3. Ugró utasítások... 78 5.4. Kimeneti regiszterek vezérlő jelei... 81 5.5. Kijelzők portkiosztása... 84 5.6. Portkiosztás... 87 5.7. Kimenet portkiosztása... 91 5.8. Portkiosztás... 93 5.9. Kijelzők portkiosztása... 97 5.10. Ugró utasítások... 99 5.11. Portkiosztás... 102 ix

Az egyenletek listája 4.1. (4.1)... 48 4.2. (4.2)... 48 4.3. (4.3)... 48 4.4. (4.4)... 48 4.5. (4.5)... 48 4.6. (4.6)... 48 4.7. (4.7)... 48 4.8. (4.8)... 52 4.9. (4.9)... 52 4.10. (4.10)... 53 4.11. (4.11)... 53 x

I. könyv. rész - Digitális technikai alapáramkörök labormérése

Tartalom 1. Bevezetés... 4 2. A mérés során használt eszközök... 5 2.1. Spartan 3 FPGA család... 5 2.1.2.1.1. Kapcsolómátrix... 6 2.1.2.1.2. Órajel... 6 2.1.2.1.3. Konfigurálható logikai blokk... 6 2.1.2.1.4. Lookup table (LUT)... 8 2.1.2.1.5. Erőforrások... 10 2.2. Digilent Basys 2 Spartan-3E FPGA Board... 11 3. Xilinx ISE fejlesztő rendszer... 14 3.1. Első mintafeladat elkészítése kapcsolási rajz alapú tervezés... 16 3.1.3.1.1. Kapcsolási rajz készítése... 19 3.1.3.1.2. A kapcsolás ellenőrzése szimulációval... 21 3.1.3.1.2.3.1.2.1. Szimulációs fájl készítése... 21 3.2. Makró hozzáadása meglévő projekthez... 26 3.2.3.2.1. Példa kapcsolási rajz alapú makró készítésére... 26 3.2.3.2.2. Kapcsolási rajz alapú saját makró módosítása... 28 3.2.3.2.3. Kapcsolási rajz alapú saját makró hozzáadása projekthez... 30 3.2.3.2.4. VHDL alapú saját makró hozzáadása projekthez... 30 3.3. Kapcsolási rajz elkészítése a makró használatával... 30 3.4. A kapcsolás hardveres ellenőrzése... 32 3.4.3.4.1. A konfigurációs fájl letöltése az FPGA-ba... 35 3.5. Az órajel bemenet prellmentesítése... 35 4. Egyszerű kombinációs hálózatok... 36 4.1. Multiplexer, demultiplexer... 36 4.1.4.1.1. Multiplexer... 36 4.1.4.1.1.4.1.1.1. 2 bemenetű multiplexer... 36 4.1.4.1.1.4.1.1.2. 4 bemenetű multiplexer... 37 4.1.4.1.2. Latch... 41 4.1.4.1.3. Korrekt flip-flop órajel engedélyezés... 41 4.1.4.1.4. Demultiplexer... 42 4.1.4.1.5. Laborfeladat... 43 4.1.4.1.5.4.1.5.1. Alkalmazandó műszerek és eszközök... 44 4.2. Kódolók... 44 4.2.4.2.1. Komparátorok (Magnitude Comparators)... 44 4.2.4.2.2. Enkóderek... 46 4.2.4.2.3. Prioritáskódoló (priority encoder)... 47 4.2.4.2.4. Dekóder... 50 4.2.4.2.4.4.2.4.1. 4-ről 1-re dekóder engedélyező jellel... 50 4.2.4.2.5. Laborfeladat... 51 4.2.4.2.5.4.2.5.1. Alkalmazandó műszerek és eszközök... 52 4.3. Összeadó áramkör... 52 4.3.4.3.1. Teljes összeadó (full adder)... 53 4.3.4.3.2. BCD összeadó... 56 4.3.4.3.3. Laborfeladat... 57 4.3.4.3.3.4.3.3.1. Alkalmazandó műszerek és eszközök... 57 4.4. Aritmetikai és Logikai Egység (ALU)... 57 4.4.4.4.1. ALU blokkvázlata... 58 4.4.4.4.2. ALU műveletvégző egységei... 58 4.4.4.4.3. Laborfeladat... 62 4.4.4.4.3.4.4.3.1. Alkalmazandó műszerek és eszközök... 64 4.5. Shift regiszter... 64 4.5.4.5.1. Léptető regiszterek... 64 4.5.4.5.1.4.5.1.1. Soros-párhuzamos átalakító... 64 4.5.4.5.1.4.5.1.2. Párhuzamos-soros átalakító... 65 4.5.4.5.1.4.5.1.3. Jobbra-balra léptető regiszter... 65 2

Digitális technikai alapáramkörök labormérése 4.5.4.5.1.4.5.1.4. Barrel shifter... 65 4.5.4.5.2. Egyéb alkalmazások shift-regiszterrel... 66 4.5.4.5.2.4.5.2.1. Lifo... 66 4.5.4.5.2.4.5.2.2. A Johnson számláló... 68 4.5.4.5.2.4.5.2.3. Soros összeadó... 68 4.5.4.5.3. Laborfeladat... 69 4.5.4.5.3.4.5.3.1. Alkalmazandó műszerek és eszközök... 69 5. Négybites CPU tervezés... 70 5.1. Bevezetés... 70 5.1.5.1.1. Számítógépes architektúrák... 70 5.1.5.1.2. Utasításkészlet... 71 5.1.5.1.3. A labormérés alatt megépítendő CPU architektúrája... 71 5.1.5.1.4. A CPU utasításainak felépítése... 72 5.1.5.1.4.5.1.4.1. Az A és B regiszter bemenetének kiválasztása (Register input select)... 73 5.1.5.1.4.5.1.4.2. ALU vezérlése (ALU control)... 75 5.1.5.1.4.5.1.4.3. Ugró utasítások, a programszámláló megváltoztatása (Branch control) 77 5.1.5.1.4.5.1.4.4. Egyéb vezérlő jelek... 80 5.1.5.1.4.5.1.4.5. Az utasítások felépítése... 82 5.1.5.1.4.5.1.4.6. Mnemonik... 82 5.1.5.1.4.5.1.4.7. A CPU teljes utasításkészlete... 82 5.1.5.1.5. Laborfeladat... 83 5.1.5.1.5.5.1.5.1. Alkalmazandó műszerek és eszközök... 83 5.2. Órajel forrás, programszámláló, utasításregiszter, kijelzés... 83 5.3. ALU és regiszterek... 90 5.4. Kimeneti regiszterek, memória, ugró utasítás... 97 5.5. Programkód írás... 106 3

1. fejezet - Bevezetés A könyv bevezetést kíván nyújtani a digitális áramkörök tervezésébe, célja a tervezési lehetőségek minél szélesebb körben való ismertetése. Manapság több módja is van az áramkörtervezésnek. A következőkben az FPGA alapú digitális áramkörtervezéshez szükséges ismeretekkel és eszközökkel ismerkedhetünk meg. Ismertetésre kerül a XILINX cég SPARTAN 3 FPGA családja és a hozzá kiadott fejlesztői környezet. Valamint egy Basys 2 nevű FPGA fejlesztői kártya, aminek segítségével a megszerzett tudás kipróbálására islehetőség nyílik. A tananyag végén egy összetettebb projekt keretén belül, négybites CPU tervezésére és szimulációjára kerül sor. 4

2. fejezet - A mérés során használt eszközök A következő részben az FPGA alapú tervezés alapjainak elsajátításához szükséges eszközök és szoftverek kerülnek ismertetésre. Természetesen a felsoroltak csak egy lehetőség, sok gyártó sokféle FPGA családot forgalmaz a különböző feladatok megoldására, valamint a tervezőszoftverekből is igen sokféle létezik. 2.1. Spartan 3 FPGA család A Xilinx cég a 90 nm-es technológiával készült Spartan-3 FPGA családot olcsó, közepes bonyolultságú digitális áramkörök megvalósítására tervezte. A felhasználó a családon belül rengeteg különböző méretű, tulajdonságú és tokozású eszköz közül választhat igényeinek és az adott alkalmazásnak megfelelően. A Spartan-3 család öt alapvető programozható funkcionális elemből épül fel (2.1. ábra): Konfigurálható logikai blokkok (CLB-k): Logikai függvények és tároló funkció megvalósítására alkalmas elem. Input/Output blokkok (IOB-k): A be- és kimenetek (a külvilág) valamint a belső logika elemek közötti adatáramlást valósítják meg. Lehetővé teszik a kétirányú és háromállapotú (tri-state) interfészek valamint különböző szabványú és feszültségszintű digitális jelek illesztését. Blokk RAM: Adattárolásra alkalmas memória elem. Szorzó blokk (Multiplier): Két 18-bites bináris szám gyors összeszorzására alkalmas egység. Digitális órajel menedzser blokk (DCM): Az órajelek kezelésére szolgáló programozható egység. Szolgáltatásai: késleltetés, frekvencia szorzás-osztás, fázistolás. 2.1. ábra - A Spartan-3 család belső felépítése [2] 5

A mérés során használt eszközök 2.1.2.1.1. Kapcsolómátrix Az FPGA-n belül egy sűrű vezetékhálózat biztosítja az egyes elemek közötti kapcsolatot. A funkcionális blokkok programozható összeköttetéseken (kapcsoló mátrix) keresztül kapcsolódnak a vezetékhálózathoz. Az FPGA programja (konfigurációja) tulajdonképpen a funkcionális blokkok vezérlőjeleit valamint a kapcsolómátrixok állapotát határozza meg, vagyis, hogy a belső vezetékhálózaton keresztül mely egységek kerüljenek egymással összeköttetésbe. A programot az FPGA-n belül statikus konfigurációs memória tárolja, amelyet a tápegység bekapcsolása után a kívánt logikai funkciónak megfelelő adattal fel kell tölteni. A feltöltés történhet külső PROM-ból, külső mikroprocesszoron keresztül, vagy JTAG interfészen keresztül. A konfigurációs adat előállítását, a konfigurációs memóriák feltöltését, valamint a JTAG interfészen történő programozást a gyártó saját Xilinx ISE programcsomagja támogatja. 2.1.2.1.2. Órajel Az órajelek FPGA-n belüli elosztásáért speciális belső vezetékhálózat felelős, amely a flip-flopok és egyéb órajeles működésű egységek órajel bemeneteihez kapcsolódik. Az órajel hálózathoz speciális bemeneti blokk (GCLK) és meghajtó-multiplexer (BUFGMUX) tartozik. A hálózatra kerülő órajelet a multiplexer választja ki a GCLK bemenetről vagy a DCM valamelyik kimenetéről (2.2. ábra). 2.2. ábra - Az órajel hálózat részei [1] Az FPGA-n belül megengedett, hogy egy flip-flop egy általános felhasználású bemenetről vagy belső vezetékről kapja az órajelét, a nagy-sebességű szinkron működés biztosítása érdekében azonban ez nem javasolt. 2.1.2.1.3. Konfigurálható logikai blokk A konfigurálható logikai blokkok (CLB-k) az elsődleges építő elemei az FPGA-ban felépített kombinációs vagy szinkron sorrendi hálózatoknak. A CLB-k egymással összeköttetésben lévő szeletekből (SLICE) épülnek fel (2.3. ábra). 2.3. ábra - A szeletek elhelyezkedése a CLB-ben [2] 6

A mérés során használt eszközök A szeletek, típustól függően logikai és memória funkciót (SLICEM) vagy csak logikai funkciót (SLICEL) láthatnak el (2.4. ábra). Mindkét szelet tartalmazza az alábbi összetevőket: Két 4-bemenetű LUT Két tároló elem Két multiplexer Carry és aritmetikai logika A SLICEM szeletek további összetevői: Két 16x1 bit RAM blokk két 16-bites shift-regiszter 2.4. ábra - A szeletek összetevői [2] 7

A mérés során használt eszközök 2.1.2.1.4. Lookup table (LUT) A számítógép (sőt számológép) előtti időkben a bonyolultabb függvényeket egy könyv alakban kinyomtatott táblázat segítségével számították ki, ahol a függvény értékei bizonyos felbontásban és pontossággal voltak megadva, és a táblázatban megadott értékek között lineáris interpolációval számoltak (logaritmustáblák, trigonometrikus függvények, stb.). A megfelelő értékek kikeresése sokkal gyorsabb volt, mint a függvény valamilyen képlettel történő közelítő kiszámítása. Természetesen, valakiknek előzőleg ki kellett számolni a táblázat értékeit, sokszor sok-sok éves munkával. A számítástechnikában a használata azon alapul, hogy egy előre feltöltött tárolóból rendszerint sokkal gyorsabban lehet az adatokat kiolvasni, mint azokat valamilyen algoritmussal kiszámolni. A fixpontos és lebegőpontos aritmetikákban is használnak LUT-ota kezdeti pontosságú érték előállítására, a végső pontosságot már számítással érik el. Az FPGA CLB blokkjában a LUT az adott logikai függvény értékeit tartalmazza, amit a fordítóprogram a logikai rajz alapján állít elő és tárol el benne. 4 bemeneti változó esetén az összes lehetséges logikai függvény száma 64K. A következő példa az alábbi háromváltozós logikai függvény Look-Up-Table lel történő megvalósítását láthatjuk. 2.1. táblázat - A függvény igazságtáblázata: ABCY 00000 10010 20101 30110 41001 51010 61101 71110 2.5. ábra - LUT 8

A mérés során használt eszközök 9

A mérés során használt eszközök 2.1.2.1.5. Erőforrások Az FPGA erőforrásai (CLB, IOB, DCM, RAM és a szorzó) közötti kapcsolatot a kapcsoló mátrixok biztosítják (2.6. ábra). A kapcsoló mátrixok a belső vezetékhálózatra kapcsolódnak, ami horizontálisan és vertikálisan az egész FPGA-t lefedi, így bizonyos megkötésekkel bármely elem bármelyik másikkal összeköttetésbe hozható (2.6. ábra, 2.7. ábra). 2.6. ábra - Kapcsoló mátrix összeköttetések [2] 2.7. ábra - A részegységek FPGA-n belüli tömbszerkezete [2] A Spartan-3 családról további információ a gyártó honlapján érhető el: http://www.xilinx.com/support/documentation/spartan-3.htm 10

A mérés során használt eszközök 2.2. Digilent Basys 2 Spartan-3E FPGA Board A mérés során a SPARTAN-3E típust tartalmazó demonstrációs panelt (Digilent Basys 2 Spartan-3E FPGA Board) fogjuk használni (2.8. ábra). A fejlesztőkártya paraméterei a következőek: Xilinx Spartan-3E FPGA, 100000 kapu 18-bites szorzók, 72Kbits dual-port block RAM USB 2 port az FPGA konfigurálásához (ingyenes Adept 2.0 szoftverrel) XCF02 Platform Flash ROM az FPGA konfiguráció tárolásához Programozható frekvenciájú oszcillátor (25, 50, and 100 MHz), egy további foglalat kvarc- oszcillátorhoz Stabilizált tápegységek (1.2V, 2.5V, and 3.3V) 8 LED, 4 db. hétszegmenses kijelző, 4 nyomógomb, 8 kapcsoló, PS/2 port, VGA port Felhasználói I/O csatlakozók 2.8. ábra - Digilent Basys 2 Spartan-3E FPGA panel [3] A panelt a hozzá tartozó USB kábel segítségével csatlakoztatjuk a PC-hez. Bár lehetőség van külső tápforrás bekötésére, a tápellátás és a programozás is az USB kábelen keresztül történik. A panel be- és kikapcsolása az SW8 jelű kapcsolóval végezhető. A programozásához szükséges (.bit kiterjesztésű) konfigurációs állományt amelyet a későbbiekben ismertetett Xilinx ISE fejlesztő rendszerrel állítunk elő a panel gyártója által ingyenesen hozzáférhető Adept segédprogram segítségével tölthetjük le közvetlenül az FPGA-ba, vagy a hozzá kapcsolódó külső konfigurációs PROM-ba (Platform Flash). A program kezelői felületét az alábbi ábrán látható (2.9. ábra). A közvetlenül az FPGA-ba töltött konfiguráció a tápfeszültség kikapcsolása után törlődik, a következő bekapcsolást követően az FPGA a Platform Flash-ben tárolt állomány szerint konfigurálódik fel automatikusan. A négy nyomógomb bemenet alapállapotban logikai 0 (L) szinten van. Logikai 1 szint (H) a gomb megnyomásával adható a bemenetekre. A nyolc kapcsoló konstans L vagy H szintet ad a hozzájuk tartozó bemenetekre. A nyolc LED a hozzájuk tartozó kimenetek logikai 1 szintje esetén világítanak (2.10. ábra). 2.9. ábra - Az Adept program konfigurációs felülete 11

A mérés során használt eszközök A négy hétszegmenses kijelző szegmensei és a tizedes pont multiplexált módban vezérelhetők. A CA, CB, CC, CD, CE, CF, CG és DP jelekkel a szegmenseket és a tizedes pontot kapcsolhatjuk ki/be. Az AN0, AN1, AN2 és AN3 jelekkel választhatjuk ki, hogy a négy kijelző közül melyikre vonatkoznak a szegmenseket vezérlő jelek. A vezérlő és kiválasztó jelek megfelelően gyors egymás utáni kapcsolgatásával négydigites számokat jelezhetünk ki. 2.10. ábra - Kapcsolók, nyomógombok és hétszegmenses kijelzők [3] 12

A mérés során használt eszközök 13

3. fejezet - Xilinx ISE fejlesztő rendszer A Xilinx ISE WebPack (Integrated Software Environment integrált szoftverkörnyezet) a Xilinx cég FPGAihoz és CPLD-ihez kifejlesztett ingyenes szoftvere, amely az internetről, a cég weboldaláról szabadon letölthető. A fejlesztőrendszer tartalmazza mindazon elemeket, amelyek kapcsolási rajz alapú és hardverleíró nyelv alapú fejlesztéshez szükségesek. A mérési segédlet bevezetést kíván nyújtani az áramkörök tervezésébe, célja a tervezési lehetőségek minél szélesebb körben való ismertetése. Elmélyülésre a korlátozott laboridő miatt saját munkával, illetve a konzultációk alatt van lehetőség. A mérések sikeres elvégzését nagymértékben segíti a mérést előkészítő előadás anyagának elsajátítása. Az ISE tervező rendszer alrendszereinek, részeinek működését a Project Navigator szoftver, az ISE keretprogramja fogja össze (3.1. ábra). 3.1. ábra - A tervezés menete [1] 14

Xilinx ISE fejlesztő rendszer A tervező az elképzeléseit, terveit: beviheti kapcsolási rajz (Schematic) formájában, a kapcsolási rajz készítő és beviteli program segítségével. beviheti hardver leíró nyelven. Ezt a HDL editor rész támogatja. A támogatott nyelvek: Verilog és VHDL. A rendszer sok mintaleírást is tartalmaz, úgynevezett sablonok (template) formájában. A bevitel utáni az ellenőrzéssel megbizonyosodunk arról, hogy a terv szerinti áramkör működése megfelel-e a feladat specifikációjának. Az ellenőrzés általában szimulációval történik. A WebPACK rendszer szimulátora a 15

Xilinx ISE fejlesztő rendszer Xilinx ISE Simulator. A szimulációs vizsgálathoz a modellt működtetni, gerjeszteni kell, azaz a modell bemeneteire megfelelően változó jeleket kell adni. Ez az úgynevezett tesztvektorok sorozatának ráadásával történik. A tesztvektorokat a tervező HDL leírással adhatja meg (testbench). A régebbi ISE verziókban rendelkezésre álló grafikus felület az újabb verziókban már nem érhető el. Ha a tervet rendben találtuk, akkor következhet a szintézis, amit jelen esetben a Xilinx Synthesis Technology (XST) alrendszer végez, amely ugyancsak az ISE része. A szintézer a HDL leírásból előállít egy minimalizált és optimalizált huzalozási listát, amely az adott FPGA primitíveket (LUT, FF ) és a köztük levő kapcsolatokat tartalmazza. Ezt követik a Translate, a Map és a Place&Route fázisok (összefoglalva: implementáció). A Translate a huzalozási listákból és a felhasználói megkötésekből (constraint-ek) generál egy fájlt, a Map leképezi ezt az adott FPGA primitívkészletére, végül a Place&Route elhelyezi a primitíveket az eszközben és kialakítja a köztük levő fizikai huzalozást. A programozói fájl előállítását követő programozást normál esetben ( égetés ) az IMPACT alrendszer vezérli. A mérések során használt demonstrációs panelhez a panel gyártója saját programozói felületet biztosít. 3.1. Első mintafeladat elkészítése kapcsolási rajz alapú tervezés A Xilinx ISE WebPack segítségével hozzunk létre egy egyszerű példaprogramot a gyakorlópanelen található LED-ek, kapcsolók és nyomógombok tesztelésére! A program ikonjára kattintva, vagy a Start menüből indítsuk el a Xilinx ISE Design Suite ISE Design Tools 32-bit Project Navigator-t. A mintapélda projekt létrehozásához a File menüben válasszuk a New Project parancsot, és töltsük ki a párbeszédablakot az alábbi módon (3.2. ábra). Az ISE fejlesztő környezetben kerülni kell a fájlnevekben és a könyvtárszerkezetben a különleges karaktereket (ékezet, szóköz, vessző, pont, stb). A fájlok, könyvtárak lenevezésekor csak az angol ABC betüit használjuk! A Project Name legyen proba. A rendszer automatikusan létrehoz egy ilyen nevű mappát a Project Location mezőben megadott elérési útnak megfelelően. Az ISE a projekthez tartozó állományokat ebbe a mappába fogja menteni. Top-Level Module Type mezőben a legördülő ablakból válasszuk a Schematic-ot. A Next gombra kattintás után megjelenik a New Project Wizard, a Project Settings táblába írhatunk be paramétereket, válasszuk a próbapanelhez tartozó alábbi értékeket: Family: Spartan3E Device: XC3S100E Package: CP132 Speed : -4 Synthesis Tool: XST (VHDL/Verilog) Simulator: ISim (VHDL/Verilog) 3.2. ábra - Új projekt létrehozása 16

Xilinx ISE fejlesztő rendszer 3.3. ábra - Új projekt létrehozása 17

Xilinx ISE fejlesztő rendszer A többi paramétert most nem kell változtatnunk. A Next gombra kattintva megjelennek a készülő projekt adatai. A Finish gombra kattintva elkészül a még üres próba projekt. Új modul létrehozásához a Project menüben kattintsunk a New Source parancsra, és válasszuk a Schematic típusú forrást. A létrehozandó modul neve legyen teszt, amit a File name ablakba kell beírni, és jelöljük ki az Add to Project opciót. A Next majd Finish gombra kattintás után egy üres kapcsolási rajz szerkesztő jelenik meg, amiben elkészíthetjük a próbaalkalmazást. A View menüpont Panel alpontjában kijelölhetjük, hogy a szerkesztő ablakban mely segédablakok jelenjenek meg. Egyelőre hagyjuk meg az alapértelmezés szerinti beállításokat. A jobb oldalon a rajzlap, a bal oldalon a Select Options jelenik meg. Itt a rajzolással kapcsolatos néhány paramétert állíthatunk be. Általában a képernyő az alábbi részekre van osztva (3.3. ábra, 3.4. ábra). Alul a Consol látható, ahol a parancsok szöveges formában jelennek meg. 3.4. ábra - A Project Navigator részei 18

Xilinx ISE fejlesztő rendszer 3.1.3.1.1. Kapcsolási rajz készítése A tesztalkalmazásban egy T-tárolókból felépített 4-bites bináris számláló kapcsolást valósítunk meg. A számláló kimeneti bitjei a panelen található LED-eket hajtják meg, így ellenőrizhető a kapcsolás működése. A számlálót a Basys 2 FPGA fejlesztő kártyán található SW0 kapcsolóval engedélyezzük, a BTN0 nyomógombbal pedig nullázhatjuk. A segédablakok közül válasszuk a Symbols fület, ennek segítségével helyezhetjük el a kapcsolási rajzban használt alkatrészeket (3.5. ábra), felül a kategória, alatta a hozzátartozó egyik elem kiválasztásával: FTCE: Engedélyezhető T-flip-flop (4 db, a négybites számlálóhoz) AND3, AND2: három, ill. két bemenetű ÉS kapuk (a bemeneti kombinációs hálózathoz) PULLUP: Pozitív tápfeszültség (logikai magas jelszint (H)) PULLDOWN: Földpont (logikai alacsony jelszint (L)) CONSTANT: Jelnek vagy busznak konstans értékadás. IBUF: Egybites bemeneti buffer (több bites változatai: IBUF4, IBUF8, IBUF16) OBUF: Egybites kimeneti buffer (több bites változatai: OBUF4, OBUF8, OBUF16) Az alkatrészek megkeresése történhet kategóriák (Categories) alapján, de használhatjuk a névkeresőt is (Symbol Name Filter). Az alkatrészek forgatását az Orientation mezőben állíthatjuk be. 3.5. ábra - A Symbols segédablak és a használt alkatrészek 19

Xilinx ISE fejlesztő rendszer Az alkatrészek huzalozásakor a következő parancsokat, ill. parancsikonokat fogjuk használni: Select ( ): Kiválasztás/mozgatás. Add Wire ( ): Vezeték hozzáadása. Add Net Name ( ): Vezetékezés elnevezése. Rename Selected Bus ( ): A kijelölt busz átnevezése. 20

Xilinx ISE fejlesztő rendszer Add Bus Tap ( ): Buszos vonalra csatlakozás hozzáadása. Add I/O Marker ( ): Be-, kimeneti pontok hozzáadása. Add Symbol ( ): Szimbólum (alkatrész, könyvtári, vagy saját) hozzáadása. Mindegyik művelethez a bal alsó ablakban (Process/Options) találunk beállítási lehetőségeket, illetve műveleteket. A kényelmesebb szerkesztés érdekében megnövelhetjük a lap méretét is. Ezt a rajz területen jobb kattintásra felugró Object Properties parancs kiválasztásával tehetjük meg. A megjelenő ablakban a Sheets sort kiválasztva módosíthatjuk a lap méretét (Size). Vezeték vagy busz elnevezéséhez válasszuk az Add Net Name parancsot majd a bal alsó ablakban az Options fülnél a Name sorba írjuk a nevet. Ezután kattintsunk az elnevezni kívánt vezetékre. A vezetékek neveire a kapcsolási rajz átláthatósága érdekében is hivatkozhatunk, ugyanis ha két vagy több vezetéket ugyan úgy nevezünk el, az olyan, mintha fizikailag összehuzaloztuk volna őket (lásd az és kapuk bemeneteit és a tárolók kimeneteit). A tárolók q(0), q(1), q(2) és q(3) kimenetei a speciális q(7:0) un. buszvezetékre csatlakoznak (buszvezetékeket a kapcsolási rajzokban az összetartozó vezetékek ábrázolása érdekében használunk). A buszok, illetve leágazásaik elnevezése utal arra, hogy adott buszon belül melyik vonalra (bitre) csatlakozunk. Az előző példa (3.5.ábra) kapcsolásán a q(7:0) jel egy 8 bites busz, melyre az adott helyértékű bitvezeték (q(0) q(7)) buszcsatlakozáson (Bus Tap) keresztül kapcsolódik. A kapcsolódás be- és kimeneti jelei I/O buffer-eken keresztül kapcsolódnak a külvilágot reprezentáló I/O Markerekhez. A CLK, ENABLE, és CLEAR bemenetekre IBUF, a LED(7:0) kimenetekre pedig OBUF (itt egy 8 bites OBUF8) elemeket helyezünk el, ez a szabályos megoldás. Az automatikus buffer-elhelyezés miatt a kapcsolás ezek nélkül is implementálható, de a be- és kimenetek nincsenek optimálisan bufferelve. Az IBUF és OBUF elemekkel számos beállítás mellett pl. a logikai családhoz, illetve a logikai szintekhez való illesztés valósítható meg. A rajz ellenőrzése az alsó Processes területen kibontva a Design Utilities-t, a Check Design Rules-ra kattintva fut le, ami ha jó, egy zöld pipa jelenik meg mellette. Ugyanezt tehetjük meg a Tools > Check Schematic paranccsal. 3.1.3.1.2. A kapcsolás ellenőrzése szimulációval Teszteljük le a kapcsolás működését szimulációval! Ehhez létre kell hoznunk egy ellenőrzési környezetet (testbench, tesztelési környezet) melyben az egységet működtető gerjesztő jeleket és jelformákat definiáljuk. Régebbi ISE verziókban lehetőség volt a gerjesztő-jelek grafikus felületen történő megadására, az újabb verziókból azonban kikerült ez a funkció, így az egyetlen lehetőség a HDL nyelvű leírás. A gyakorlatokon nem cél a HDL nyelvek ismertetése, ezért a tesztkörnyezetet leíró forrást nem kell elkészíteni, a kész forrásokat csak a projekthez kell adni. 3.1.3.1.2.3.1.2.1. Szimulációs fájl készítése Az elkészült projekthez szimulációs fájlt a Design/Simulation ablakban, az Add New Source opcióval lehet hozzáadni (3.6. ábra). Fontos hogy minden port nevet adjunk meg a kapcsolási rajzon a szimulációs fájl elkészítése előtt, mert a program az aktuális port neveket használja fel a sablon elkészítésére. 3.6. ábra - Szimulációs fájl hozzáadása a projekthez 21

Xilinx ISE fejlesztő rendszer Ezután a VHDL Test Bench opciót válasszuk és adjuk meg a tesztfájl nevét (teszt_tb). A Next gomb lenyomása után a program megkérdezi melyik forrásfájlhoz készül a tesztfájl. Itt válasszuk a fő kapcsolási rajzot (példánkban: teszt.sch), majd válasszuka Next gombot, végül kattintsunk a Finish gombra. Az ISE által generált sablon fájl tartalmazza a ki- és bemeneti portokat és a VHDL fájl keretét. Ha mindent jól csináltunk a következő VHDL fájlt kapjuk eredményül: vhd-1. ábra -../section/src/codetestbrench1.vhd 22

Xilinx ISE fejlesztő rendszer A vizsgálójelek előállításához az alapértelmezett tesztfájlt módosítani kell. Az első kiegészítéssel adjuk hozzá a szimulációhoz a számlálót működtető 1MHz-es órajelet (CLK). A kódba a constantclk_period : time :=1us; sor beszúrásával definiálásra kerül az órajel periódusideje és a clk_process : processbegin. end process-el az órajel előállításra kerül. Amennyiben nem CLK az órajel port neve, módosítani kell az általunk használt névre. A fenti kiegészítéseket elvégezve, a szimuláció során a CLK bemeneti porton egy 1 us periódusidejű órajel jelenik meg. vhd-2. ábra -../sections/src/codetestbrench2.vhd 23

Xilinx ISE fejlesztő rendszer A jeleknek értéket a "<=" értékadó utasítással lehet adni (példa: ENABLE<= 1 ). Buszvezetékeknél értékadás binárisan történik (példa egy négybites busz értékadására: INB<="1011"). A jelek beállítása után a wait for paranccsal adhatjuk meg mennyi ideig maradjanak meg a beállított értékek. Lehetőség van kész VHDL testbench-et hozzáadni a projekthez. A "valami_tb.vhd" fájlt ami tartalmazza a szimulációs környezetet, célszerű a projekt könyvtárába másolni, majd a Project menü Add Source parancsával adhatjuk hozzá a projekthez. A megjelenő Adding Source Files ablakban az Association alatt a Simulation kell, hogy legyen. A szimuláció elindítása a korábban ismertetett módon történik. A szimuláció elindításához a Design segédablakban jelöljük be a Simulation rádiógombot, majd jelöljük ki a megjelenő "teszt_tb.vhd" fájlt. Kibontva a Isim Simulatort az alsó segédablakban, megjelenik a Simulate Behavioral Model parancs, amivel elindíthatjuk az ISE szimulátorát. A szimuláció lépéseit alul, a Console területen láthatjuk. A szimuláció során a CLK órajel, az ENABLE és a CLEAR vezérlő jelek a VHDL forrásban megadottak szerint változnak. A szimuláció eredménye egy új ablakban fog megjelenni (3.7. ábra, a képen látható eredmény a Zoom to Full View ikonra kattintás után látható). A Zoom In, Zoom Out, Zoom to Full View ikonokkal (3.7. ábra, piros téglalappal jelölt 24

Xilinx ISE fejlesztő rendszer rész) tudjuk a megjelenített időtartományt módosítani. A Restart ikon újraindítja a szimulátort, törli a megjelenített idődiagramot, Run for the time specified on toolbar ikon lenyomásakor a szimuláció a beállított időegységnyit lép előre. 3.7. ábra - A szimuláció eredménye a Xilinx ISE Simulator hullámforma ablakában. Az egyes jelnevekre a jobb gombbal kattintva lehetőség van a kijelzés formátumát megváltoztatni. A led[7:0] kimenet esetén ezt (jobb gomb, Radix / Hexadecimal) hexadecimálisra állítva máris könnyebben ellenőrizhető a helyes működés. 3.8. ábra - Kijelzés formátuma Sokszor nagyon hasznos a modulok belső jeleit vizsgálni, ennek elvégzéséhez nem szükséges ezeket a jeleket kivezetni a modulból, a szimulátorban egyszerűen hozzáadhatjuk őket a Wave ablakhoz. A szimuláció a View>Panels> Instance and Process Name bal oldali ablakában megjelenik a szimulációs hierarchia, amelyben megtalálható (UUT unit under test néven) a tesztelés alatt álló kapcsolási rajz modul. A View>Panels>Objects ablakban látjuk a modul összes jelét, melyek közül a vizsgálni kívánt jel egyszerű dragand-drop módszerrel adható hozzá a Wave ablakhoz (3.9. ábra). Ezután már csak a szimuláció újraindítására van szükség ahhoz, hogy a jelek értékeit figyelemmel tudjuk követni (Kék, enter-szerű gomb a felső menüben, majd 25

Xilinx ISE fejlesztő rendszer a homokórás play-szerű gomb, amelyet nyomkodva, a mellette beállított értéknek megfelelő időt haladunk a szimulációban). 3.9. ábra - További jelek hozzáadása Lehetőség van a szimulációs beállítások mentésére, ezt a File>Save paranccsal tehetjük meg. Az elmentett *.wcfg fájlt a szimulátorban megnyitva, visszaállítható a korábbi konfiguráció. A szimulátor bezárásakor, ha nincs elmentve a szimulátor konfigurációja, a program megkérdezi, hogy szeretnénk e menteni a beállításokat. 3.2. Makró hozzáadása meglévő projekthez Minden az ISE kapcsolási rajz szerkesztőjében használt makróhoz két fájl tartozik. Az egyik egy szimbólumfájl (*.sym), ami leírja a makró kapcsolási rajzon való megjelenését. A másik a működést leíró fájl, ami lehet kapcsolási rajz (*.sch), vagy HDL (*.vhd) alapú. Ha makrót akarunk a rajzból készíteni későbbi felhasználásra, akkor a portok be- és kimenetekre történő hozzáadása után, a Design ablak alsó Processes részén kibontva a Design Utilities menü-pontot rá kell kattintanunk a Create Schematic Symbol-ra. Az eddigi rajz neve alatt egy új elem jelenik meg, amit egy másik rajzra le is tehetünk. Ha rögtön makrót akarunk készíteni, akkor más az eljárás. A Project Navigator-ban, kiválasztva a Project > New Source menüpontot, megjelenik a New Source Wizard ablak. A forrás típusaként kiválasztjuk a rajzot (Schematic), megadjuk a fájl nevét és helyét majd a Next és Finish megnyomása után hozzáadódik a projekthez és megnyílik az adott nevű üres rajz. Ezután i/o portokat kell a rajzhoz hozzáadnunk a Tools > Create I/O Markers segítségével. A megjelenő dialógus dobozba be kell írni sorban, vesszővel elválasztva, az összes bemeneti, kimeneti és esetleg kétirányú port nevét. Az üres rajzon megjelennek a portok, ezután hozzárajzoljuk a makró többi részét. Ha kész, el kell mentenünk. 3.2.3.2.1. Példa kapcsolási rajz alapú makró készítésére A következő példa során a korábbi négybites számlálót felhasználva készítjük el a makrónkat, így később lehetőség nyílik rá, hogy a számlálót önálló szimbólumként kezeljük. A 3.10. ábra szerint módosítsuk az előző feladatban szereplő számlálót. A korábbi kapcsolási rajzhoz képest csak a kimeneti busz szélessége változott, valamint a ki és bemeneti portokon csak IO markerek találhatóak. Az IO markereket a "ADD" I/O Marker" nevű gombbal lehet hozzáadni. IBUF-ra és OBUF-ra csak olyan portok esetén van szükség ami a külvilággal tart kapcsolatot. Az I/O markerekhez kapcsolódó vezeték neve lesz az IO marker neve és ez lesz a makró ki- és bemeneti portjának a nev is. A kapcsolási rajzot kijelölve, megjelenik a "Create Schematic Symbol" opció (3.10. ábra). Ezt a processt futtatva elkészül a makró (létrejön egy sym kiterjesztésű fájl a kapcsolási rajz mellett). 3.10. ábra - Kapcsolási rajz módosítása 26

Xilinx ISE fejlesztő rendszer A fejlesztő környezet parancssorában a makró sikeres elkészítését a következő üzenet jelzi: "Process completed successfully". A szimbólumok között ezután már megtalálható a makró szimbólum (3.11. ábra). 3.11. ábra - Elkészült makró kiválasztása A makró tartalmát a "View" menü "Push into Symbol" gombjával lehet megtekinteni. Előtte szükséges kijelölni a makrót, a kapcsolási rajzon! A korábbi teszt.sch fájl most szimbólum fájlként létezik, így szükséges egy új kapcsolási rajz fájl hozzáadása a projekthez, aminek adjuk a teszt_macro.sch nevet (3.12. ábra). Az új kapcsolási rajz file jelenleg nem "Top Modul", ezért módosítsuk a teszt_macro.sch fájl beállításait top modul szintűre (3.12. ábra). 3.12. ábra - Top modul 27

Xilinx ISE fejlesztő rendszer 3.2.3.2.2. Kapcsolási rajz alapú saját makró módosítása Ha a változtatás nem érinti a makró ki- és bemeneti portjait, akkor a "Push into Symbol" paranccsal megnyitva lehetőség van a makró módosítására. A változásokat minden esetben el kell menteni. Amennyiben a változás a makró megjelenésére is kihat, például új portot kell hozzáadni, törölni, vagy port nevet kell változtatni, akkor a következőképpen kell eljárni. Első lépésként meg kell nyitni a makrót tartalmazó sch fájlt. Ezt a "Push into Symbol" paranccsal, vagy a "Design" ablakban a kapcsolási rajzra kétszer kattintva lehet megtenni. Végezzük el a változtatásokat a makró fájlon. A példában a régi rajzot egészítsük ki egy új kimenettel, ami a számláló 15-ös értékét jelzi (3.13. ábra). 3.13. ábra - Kimenet 28

Xilinx ISE fejlesztő rendszer A módosítások mentése után a teszt.sch kapcsolási rajz fájlt kijelölve, a "Create Schemetic Symbol" parancs-ra jobb gombbal kattintva a "Process Properties..." opciót kiválasztva engedélyezni kell a létező szimbólumfájl felülírását, úgy hogy az "Owerwrite Existing Symbol" jelölő négyzetet bepipáljuk. A "Run" parancs futtatásával módosul a makró megjelenését leíró szimbólum fájl. Ha valamelyik kapcsolási rajzban használunk egy ilyen makrót, amit módosítottunk, majd a makró megjelenésére kiható változtattatást hajtunk végre, a kapcsolási rajz szerkesztőben "Obsolate Symbols" ablak jelenik meg. Az "Update" paranccsal frissíthetjük a kijelölt objektumra vonatkozó módosításokat (3.14. ábra). 3.14. ábra - Kapcsolási rajz alapú makró módosítása Ha a makró újrafordítása után nem kínálja fel a program a makró szimbólum frissítését, és a kapcsolási rajzon nem is változik meg a makró megjelenése, akkor újra kell indítani az ISE fejlesztőkörnyezetet (előtte mindent mentsünk el!). Az újraindulás után már a módosított szimbólumnak kell megjelennie (3.15. ábra). 3.15. ábra - Módosított szimbólumfájl 29

Xilinx ISE fejlesztő rendszer A szimbólumfájl külső megjelenésén is lehetőség van módosítani. A kapcsolási rajzon elhelyezett teszt nevű makró fájlra jobb gombbal kattintva válasszuk a Symbol->Edit Symbol opciót (3.16. ábra). 3.16. ábra - Makró szerkesztés 3.2.3.2.3. Kapcsolási rajz alapú saját makró hozzáadása projekthez Másoljuk át a makró fájlokat a projektkönyvtárba. A makró megjelenését és működését egy azonos nevű *.sym és egy *.sch kiterjesztésű fájl írja le. A *.sch fájlt az Add Source paranccsal a projekthez kell adni. Mivel korábban átmásoltuk a projektkönyvtárunkban kell lennie. Fontos, hogy a fájlok másolása után hajtsuk végre ezt a lépés. Végül a szimbólumok között megjelenik az új makró. Lehetőség van a projekthez hozzáadott makró tartalmának megtekintésére. A makró szimbólum kijelölése után a View menü Push into Symbol gombjára kattintva megjelenik a működést leíró fájl. 3.2.3.2.4. VHDL alapú saját makró hozzáadása projekthez Másoljuk át a makró fájlokat a projektkönyvtárba. A makró megjelenését és működését egy azonos nevű *.sym és egy *.vhd kiterjesztésű fájl írja le. A *.vhd fájlt az Add Source paranccsal a projekthez kell adni. Mivel korábban átmásoltuk a projektkönyvtárunkban kell lennie. Fontos, hogy a fájlok másolása után hajtsuk végre ezt a lépés, mert az ISE ellenkező esetben a *.vhd fájlt felülírhatja egy template fájllal. Végül a szimbólumok között megjelenik az új makró. Lehetőség van a projekthez hozzáadott makró tartalmának megtekintésére. A makró szimbólum kijelölése után a View menü Push into Symbol gombjára kattintva megjelenik a működést leíró fájl. 3.3. Kapcsolási rajz elkészítése a makró használatával 30

Xilinx ISE fejlesztő rendszer Készítsünk egy új kapcsolási rajzot "teszt_macro.sch" néven. A 3.17. ábra szerint készítsük el a kapcsolási rajzot. Felhasználva a négybites számláló makrót, készíthetünk 8 bites számlálót. Figyeljünk rá, hogy a "teszt_macro.sch" rajz legyen a topmodul (3.18. ábra). 3.17. ábra - 8 bites számláló kapcsolási rajza Az áramkör szimulációját hasonló képen végezzük el, mint a 4 bites számláló esetében. A tesztfájl elkészítése után a következő VHDL kódot használjuk fel. 3.18. ábra - 8 bites számláló fájlok vhd-3. ábra -../sections/src/codetestbrench3.vhd 31

Xilinx ISE fejlesztő rendszer A szimuláció lefuttatása után a 3.19. ábra szerinti eredményt kell kapnunk. 3.19. ábra - 8 bites számláló szimulációs eredmény 3.4. A kapcsolás hardveres ellenőrzése 32

Xilinx ISE fejlesztő rendszer Jelöljük be az Implementation rádiógombot a Design panelen. A Project menü Add Source parancsával adjuk hozzá a projekthez a laborok során használt Basys2 fejlesztőpanel alapértelmezett lábkiosztását és a felhasználói megkötéseket (constraint-ek) tartalmazó Basys2_100_250General.ucf fájlt. A Megnyitás és OK gombok megnyomása után a projektben megjelenik a kiválasztott fájl, amit kettős kattintással szerkesztésre meg is nyithatunk (3.20. ábra). A fájl egyéb itt nem részletezett felhasználói megkötések mellett a kapcsolási rajzban használt vezetékek neveit (NET) és a hozzájuk tartozó FPGA IC kivezetések (lábak) összerendeléseit definiálja. 3.20. ábra - A Basys2_100_250General.ucf fájl A "Basys2_100_250General.ucf" fájl az FPGA összes panelen bekötött kivezetéséhez alapértelmezett belső vezetékneveket rendel. Az alapértelmezett elnevezések segítenek a panelen való tájékozódásnál, azonban nincsenek összhangban a kapcsolási rajzban általunk használt I/O Marker nevekkel, emellett legtöbbjüket nem is használjuk (3.21. ábra). vhd-4. ábra -../sections/src/codeucfclk4bit.vhd 33

Xilinx ISE fejlesztő rendszer A helyes működéshez, módosítsuk az alapértelmezett ucf fájlt az alábbiak szerint. 3.21. ábra - UCF Ezzel a kapcsolási rajzunk Led(7:0) kimeneteit a panelen található LED-ekhez, az ENABLE bemenetet az SW0 kapcsolóhoz a CLK és CLEAR bemeneteket pedig a BTN1 és BTN0 nyomógombokhoz rendeltük (a buszvezetékek elnevezésében szereplő zárójelek az.ucf-fájlban <> karakterekkel helyettesítendők). Az összes többi nem használt vezetékek definíciót tartalmazó sorokat a # karakterrel alakítsuk megjegyzéssé (comment), vagy töröljük. Mentsük el a változtatásokat. A kapcsolás implementálásához és az FPGA konfigurációs állományának előállításához a Design segédablakban jelöljük ki a teszt.sch kapcsolási rajzot. Ennek hatására a Processes ablakban az Implement Design kibontásakor megjelenik a Generate Programming File parancs, amelynek feladata, hogy létrehozza az FPGA-ba letölthető teszt.bit állományt. Ez általában elég sokáig tart, a művelet lépéseit a Console területen követhetjük. Először a parancs futtatásának eredménye hibaüzenet, amit az Errors ablakban tekinthetünk meg. Mivel a kapcsolásban a tárolók órajele nem dedikált órajel vezetéken keresztül kerül az FPGA-ba, a program figyelmeztet. Mivel esetünkben ez a nem optimális vezetékezés elfogadható, az ucf-fájlban el kell helyeznünk a NET "CLK" CLOCK_DEDICATED_ROUTE = FALSE; kiegészítést. Az újabb Generate Programming File parancs futtatásakor a fenti hibajelzés már csak a Warnings ablakban jelenik meg. Az elkészült konfigurációs állományt ( teszt.bit ) a korábban ismertetett Adept program segítségével letölthetjük az FPGA-ba. 34

Xilinx ISE fejlesztő rendszer 3.4.3.4.1. A konfigurációs fájl letöltése az FPGA-ba Először telepíteni kell az Adept kezelő programot (jelenleg digilent.adept.system_v2.8.1.exe), ezt még azelőtt kell megtenni, mielőtt a tesztkártyát az PC-hez csatlakoztatnánk. Csatlakoztatáskor a Windows észreveszi az új hardvert, engedélyezni kell a driver telepítését. Az Adept indulásakor észreveszi, hogy melyik eszköz van csatlakoztatva. A Config fül kiválasztásával Browse-ra kattintva kikeressük az adott bit kiterjesztésű fájlunkat és bevisszük az FPGA melletti edit box-ba. A Program gombra kattintva megtörténik a letöltés, és a kártyán azt látjuk, ami sikerült. 3.5. Az órajel bemenet prellmentesítése A prellezés (a mechanikusan működő villamos érintkezők egymáson való pattogása) miatt az órajelet szolgáltató BTN1 nyomógomb nem mindig ad rögtön stabil jelet. Rövid ideig egyszeri lenyomás hatására is két állapot között pereg, ezzel többszöri 0 -> 1 átmenetet adhat a tárolók órajel bemenetére. Ennek a jelenségnek a kiküszöbölésére módosítsuk a kapcsolást a 3.22. ábra szerint, az ucf-fájlt pedig az alábbiak szerint. vhd-5. ábra -../sections/src/codeucfclkprell.vhd Az aszinkron törlés és beállítás (CLR, PRE) bemenetekkel rendelkező FDCP flip-flop az UP bemenetre csatlakozó BTN3 nyomógomb megnyomásával (preset) logikai 1 szintre vált, a DOWN bemenetre csatlakozó BTN2 nyomógomb megnyomásával (clear) pedig logikai 0 szintre vált. Egy teljes órajel periódust (felfutó él - lefutó él) a BTN3 és BTN2 nyomógombok egymás utáni lenyomásával hozhatunk létre. 3.22. ábra - A teszt.sch kapcsolási rajz módosítása 35

4. fejezet - Egyszerű kombinációs hálózatok 4.1. Multiplexer, demultiplexer 4.1.4.1.1. Multiplexer A multiplexer egy olyan áramkör, amely több bemenet közül egyet enged tovább a kimenetén, méghozzá azt a bemenetet, amelynek a címe rákerül a címző bemenetre. Ez a leggyakrabban használt kombinációs hálózat. 4.1.4.1.1.4.1.1.1. 2 bemenetű multiplexer Legegyszerűbb esetben a cím egybites select jel (S), ami két bemenet közül (I0, I1) választ ki egyet (4.1. ábra, 4.2. ábra). A két bemenetű multiplexer igazságtáblája a következő: 4.1. táblázat - Egybemenetű multiplexer igazságtáblázata SY 0I 0 1I 1 4.1. ábra - Két bemenetű multiplexer kapcsolási rajza 4.2. ábra - Két bemenetű multiplexer logikai rajza 36

Egyszerű kombinációs hálózatok A multiplexert legtöbbször bonyolult adatutak kialakítására használják pl. a processzorok ALU-jában. Vannak egyéb alkalmazási, ezek közül először kettőt mutatunk meg. 4.1.4.1.1.4.1.1.2. 4 bemenetű multiplexer A multiplexer címbitjeinek eggyel való megnövelése a bemenetek számának a kétszeresét teszi lehetővé. Így két címbit esetén kapjuk a 4-bemenetű multiplexert (4.3. ábra, 4.4. ábra). A négy bemenetű multiplexer igazságtáblája a következő: 4.2. táblázat - Kétbemenetű multiplexer igazságtáblázata SSY 10 00I 0 01I 1 10I 2 11I 3 4.3. ábra - Négy bemenetű multiplexer logikai rajza 37

Egyszerű kombinációs hálózatok 4.4. ábra - Négy bemenetű multiplexer kapcsolási rajza 38

Egyszerű kombinációs hálózatok A nagyobb számú bemenetekkel rendelkező multiplexer tervezése kétféleképpen lehetséges: a megfelelő számú kapuból megtervezve, vagy kisebb multiplexerek felhasználásával. Például egy 16 bemenetű multiplexert így is megtervezhetünk. Ez ugyan redundáns a felhasznált kapuk számát illetően, de lehet, hogy az alkatrészkészlet ezt a megoldást teszi alkalmasabbá (4.5. ábra). 4.5. ábra - 16 bemenetű multiplexer tervezése kisebb multiplexerek felhasználásával 39

Egyszerű kombinációs hálózatok A multiplexer lehetőséget nyújt look-up table megvalósítására (4.6. ábra). Az általunk használt FPGA CLBjében 4-bemenetű LUT található tetszőleges 4-változós logikai függvény előállítására. Ha ezt egy tárolóval oldanák meg, minden egyesclb-ben egy 64K bites tárolóra lenne szükség az összes logikai függvény előállítására. Ehelyett pl. egy 16 bites regiszter és egy 16 bemenetű multiplexer elegendő. A multiplexer címbitjeire csatlakozik az adott logikai függvény 4 változója. A rajz alapján a szoftver kiszámolja, hogy melyik logikai függvény kell a megvalósításhoz, és a 4 bemenet összes kombinációjának megfelelő 16 kimeneti bitet betölti egy 16 bites regiszterbe, amelynek kimenetei csatlakoznak a multiplexer megfelelő címzésű bemenetéhez. Látható, hogy egy ilyen megoldás erőforrás igénye lényegesen kisebb. 4.6. ábra - Look-up table megvalósítása multiplexer segítségével 40

Egyszerű kombinációs hálózatok 4.1.4.1.2. Latch A latch egy olyan tároló elem, amely nem órajelre (élre) működik, hanem egy engedélyező jel megléte esetén az áramkör transzparens, azaz átengedi a bemenetén lévő jelet, az engedélyező jel megszűnésére az utolsó értéket tárolja. Az alábbi rajzon az engedélyező jel aktív értéke az első esetben magas, a másik esetben alacsony (4.7. ábra). 4.7. ábra - Latch 4.1.4.1.3. Korrekt flip-flop órajel engedélyezés 41

Egyszerű kombinációs hálózatok Az órajelre működő szinkron hálózatok esetén fontos, hogy az összes tároló egyszerre billenjen, ellenkező esetben rövid időre hazárd állapotok léphetnek fel. Ezenkívül a dinamikus bemeneten a jelnek stabilnak kell lennie bizonyos idővel az órajel felfutása előtt és után. Ez az áramkörre jellemző katalógus érték (setup time, hold time). Ha ezek a feltételek nem teljesülnek a flip-flop működése bizonytalanná válik, ha például az órajelet kapuzzuk, így plusz késleltetést viszünk bele. Ezért a korrekt megoldást egy multiplexeren áthaladó enable jel biztosítja (4.8. ábra). az első esetben egy D flip-flop, a másodikban egy T flip-flop esetében. Az első esetben, ha az órajel nincs engedélyezve, az órajelre saját magát írja be újra meg újra, ugyanaz a hatás, mintha nem lenne órajel. A második esetben a bemenetre 0 kerül, így a T flip-flop nem billen. 4.8. ábra - Korrekt flip-flop órajel engedélyezés 4.1.4.1.4. Demultiplexer A demultiplexer működése a multiplexerének a fordítottja. Egy bemenete van, és a címző bemenetek határozzák meg, hogy melyik kimeneten megy ki a jel (4.9. ábra, 4.10. ábra). A többi kimenet állapota inaktív. A felhasználási területe főként a számítástechnika. 4.9. ábra - Négy kimenetű demultiplexer 42

Egyszerű kombinációs hálózatok 4.10. ábra - Négy kimenetű demultiplexer kapcsolási rajza 4.1.4.1.5. Laborfeladat Tervezzen meg egy 8-bemenetű multiplexert. Az adatbemeneteket a Digilent Basys2 kártyán lévő SW0-SW7 kapcsolókon lehessen beállítani, a címző bemeneteket a multiplexer bemenetére csatlakozó 3-bites számláló kimenete adja. A számláló órajelét a BTN0 nyomógomb adja. A helyi értékek megfelelnek a kapcsolók és a 43

Egyszerű kombinációs hálózatok számláló kimeneteinek indexének. Végezze el az áramkör szimulációját, és ha jó, fordítsa le, a kapott bit kiterjesztésű fájlt töltse le a Basys2 kártyába, és a kapcsolók és az órajel nyomógomb segítségével próbálja ki az áramkör működését. 4.1.4.1.5.4.1.5.1. Alkalmazandó műszerek és eszközök PC számítógép Digilent Basys2 Spartan-3E FPGA mérőpanel Digilent Adept konfiguráló szoftver 4.2. Kódolók 4.2.4.2.1. Komparátorok (Magnitude Comparators) A digitális komparátorok 2 azonos bitszélességű bináris értéket hasonlítanak össze, egyszerűbb esetben csak az egyenlőséget jelezve, de az un. magnitude komparátorok ezen kívül a kisebb-nagyobb relációt is jelzik (4.11. ábra). 4.11. ábra - 2-szer 4-bites komparátor blokkrajza A két bemenet A(3:0) és B(3:0), az EQ kimenet igaz volta az egyenlőséget (equal), a BGA a B(3:0) a nagyobb voltát, (B greater), az AGB az A(3:0) nagyobb relációt jelenti. A relációt a legnagyobb helyi érték dönti el, ha egyenlők, akkor a következő helyi érték, stb. (4.3. táblázat) 4.3. táblázat - Magnitude Comparator igazságtáblázata 44

Egyszerű kombinációs hálózatok AB AB AB AB AB E 33221100 GQ BA 10xxxxxx100 01xxxxxx010 ==10xxxx100 ==01xxxx010 ====10xx100 ====01xx010 ======10100 ======01010 ========001 Miután az A nagyobb, a B nagyobb és A=B relációk egymást kizárják, ezért az előző igazságtábla redundáns, egyszerűsíthető (4.4. táblázat). Így, ha AGB=0 és EQ=0, akkor BGA=1 (4.12. ábra). 4.4. táblázat - Magnitude Comparator egyszerűsített igazságtáblázata AB AB AB AB AE 33221100GQ B 10xxxxxx10 ==10xxxx10 ====10xx10 = = = = = = 1 0 1 0 = = = = = = = = 0 1 4.12. ábra - Magnitude Comparator egy áramköri megvalósítása 45

Egyszerű kombinációs hálózatok 4.2.4.2.2. Enkóderek Az encoder (átkódoló, kódoló stb.) egy olyan áramkör, amely az információt valamely formából valamilyen másikba alakítja át. (Természetesen, van sokkal precízebb definíció is). Mi két átkódolóval foglalkozunk, az egyszerű átkódolóval és a priority átkódolóval. Az egyszerű átkódoló a sorszámozott egyedi bemeneteket (one hot) átkódolja a sorszám (v. index) bináris kódjává (4.5. táblázat, 4.13. ábra). A bemenetek közül egy és csakis egy lehet aktív. Az áramkör nem tudja megkülönböztetni azt, hogy az I0 bemenet van, vagy egy bemenet sincs. 4.5. táblázat - 8-ról 3-ra enkóder igazságtáblázata Y 210 I 000 n 0 I 001 n 1 I 010 n 2 I 011 n 3 I 100 n 46

Egyszerű kombinációs hálózatok 4 I 101 n 5 I 110 n 6 I 111 n 7 4.13. ábra - 8_to_3 enkóder egy áramköri megvalósítása: 4.2.4.2.3. Prioritáskódoló (priority encoder) A prioritáskódoló esetében egyszerre több bemenet is lehet, a kimeneten a legnagyobb prioritású jel indexe jelenik meg binárisan. Ezen kívül van egy kimenet, amely jelzi, hogy legalább egy bemenet aktív. A következőkben láthatunk példát egy 4 bites (4.6. táblázat) és egy 8 bites (4.7. táblázat) prioritás kódolóra (4.14. ábra, 4.15. ábra, 4.16. ábra). 4.6. táblázat - 4 bites prioritáskódoló igazságtáblázata, (4.1), (4.2), (4.3) I I I I OOI 47

Egyszerű kombinációs hálózatok nnnnuut 0123t t 10 0000xx0 1000001 x100011 xx10101 xxx1111 4.1. egyenlet - (4.1) 4.2. egyenlet - (4.2) 4.3. egyenlet - (4.3) 4.7. táblázat - 8 bites prioritáskódoló igazságtáblázata, (4.4), (4.5), (4.6), (4.7) I I I I I I I I OI nnnnnnnnuuut 01234567t t t 210 xxxxxxx11111 xxxxxx101101 xxxxx1001011 xxxx10001001 xxx100000111 xx1000000101 x10000000011 100000000001 00000000 x x x 0 4.4. egyenlet - (4.4) 4.5. egyenlet - (4.5) 4.6. egyenlet - (4.6) 4.7. egyenlet - (4.7) 4.14. ábra - 8 bites prioritáskódoló rajzjele 48

Egyszerű kombinációs hálózatok 4.15. ábra - 8 bites prioritáskódoló blokkrajza 4.16. ábra - A 8 bites prioritáskódoló megvalósítása 2 4 bitesből 49

Egyszerű kombinációs hálózatok 4.2.4.2.4. Dekóder A dekóder a kódoló inverze, visszaalakítja az információt a kezdetire. Az egyszerű dekóder esetében a binárisan kódolt bemenetet egy és csakis egy (one hot) kimeneti jelre. 4.2.4.2.4.4.2.4.1. 4-ről 1-re dekóder engedélyező jellel 4.8. táblázat - 4-ről 1-re dekóder igazságtáblázata ESS O N1 0 U TTT T 3210 0000000 0010000 0100000 0110000 1000001 1010010 1100100 1111000 4.17. ábra - 4-ről 1-re dekóder blokkrajza 50

Egyszerű kombinációs hálózatok 4.18. ábra - 4-ről 1-re dekóder engedélyező jellel egy áramköri megvalósítása 4.2.4.2.5. Laborfeladat Tervezzen 2 2 bites komparátorból 2 4 bitest! A 2 2 bites komparátor bemenetei: A0, A1, B0, B1, EQin, AGin kimenetei: EQout, AGout. Az igazságtábla alapján tervezze meg az áramkört, legfelsőbb szintű rajzot top.schnak nevezze el! A szimulációhoz használja a kiadott tesztfájlt (testbench, tb_.vhd). A BASYS2 kártya portjaiból a következőket használja: 4.9. táblázat - Portkiosztás SSSS SSSS BL L WT TEE 51

Egyszerű kombinációs hálózatok 01234567NN D 0101 A BE AE A 01230123QG QG i i oo nnuu t t 4.2.4.2.5.4.2.5.1. Alkalmazandó műszerek és eszközök PC számítógép Digilent Basys2 Spartan-3E FPGA mérőpanel Digilent Adept konfiguráló szoftver 4.3. Összeadó áramkör A legegyszerűbb összeadó két bitet ad össze, és az egy bites eredményt és az átvitelt adja ki a kimenetén, ez a félösszeadó (half adder) (4.10. táblázat, 4.19. ábra). 4.10. táblázat - A két bites félösszeadó igazságtáblázata, (4.8), (4.9) I I SC nnuo 01mu t 0000 0110 1010 1101 4.8. egyenlet - (4.8) 4.9. egyenlet - (4.9) 4.19. ábra - Félösszeadó áramkör kapcsolási rajza 52

Egyszerű kombinációs hálózatok 4.3.4.3.1. Teljes összeadó (full adder) A teljes összeadó egy logikai áramkör, ami összeadás műveletet valósít meg három bináris számjegy között (4.11. táblázat, 4.20. ábra, 4.21. ábra, 4.22. ábra). A teljes összeadó egy összeg és egy átvitel értéket szolgáltat, melyek mind bináris számjegyek. Kombinálható más teljes összeadókkal vagy egymaga is dolgozhat. 4.11. táblázat - A két bites teljes összeadó igazságtáblázata, (4.10), (4.11) I I CS C nni uo 01nmu t 00000 00110 01010 01101 10010 10101 11001 11111 4.10. egyenlet - (4.10) 4.11. egyenlet - (4.11) 4.20. ábra - Teljes összeadó egy megvalósítása 53

Egyszerű kombinációs hálózatok 4.21. ábra - Teljes összeadó egy megvalósítása 54

Egyszerű kombinációs hálózatok 4.22. ábra - Teljes összeadó megvalósítása félösszeadó áramkörök segítségével Több bit bites összeadó áramkörben (4.23. ábra) minden helyi értékre kell egy teljes összeadó, az előző helyi érték átvitel kimenete van csatlakoztatva az adott átvitel bemenetére (COUTn-1 -> CINn). Ha kivonást is akarunk végeztetni az összeadónkkal, akkor a második operandus kettes komplemensét (bitenként negált +1) kell az elsőhöz hozzáadnunk. A negálást exkluzív vagy kapuval, az egyes hozzáadását az első helyi értéken a CIN-re adott egyessel oldhatjuk meg. A sorba kapcsolt összeadókkal történő megoldást ripple carry módnak hívjuk. Ennek a megoldásnak az a hátránya, hogy meg kell várnunk, amíg az egyes átvitelek végighaladnak az összes összeadón. Ezért alkalmaznak gyorsítókat (look ahead carry). 4.23. ábra - 4 bites összeadó áramkör 55

Egyszerű kombinációs hálózatok 4.3.4.3.2. BCD összeadó A decimális összeadónál is használhatunk hexa összeadót (4.24. ábra). A bemenet itt is 2db 4 bites operandusból és a bemenő átvitelből áll, de az operandusok maximális értéke 9 lehet, és ez a tervező felelőssége. Átvitel akkor keletkezik,amikor az összeg 10 vagy annál nagyobb, maximálisan 19 lehet. Ha az összeg eléri vagy meghaladja a tízes értékek, ki kell adnunk az átvitel jelet a következő helyi érték felé (a 3 kapuval megoldva), és a bináris értékből le kell vonnunk tízet. Miután modulo 16-ban dolgozunk, ez ekvivalens a 6 hozzáadásával, és ez az egyszerűbb. Ha az összeadás értéke 9 vagy kisebb, a második összeadóval még hozzáadunk 0-t (látszólag feleslegesen). A COUT=0, amely a H5 második operandusának B1 és B2 bemenetére kerül, a B0, B3 és a Cin fixen nullára van kötve. Ha azonban a H6-on keletkezett összeg 10 vagy annál nagyobb, a COUT=1, ez kerül a H6 B1 és B2 bemenetére, így H6 második operandusa 6 lesz. 4.24. ábra - BCD összeadó 56

Egyszerű kombinációs hálózatok 4.3.4.3.3. Laborfeladat Tervezzen egy 4 bites összeadót-kivonót! Az első operandus a 4 bal oldali SW kapcsoló, a második a 4 jobb oldali legyen. A helyi értékek a digiteken belül bal felé nőnek. A kivonás a jobb legszélső nyomógomb (BTN0) lenyomásakor történjen. Az áramkört vizsgálja meg szimulációval, majd töltse le a BASYS2 kártyára, és úgy ellenőrizze a működését. 4.3.4.3.3.4.3.3.1. Alkalmazandó műszerek és eszközök PC számítógép Digilent Basys2 Spartan-3E FPGA mérőpanel Digilent Adept konfiguráló szoftver 4.4. Aritmetikai és Logikai Egység (ALU) A számítástechnikában az aritmetikai-logikai egység (rövidítése ALU az angol Arithmetic Logic Unit alapján) aritmetikai és logikai műveleteket elvégző digitális áramkör. Alapvető eleme a számítógép központi vezérlőegységének. Neumann János alkotta meg az ALU fogalmát 1945-ben, amikor cikkében beszámolt új számítógépéről, az EDVAC-ról. Egy tipikus Neumann-féle CPU belső szerkezetének részében az ALU saját maga végzi az összeadást, a kivonást és más egyszerű műveleteket az inputjain, így adva át az eredményt az output regiszternek. Az első integrált aritmetikai logikai egység a 74-es TTL sorozat 74181 típusú áramköre volt, ami megalapozta a mai modern CPU-k kialakulását. Egy ALU általában a következő alapműveletek végrehajtására képes: összeadás és kivonás (fixpontos, lebegőpontos számokkal) szorzás, osztás (fixpontos, lebegőpontos számokkal) léptetések bitszintű logikai műveletek A műveletek eredményével kapcsolatos egyéb információkat (pl.: túlcsordulás, az eredmény nulla, carry átvitel) is szolgáltat. 57

Egyszerű kombinációs hálózatok 4.4.4.4.1. ALU blokkvázlata Az egyszerűség kedvéért a laborgyakorlaton csak a legalapvetőbb műveleteket valósítjuk meg az ALU-ban (4.25. ábra) 4.25. ábra - A laborgyakorlat során megépítésre kerülő ALU blokkvázlata A modul bemenete két 4 bites szám (A, B). Az S bemenet az ALU vezérlését végzi. Ezzel lehet kiválasztani, hogy éppen milyen műveletet szeretnénk végezni a két bemeneti értéken. Az ALU_out kimeneten az eredmény jelenik meg. A extbfflags kimeneten a műveletvégzés eredményét jelző (Carry, Overflow, Zero) információk jelennek meg. 4.4.4.4.2. ALU műveletvégző egységei ADD: Két négybites szám összeadására képes teljes összeadó. Ha kivonást is akarunk végeztetni az összeadóval, akkor a második operandus (B) kettes komplemenést (bitenként negált +1) kell az elsőhöz (A) hozzáadnunk. A negálást exkluzív vagykapuval, az egyes hozzáadását az első helyi értéken a CIN-re adott egyessel oldhatjuk meg. AND, OR, XOR: A két négybites bemenet bitenkénti és, vagy, kizáró-vagy kapcsolatát adja eredményül. ROL, ROR: Az A bemenet egy bittel történő balra, illetve jobbra forgatása. MUX: A multiplexer a vezérlő jeleknek megfelelő műveletvégző egység kimeneti jelét választja ki. Az ALUban minden műveletvégző egység kimenetén megjelenik az adott műveleti eredmény, ezért szükséges a multiplexer ami csak a megfelelő műveleti eredményt adja a kimenetre. Ez lesz az ALU kimeneti értéke. A blokksémán látható hogy a multiplexer több négybites adatvonal kiválasztását végzi (4.12. táblázat), majd az eredmény egy szintén négybites adatvonalra kerül. Megvalósítása: Négy darab multiplexer, a négybites busz helyi értékeinek kiválasztására. 58

Egyszerű kombinációs hálózatok Másik lehetőség az ALU_out_mux 1 makró használata. Ez egy 8-ról 1-re multiplexer, 4 bites adatcsatornákkal. 4.12. táblázat - Az ALU kimeneti jelei a vezérlőjeleinek függvényében SSSK L 210i eí m rá e s n e t 000Y A =z A + A B és B be m en et ös sz eg e. 001Y A =z A A B és B be m en et k ül ö n bs ég e 010Y (i ) = A (i ) & A z A és B 1 A makró fájlok a mellékletben megtalálhatóak. 59

Egyszerű kombinációs hálózatok 60 B (i ) be m en et bi te n ké nt i É S ka pc so la ta 011Y ( 2 : 0 ) = A ( 3 : 1 ), Y ( 3 ) = A ( 0 ) A z A be m en et ro tá lá sa jo b br a. 100Y (i ) = A (i ) B (i ) A z A és B be m en et bi te n ké nt i

Egyszerű kombinációs hálózatok 61 V A G Y ka pc so la ta 101Y ( 3 : 1 ) = A ( 2 : 0 ), Y ( 0 ) = A ( 3 ) A z A be m en et ro tá lá sa ba lr a. 110Y (i ) = A (i ) B (i ) A z A és B be m en et bi te n ké nt i X O R ka pc so la ta 111- -

Egyszerű kombinációs hálózatok A laborgyakorlaton megépített ALU három Flag bitet tartalmaz. Overflow: Előjeles túlcsordulás. Előjeles számok esetében az összeadás, vagy a kivonás eredménye nem ábrázolható az adott számtartományon. Carry: Átvitel előjel nélküli műveleteknél. Az összeadás eredménye nem ábrázolható az adott számtartományban. Zero: Az ALU művelet eredmény nulla lett. 4.4.4.4.3. Laborfeladat Készítse el egy négybites aritmetikai és logikai egységet (4.26. ábra), a következő műveletek végrehajtására: összeadás, kivonás, ÉS, VAGY, kizáró-vagy, forgatás jobbra, forgatás balra. Az ALU építésénél felhasználható, a szimbólumok között megtalálható ADD4 összeadó áramkör, és a mellékletben megtalálható ALU_out_mux multiplexer. A kész ALU áramkörből készítsen makrót. 4.26. ábra - ALU A makró ki-bemeneteit a megadott módon társítsa portokhoz (4.13. táblázat). 4.13. táblázat - Portkiosztás MP a o k r r t ó ( U C F f á j l 62

Egyszerű kombinációs hálózatok 63 ) S 0, S 1, S 2 B T N 0, B T N 1, B T N 2 A ( 3 : 0 ) S W ( 3 : 0 ) B ( 3 : 0 ) S W ( 7 : 4 ) A L U _ O U T ( 3 : 0 ) L E D ( 3 : 0 ) O V F L E D ( 5 ) C A R R Y L E D ( 6 ) Z E R O L E D (

Egyszerű kombinációs hálózatok 7 ) A szimulációhoz használja a kiadott tesztfájlt. Kiegészítő feladat: A bemeneti A, és B számot, a vezérlőbiteket és az eredményt jelenítse meg hétszegmenses kijelzőkön. A feladathoz szükséges makrók: Clk_divide, Bin_to_7_segment_x4. 4.4.4.4.3.4.4.3.1. Alkalmazandó műszerek és eszközök PC számítógép Digilent Basys2 Spartan-3E FPGA mérőpanel Digilent Adept konfiguráló szoftver 4.5. Shift regiszter A shift regiszter sorba kötött, leginkább D flip-flopokból álló áramkör. Ha a flip-flopok bemenetére a tőlük balra lévő flip-flop kimenetét kötik, akkor jobbra léptető, ha a tőlük jobbra lévő flip-flop kimenetét kötik, balra léptető shift regiszterről beszélhetünk. A mikroprocesszorok regisztereinek léptetéskor (shift utasítás) az utolsó bit helyére legtöbbször 0 kerül, rotálásakor a léptető regiszter soros kimenete és bemenete össze van kötve, vagy a Carry jelző bitet léptetjük be az utolsó bit helyére. A shift regisztert használhatjuk számlálónak, vagy állapotgépben a különböző állapotok bináris tárolására. Minden szám egy egyest tartalmaz, a többi zérus (one hot). Minden állapotnak vagy számlálóértéknek egy flip-flop egyes állapota felel meg, azaz, ahány flip-flop van, annyit tud számlálni, vagy annyi állapot feleltethető meg neki. Ez több flip-flopot igényel (n), mint a binárisan kódolt számláló esetén (2 log n), de lényegében nincs szükség kapuáramkörökre. A gyűrűs számláló esetén (4.27. ábra) a jobb szélső kimenet vissza van csatolva a bal szélső bemenetre, így az egyes a számlálás folyamán balról jobbra lép. Az első flip-flop és a kapu a bekapcsolás utáni első egyes bevitelére szolgál, később már nem játszik szerepet. (Máshogy is megoldható.) 4.27. ábra - Gyűrüs számláló 4.5.4.5.1. Léptető regiszterek 4.5.4.5.1.4.5.1.1. Soros-párhuzamos átalakító A legegyszerűbb shift regiszter, a soros adat a baloldali SHIN bemeneten lép be, és amikor megjelenik a SHOUT kimeneten (8. ütem), a flip-flopok kimenetéről párhuzamosan leolvasható a byte (4.28. ábra). Felhasználására példa a merevlemez illesztő, ahol a lemezről olvasott soros adatokat a párhuzamos buszon keresztül kell eljuttatni a szintén párhuzamos szervezésű memóriába. 4.28. ábra - Shift regiszter 64

Egyszerű kombinációs hálózatok 4.5.4.5.1.4.5.1.2. Párhuzamos-soros átalakító A párhuzamosan beírt adatokat sorosan kell az SHOUT kimenetre juttatni. Itt az első flip-flop kivételével az adatok két helyről kerülnek a flip-flopok bemenetére, minden órajelre az előző kimenetéről, és 8 ütemenként a párhuzamos bemenetről. Ezt végzik a bemeneti multiplexerek. Ha a MODE bemenet 1 soros léptetés, ha 0 párhuzamos beírás történik. Felhasználására itt is példa lehet a merevlemez illesztő, ahol a párhuzamos szervezésű memóriából olvasott soros adatokat sorosan kell eljuttatni a lemez felületére (4.29. ábra). 4.29. ábra - Shift regiszter párhuzamos adatbemenettel 4.5.4.5.1.4.5.1.3. Jobbra-balra léptető regiszter Az adat sorosan kerül be a SRIN vagy az SLIN bemeneteken, és a DIRECTION bit határozza meg, hogy balra DIRECTION=0 vagy jobbra DIRECTION=1 léptet. A soros kimenet a S7 jobbra léptetésnél, és S0 a balra léptetésnél (4.30. ábra). 4.30. ábra - Jobbra-balra léptető regiszter 4.5.4.5.1.4.5.1.4. Barrel shifter A barrel shifter (4.31. ábra) egy kombinációs hálózat (nem regiszter), legegyszerűbben 2 bemenetű multiplexerekkel építhető fel. Az egy oszlopban lévő multiplexerek száma megegyezik az adatszélességgel, (az ábrán 1 byte), az oszlopokszáma egyenlő a címző bitek számával. A címző bitek a lehetséges maximális eltolás binárisan kódolva (az ábrán 3, azaz a maximális eltolások száma 7). Az első oszlopban lévő multiplexerek, ha a címző bemenetükön egy van, eggyel léptetik el az adatot, a másodikban lévők kettővel, a harmadikban lévők néggyel. A léptetések összegződnek. A léptetés (valójában rotálás) az egyik irányban történik, de ha a barrel shifter N léptetésre alkalmas, akkor az n léptetés az egyik irányban megfelel (N n) léptetésnek a másikban. 4.31. ábra - Fast, Compact Barrel Shifter with Encoded Shift Control 65

Egyszerű kombinációs hálózatok 4.5.4.5.2. Egyéb alkalmazások shift-regiszterrel 4.5.4.5.2.4.5.2.1. Lifo Az előre-hátraléptető regiszter felhasználható hardver LIFO, vagy más néven stack, magyar szóhasználattal verem létrehozására (4.32. ábra). 4.32. ábra - LIFO 66

Egyszerű kombinációs hálózatok A példán egy 8 byte mélységű verem látható ahol a LIFOMEM jelenti a 8 byte-os tárolót, az SH_FORE a verem állapotának jelzésére szolgáló áramkör. A memória 8 párhuzamosan, bitenként működő 8 bites előrehátraszámláló léptető regisztert tartalmaz. A LIFOINn jelenti a verem bemenetét, a LIFOOUTn a kimenetét, a LIFOPUSH mutatja meg, hogy mélyítünk vagy kiemelünk. A verem korrekt működéséhez jelezni kell az állapotát, ha üres, csak írni szabad bele (ellenkező esetben az olvasott adat nem jó), ha tele van, azaz a beírt adat elérte a verem alját, csak olvasni szabad belőle (ellenkező esetben az utolsó adatot felülírjuk, így elvész). Az állapot jelzésére egy 9-dik 8 bites előre-hátraszámláló léptető regisztert alkalmazunk, amelynek a jobbra léptető bemenetére egy állandó egyest, a balra léptető bemenetére egy állandó nullát kötünk. Amikor beírunk a LIFO-ba (mélyítés) megy befelé az egyes, és ha megjelenik a jobb kimeneten, akkor a verem tele van. Amikor kiolvasunk a LIFO-ból (kiemelés) a nulla vándorol a bal kimenet felé, és ha a bal kimeneten megjelenik, akkor a verem üres. A hardver vermet a mikroprocesszorok IT kezelésében (amennyiben az többszintes) alkalmazzuk. 67

Egyszerű kombinációs hálózatok 4.5.4.5.2.4.5.2.2. A Johnson számláló Ha egy léptető regiszter kimenetét egy inverteren keresztül visszacsatoljuk a bemenetére megkapjuk a Johnson számlálót. Egy tízes Johnson számláló öt flip-flopból áll (4.14. táblázat, 4.33. ábra). 4.14. táblázat - Johnson számláló igazságtáblázata ABCDEC o u n t 000000 100001 110002 111003 111104 111115 011116 001117 000118 000019 Az öt flip-flop kimenetét jelöljük A-tól E-ig. Látható, hogy minden ötbites értékben van két egymás mellett lévő olyan bit, amely egyedi, így ezek a párosok felhasználhatók a számok kódolására 0-tól kilencig. (Ezek: nanb, AnB, BnC, CnD, DnE, EA, nab, nbc,ncd és nde. Az n jelenti a negált értéket). A kimenetek egy-egy esetleg invertált két bemenetű kapuval előállítható. A flip-flopok száma kevesebb, mint a one hot esetében (10), de több, mint a binárisan kódolt számok használatánál (4), de viszonylag kevés kaput használ. Azonkívül, ha sorban számol, a következő szám mindig csak egy bitben különbözik az előzőtől, mint a Grey kód esetén. 4.33. ábra - Johnson számláló 4.5.4.5.2.4.5.2.3. Soros összeadó A soros összeadóban van két jobbra léptető regiszter a két operandusnak, egy harmadik az eredménynek, egy flip-flop a carry out tárolására, és egy egybites teljes összeadó. a legkisebb helyi értékű bitek rákerülnek az összeadó adatbemeneteire, az összeg rákerül a harmadik regiszter shift in bemenetére, az esetleg keletkezett átvitel a flip-flop bemenetére, a flip-flop kimenete tartalmazza az előző összeadás átvitelét. Órajelre mindhárom léptető regiszter eggyel jobbra lép, az összeadó adatbemeneteire a következő helyi érték kerül, a flip-flopba 68

Egyszerű kombinációs hálózatok beíródik az új átvitel, az összeget tartalmazó léptető regiszterbe belép az adott helyi értékhez tartozó egybites összeg. A 8.-ik órajelre előáll az eredmény, a flip-flop kimenete pedig tartalmazza az esetleges átvitelt (4.34. ábra). 4.34. ábra - Shift Register Applications Example: 4.5.4.5.3. Laborfeladat Tervezzen egy 8 bites, jobbra-balra léptető regisztert párhuzamos beírási lehetőséggel. A léptető regiszter kimenetei csatlakozzanak a tesztkártyán lévő LED-ekhez, az órajelet (clk) a BTN0 nyomógombról, a párhuzamos beírás engedélyezése(pen) a BTN1 nyomógomb megnyomásával legyen elérhető. Oldja meg, hogy a léptető regiszterbe beírt byte órajelre addig lépdeljen jobbra ill. balra, amíg egy egyes nem éri el valamelyik (0. vagy 7.) szélső bitet, amikor is a léptetés iránya megfordul. Ha beíráskor a két szélen mindkét bit egyes, a következő órajelre az egyik kerüljön át a másik mellé, és innen folytassa a fentebb leírt működést (futófény). 4.5.4.5.3.4.5.3.1. Alkalmazandó műszerek és eszközök PC számítógép Digilent Basys2 Spartan-3E FPGA mérőpanel Digilent Adept konfiguráló szoftver 69

5. fejezet - Négybites CPU tervezés 5.1. Bevezetés A CPU (angol: Central Processing Unit központi feldolgozóegység) más néven processzor, a számítógép agya, azon egysége, amely az utasítások értelmezését és végrehajtását vezérli, félvezetős kivitelezésű, összetett elektronikus áramkör. Egy szilícium kristályra integrált, sok tízmillió tranzisztort tartalmazó digitális egység. A bemeneti eszközök segítségével kódolt információkat feldolgozza, majd az eredményt a kimeneti eszközök felé továbbítja. A processzor alatt általában mikroprocesszort értünk, régebben a processzor sok különálló áramkör volt, ám a mikroprocesszorral sikerült a legfontosabb komponenseket egyetlen szilíciumlapkára integrálni. 5.1. ábra - Intel 80486-os processzor Az első mikroprocesszor az 1971-ben megjelent 4 bites szóhosszúságú Intel 4004 volt. Később több sikeres 8 bites sorozat jelent meg több gyártó részéről (Intel 8008, 8080, 8085, Zilog Z80, Motorola 6800, MOS Technology 6502). A 80-as évektől kezdve megnőtt a processzorok szóhossza (Intel 8086 (az IBM PC és PC/XT processzora): 16 bit (20-bites címtartomány), Intel 80286 (a PC/AT processzora): 16 bit (24 bites címtartomány) 1982, Intel 80386: 32 bit 1985) az órajel folyamatos növekedése mellett. 5.1.5.1.1. Számítógépes architektúrák A mikroszámítógépek fejlődése során két architektúra terjedt el (5.2. ábra). Az egyik a Neumann architektúra, itt ugyanabban a memóriában van a programkód, mint az adatok. Ilyen architektúrájúak például az INTEL x86-os processzorok. A Harvard architektúra esetében külön memória áll rendelkezésre az adatok és az utasításkód tárolására (mikrokontrollerek, PIC család). 70

Négybites CPU tervezés 5.2. ábra - Neumann és Harvard számítógép architektúra 5.1.5.1.2. Utasításkészlet A processzor által ismert műveletek és utasítások összességét értjük a processzor utasításkészlete alatt. Legelőször a RISC (Reduced Instructions Set Computer) utasításkészletet használták, ez leegyszerűsített, rövid utasításokat tartalmazott. Elsődlegesnek tekintette a sebességet, és az egyszerűséget. Később a CISC-et (Complex Instructions Set Computer) alkalmazták, ez már több, hosszabb utasítást tartalmazott, ám a túl sok, bonyolult utasítás nem bizonyult célravezetőnek, ezért visszatértek a RISC-hez. Ma már persze rengeteg utasításkészlet van, melyben keverednek a RISC, és a CISC irányelvei. 5.1.5.1.3. A labormérés alatt megépítendő CPU architektúrája A labormérés korlátozott időtartama miatt az alábbi blokkvázlaton látható (egyszerű felépítésű) Harvard architektúrájú CPU kerül megtervezésre és elkészítésre (5.3. ábra). A gyakorlatban használatos processzorok ennél jóval bonyolultabb belső felépítéssel rendelkeznek, de az általános működés megértéséhez ez az egyszerű változat is elegendő. A következőekben a laborgyakorlatok során összeállított négybites processzor belső felépítése kerül ismertetésre. 5.3. ábra - A laborgyakorlatok alatt épített négybites CPU blokkvázlata 71

Négybites CPU tervezés PC (Program Counter): A programszámláló mindig a következő végrehajtandó utasítás címét tartalmazza. A labormérésen épített processzorban a programszámláló maximális értéke 255 lehet, mivel a programmemória 256 elemű. Programmemória (INST_MEM): A programmemória tartalmazza a végrehajtandó programot. A program utasítások sorozatából épül fel. Az utasítások vezérlik a mikroprocesszor működését. Egy utasítás kód hossza 21 bit, így a programmemória is 21 bit szélességű. Utasítás: Az utasítások az alegységeket vezérlő bináris kódokat és operandusokat tartalmaznak. Az éppen végrehajtásra kerülő utasítást a PC választja ki. Az utasítást két részre lehet bontani: Vezérlőjelek: az utasítás azon része, mi a mikroprocesszor vezérléséért felel. Pl.: beolvasás a bemenetről, összeadás, kivonás elvégzése regisztereken Operandus: a vezérlőjeleken kívül az utasítás operandust is tartalmazhat. Ez az utasítás típusától függően lehet adat, vagy cím is. Regiszterek: Vannak speciális célú regiszterek a CPU-ban. Ilyen az A és a B regiszter. Ezekbe lehet az operandusokat betölteni, majd az ALU ezeken végzi el a kiválasztott műveletet. Az ALU művelet eredménye szintén ezekbe a regiszterekbe töltődik. Aritmetikai és Logikai Egység (ALU): Aritmetikai és logikai műveletek végrehajtására alkalmas. Memória (RAM): Címezhető memória. Adatok tárolására alkalmas. A regiszterek értékét, az utasításban megadott című memóriarekeszbe lehet tölteni, vagy kiolvasni. A memória 32 darab 4 bites adatot tud tárolni. Bemenet (input): A processzor két bemeneti porttal rendelkezik. Rajtuk keresztül 4 bites adatokat lehet a processzor belső regisztereibe juttatni. Kimenet (output): A processzor két kimeneti porttal rendelkezik. Rajtuk keresztül 4 bites adatokat lehet a kimenetre írni (pl. LED-ekre vagy hétszegmenses megjelenítőkre). 5.1.5.1.4. A CPU utasításainak felépítése 72

Négybites CPU tervezés A processzoron belül különböző műveletvégző egységek, memóriák, kimeneti, bemeneti egységek találhatóak. Ezek vezérléséhez vezérlőjelek szükségesek. A vezérlőjelek az utasításban általában kódolva jelennek meg, így rövidebb utasítás szóhossz érhető el. Ebben az esetben a vezérlőjelek előállításához az utasítást dekódolni kell. A labormérésen épített CPU egyszerűsítése miatt kihagyjuk az utasításdekódolót, így az utasításokban a vezérlőjelek már dekódolt formában helyezkednek el. A következő táblázatok a CPU egyes egységeinek vetélését adják meg. 5.1.5.1.4.5.1.4.1. Az A és B regiszter bemenetének kiválasztása (Register input select) A labormérésen tervezett CPU-ban minden adat az A és B regiszteren keresztül mozgatható, ezért a regiszterek bemenete több modulból is érkezhet. A regiszterek bemenetét egy 8 bemenetű multiplexerrel választhatjuk ki a három vezérlőbemenet segítségével. A multiplexer adatbemenetei 4 bitesek. A következő táblázat megadja, az egyes vezérlő bemenet kombinációk esetén melyik forrás kerül a regiszterekre. A multiplexerrel kiválasztott adatot a megfelelő regiszterbe a Ben, ABEN típusú vezérlőbittel lehet beírni. A Ben nulla értéke esetén a kiválasztott adat az A regiszterbe, míg logikai egy értéke esetén a B regiszterbe töltődik. 5.1. táblázat - Az A és B regiszter bemenetének kiválasztása AF Leí eeeurás nnnn 210k c i ó 000AA oreg uiszt t ere k be me net e az A reg iszt er ki me net e 001BA oreg uiszt t ere k be me net e a B reg iszt er ki 73

Négybites CPU tervezés me net e 010RA Areg Miszt oere uk t be me net e a me mó ria ki me net e 011I A Nreg Siszt Tere k be me net e az uta sítá s arg um ent um a (ut asít ás els ő 4 bite ) 100I A Nreg 0iszt ere k be me net e az inp ut 0 101I A Nreg 74

Négybites CPU tervezés 1iszt ere k be me net e az inp ut 1 110AA Lreg Uiszt oere uk t be me net e az AL U ki me net e 111- - 5.1.5.1.4.5.1.4.2. ALU vezérlése (ALU control) A processzor Aritmetikai és Logikai Egysége a bemeneti A illetve B regisztereken képes műveleteket végezni. Az eredmény minden esetben az A regiszterbe kerül. A művelet kiválasztása 3 biten történik, ezt ismerteti a következő táblázat. 5.2. táblázat - ALU vezérlő jelei SSSF Leír 210uás n k c i ó 000AAz + A Bés a B regi szte r öss zea dás a, ere dm ény az 75

Négybites CPU tervezés A -ba 001AAz - A Bregi szte rből B kiv oná sa, ere dm ény az A -ba 010AAz A aés a n B dregi szte Br bite nké nti ÉS kap csol ata, ere dm ény az A -ba 011RAz O A Rregi szte r rotá lása job bra, ere dm ény az A -ba 100AAz A oés a r B regi Bszte 76

Négybites CPU tervezés r bite nké nti VA GY kap csol ata, ere dm ény A -ba 101RAz O A Lregi szte r rotá lása balr a, ere dm ény az A -ba 110AAz A xés a o B r regi szte Br bite nké nti XO R kap csol ata, ere dm ény az A -ba 111- - 5.1.5.1.4.5.1.4.3. Ugró utasítások, a programszámláló megváltoztatása (Branch control) Normál esetben az utasítás számláló minden utasítás után eggyel növekszik. Ugró utasítás esetén a program végrehajtását az utasításkódban megadott címtől kell folytatni (utasítás első 8 bitje). Ehhez az utasításszámlálót a következő ciklus előtt módosítani kell. Az ugróutasítás lehet feltétel nélküli, vagy feltételes. Feltétel nélküli ugrás esetén mindenképpen megváltozik az utasításszámláló értéke. A feltételes ugrásnál az ugrás 77

Négybites CPU tervezés bekövetkezése feltételhez kötött. A feltételeket az ALU Z (zero), C (carry), O (overflow) jelzőbitjei szolgáltatják. Az ugró utasítás előtti ALU művelet módosítja a jelzőbitek értékét, és ennek függvényében az ugróutasítás vagy bekövetkezik (ekkor módosul a PC az utasításban megadott címre), vagy nem következik be (ekkor a PC értéke eggyel növekszik). 5.3. táblázat - Ugró utasítások BF Leí r r r urás 210n k c i ó 000nNin ocs ugr Bás R 001BAz RAL ZU Z flag -je 1, ugr ás az utas ítás utol só 8 bitj én me gad ott cím re 010BAz RAL NU Z Zflag -je 0, ugr ás az utas ítás utol só 8 bitj én me gad ott 78

Négybites CPU tervezés 79 cím re 011B R C Az AL U C flag -je 1, ugr ás az utas ítás utol só 8 bitj én me gad ott cím re 100B R N C Az AL U C flag -je 0, ugr ás az utas ítás utol só 8 bitj én me gad ott cím re 101B R O Az AL U O flag -je 1, ugr ás az utas ítás utol

Négybites CPU tervezés só 8 bitj én me gad ott cím re 110BAz RAL NU O flag -je 0, ugr ás az utas ítás utol só 8 bitj én me gad ott cím re 111BFelt Rétel nél küli ugr ás, ugr ás az utas ítás utol só 8 bitj én me gad ott cím re 5.1.5.1.4.5.1.4.4. Egyéb vezérlő jelek A processzoron belül található memória adatbemenete az A regiszter kimenetére kapcsolódik. A regiszter értékének memóriába töltése a mwe, MWE típusú vezérlőbittel történik. A beírás során az adatmemória címét az utasítás első 5 bitje határozza meg. 80

Négybites CPU tervezés Az A regiszter értékének kimenetre történő másolása Oen és Onb, OEN típusú vezérlőbitekkel lehetséges. 5.4. táblázat - Kimeneti regiszterek vezérlő jelei OF Leí enu rás nbn k c i ó 00- Ne m tört éni k kiír ás 01- Ne m tört éni k kiír ás 10o Az u A t regi 0szte = r Aérté ke a 0. kim ene ti latc h- be ker ül 11o Az u A t regi 1szte = r Aérté ke a 1. kim ene ti latc h- be ker ül 81

Négybites CPU tervezés 5.1.5.1.4.5.1.4.5. Az utasítások felépítése Egy utasítást két részre lehet bontani. A vezérlőjelek az utasítás azon részei, melyek a mikroprocesszor vezérléséért felelnek (pl. az ALU egyes egységeinek vezérlőjelei), ezeket összefoglalóan "Control signals"-nak nevezzük (5.4. ábra). Az utasítás másik része az operandus, amit a vezérlőjelektől függően lehet adat vagy címként is értelmezni, vagy az utasítás szempontjából nem tartalmaz információt (Address or Operand). Az operandust a következőképpen lehet értelmezni: INSTR address: 8 bites címet tartalmaz, az ugró utasítások esetén. RAM address: 5 bites cím, a memória műveletek esetén. RAM-ba írás, vagy RAM-ból olvasás. A maradék 3 bit nem használt (don t care). DATA: 4 bites adat, a konstans szám regiszterbe töltése esetén. A maradék 4 bit nem használt (don t care). 5.4. ábra - Az utasítások felépítése 5.1.5.1.4.5.1.4.6. Mnemonik A következő táblázat azokat az utasításokat tartalmazza, melyeket a CPU képes értelmezni, és végrehajtani. Vegyük példának egy konstans A regiszterbe való betöltését (5.5. ábra). 5.5. ábra - Az utasítások felépítése A táblázat első sora a bitszámozást tartalmazza, a második sorában az utasítás általános alakja szerepel. Itt a lényeges vezérlőbitek értéket kaptak (0,1), az utasítás számára lényegtelen biteket x-el jelöltük. Az utolsó sorban az utasítás számára érdektelen biteket nullával helyettesítettük. A 0. 3.-ik helyi értéken egy k szám kerül megadásra, ez lesz a betöltendő konstans. Ha vesszük az utasítást hexadecimális formában 0x0C000+k és hozzáadjuk a konstans négybites számot akkor megkapjuk az utasítás kódját. Az ilyen kódok szemléletesebb jelölésére rövid utasításneveket szoktak megadni, melyeket mnemonikoknak nevezünk. Ez a rövid azonosító az operandussal együtt meghatározza az utasításkódot. A példa esetében: LDI k. 5.1.5.1.4.5.1.4.7. A CPU teljes utasításkészlete 5.6. ábra - Utasításkészlet 82

Négybites CPU tervezés 5.1.5.1.5. Laborfeladat A CPU megtervezése és megépítése 5 laborgyakorlat alatt történik. Az egyes laborgyakorlatokon elkészítendő részfeladatok: CPU laborfeladat és a használt alkatrészek megismerése. Hétszegmenses kijelző modulok használatának megismerése (négy és a nyolc hétszegmenses kijelző). Órajel forrás hozzáadása (manuális, 10Hz-es). Programszámláló és programmemória. A programszámláló és az utasítás megjelenítése. Szimuláció és letöltés. Buszrendszerek. Az A és a B regiszter bemenetének kiválasztása és ALU hozzáadása a rendszerhez. Az A és B regiszter értékének megjelenítése. ALU flag kimeneteinek regiszterbe töltése. Szimuláció és letöltés. Kimeneti regiszterek és memória hozzáadása a rendszerhez. Ugró utasítás megvalósítása. Az így elkészül végleges processzoron az 1. mintaprogram kipróbálása. Letöltés. Az elkészült CPU-ra programkód készítése, és annak vizsgálata. A laborgyakorlatokon elkészítendő részfeladatok a következő 4 alfejezetben kerülnek ismertetésre. 5.1.5.1.5.5.1.5.1. Alkalmazandó műszerek és eszközök PC számítógép Digilent Basys2 Spartan-3E FPGA mérőpanel Basys2 extboard #1 kiegészítő panel Digilent Adept konfiguráló szoftver Assembler program: assemblerdtcpu4.exe 5.2. Órajel forrás, programszámláló, utasításregiszter, kijelzés 83

Négybites CPU tervezés A CPU működéséhez órajel szükséges. Az órajelet a panelen található 50 Mhz-es oszcillátorból nyerhetjük, vagy nyomógombok segítségével állíthatjuk elő. Hogy a processzor működését nyomon követhessük megfelelően kis frekvenciájú órajelre van szükség. Az 50Mhz-es jelből a Clk_divide makróval 10 Hz-es órajelet állíthatunk elő. Másik lehetőség, hogy az órajel fel- és lefutó életi nyomógombok segítségével állíthatjuk elő (lásd: FPGA fejlesztés ISE-ben 16. oldal). Az egyik gomb az UP a másik gomb a DOWN port nevet viseli az ucf fájlban. Egy kiválasztó gomb (OCLK_EN) lenyomásával dönthetjük el, hogy a 10 Hz-es (OCLK_EN=1), vagy az UP/DOWN gombokkal előállított jel (OCLK_EN=0) legyen a CPU órajele (clock jel). Mivel a processzor egységei az órajel különböző éleire aktívak, szükség van az órajel negáltjára (clock_n). A clock_n órajel adja egy 8 bites számláló (CB8CLE) órajelét. Ez a számláló a programszámláló, melynek load bemenetét az ugróutasítások vezérlik. A párhuzamos adatbemenete az utasítás argumentum része lesz, vagyis az ugrási cím. (Az ugró utasításokról későbbi fejezetben ismerkedhetünk meg részletesebben.) Jelen feladatban az ugró utasításokkal nem foglalkozunk, ezért ezt a bemenetet logikai nulla értékre kell kötni. A számláló kimenete a Pcnt busz, ami az utasításmemória (INST_MEM) címbemenetét adja. Azutasításmemória kimenetén (INSTR busz) jelennek meg az utasítások, a clock órajel hatására. Az órajel felfutó élének hatására a programmemóriából a megfelelő utasítás kiolvasásra kerül, majd az órajel lefutó élének hatására végrehajtódik az utasítás, és a programszámláló értéke megváltozik a következő végrehajtandó utasítás címére. A kijelzőkre kösse rá az utasításmemória és a programszámláló kimenetét (részletek a táblázatban). 5.5. táblázat - Kijelzők portkiosztása BJ Leí ee rás ml e n e t i P nc Pro _ n gra At ms 1( zá 7 ml : áló 4 me ) gje i P len nc ítés _ n e At az 0( A kij 3 : 0 ) elz őn i 0 Ut n0asít _ 0 ás B me 1+ gje len I ítés Ne a S B, T C R és ( D 2 kij 0 elz 84

Négybites CPU tervezés 85 ) ő mo dul ok on i n _ B 0 I N S T R ( 1 9 : 1 6 ) i n _ C 1 I N S T R ( 1 5 : 1 2 ) i n _ C 0 I N S T R ( 1 1 : 8 ) i n _ D 1 I N S T R ( 7 : 4 ) i n _ D 0 I N S T R ( 3 : 0 )

Négybites CPU tervezés Szimulációval ellenőrizze a működést. A szimuláció során figyelje meg a programszámláló értékét, és a hozzátartozó utasításokat. Alapértelmezésben az alábbi kódrészlet található a programmemóriában (5.7. ábra). Az első oszlop az utasítás helyét jelöli a programmemóriában, ez nullától kezdve folyamatosan növekszik. A harmadik oszlopban az utasítás mnemonikja látható (nop, ldi...) majd a következő oszlopban az argumentum. Az utolsó oszlop az utasítás hexadecimáliskódját mutatja. Helyes működés esetén a PC kiválasztja az aktuális utasítást, a kijelzőn ennek megfelelő utasításkód jelenik meg. A kijelzőkön az (5.7. ábra) első és utolsó oszlopának sorait kell látnunk. 5.7. ábra - A mintaprogram mnemonikjai és utasításkódjai A szimuláció után próbálja meg letölteni a kapcsoláshoz tartozó konfigurációs fájlt az FPGA-ba és ellenőrizze a működést. A 5.8. ábra szemlélteti a CPU teszteléséhez szükséges kapcsolók, kijelzők funkcióját. 5.8. ábra - Ki-bemeneti egységek 86

Négybites CPU tervezés A következő táblázat tartalmazza a laborgyakorlaton felhasznált ki-és bemeneti portokat (I/O port) (20. táblázat). 5.6. táblázat - Portkiosztás PBLeí ourás r s t z n é v S84d E b Gb hét 4i sze ( t gm 7 ens : es 0 kij ) elz ő sze gm ens 87

Négybites CPU tervezés 88 ei. A N 4 ( 3 : 0 ) 4 b i t 4d b hét sze gm ens es kij elz ő kiv ála szt ó jel ei. S E G 8 ( 7 : 0 ) 8 b i t A kie gés zít ő pa nel sze gm ens ei. A N 8 ( 7 : 0 ) 8 b i t A kie gés zít ő pa nel kiv ála szt ó jel ei. M C L K - A Cl oc k_ div ide be me net e. 50 Mh z- es óra jel U- btn

Négybites CPU tervezés P 3. Le ny om ása kor a ren dsz er óra jel ma gas ért ék ű les z D- btn O 2. WLe N ny om ása kor a ren dsz er óra jel ala cso ny ért ék ű les z O- btn C 1. L Le K ny _ om E ása N kor a ren dsz er óra jel 10 Hz, ell en kez 89

Négybites CPU tervezés ő ese tbe n az UP /D O W N R- btn S 0. T Re nds zer ala pál lap otb a hel yez ése. Mi nd en szá ml áló t tör öl. 5.3. ALU és regiszterek Az előző órán elkészített áramkört egészítse ki regiszterekkel. A regiszterekhez FD4CE tárolót használjon. A kapcsolásban szereplő jeleket az ábra szerint nevezze el (5.9. ábra). Az A és B regiszterek vezérlése a rendszer órajel lefutó élére történik. A regiszterek kimeneteit kösse rá az ALU bemeneteire. Az utasítás busz (INSTR) megfelelő jeleit kösse rá az ALU vezérlőjeleire. 5.9. ábra - A CPU műveletvégző egysége és regiszterei 90

Négybites CPU tervezés Az A és B regiszter bemenete több forrásból származhat (bemenet, regiszterek, ALU, RAM, utasítás...), melyek közül a multiplexer választja ki az utasításnak megfelelőt (felhasználható makró: mux8_4bit). Az utasítás busz (INSTR) regiszterekre vonatkozó jeleit kösse a multiplexer kiválasztó bemenetére. A regiszterek lehetséges bemeneti forrásait kösse rá a multiplexer adatbemeneteire, ebből hagyja ki a RAMout kiválasztást, mivel ez a jel egy későbbi gyakorlat során kerül a rendszerbe. Most konstans nulla értékkel helyettesítse ezt a bemenetet. A kiválasztott adat A vagy B regiszterbe való töltését az ABEN vezérlőbit irányítja. A Bin_to_7_segment_x4 makró bekötéseit az alábbi táblázat tartalmazza (5.7. ábra). 5.7. táblázat - Kimenet portkiosztása BJ ee ml e n e t i A no _ u At ( 3 : 0 ) i B no _ u Bt ( 3 : 0 ) 91

Négybites CPU tervezés i 0 n _ C i 0 n _ D Szimulációval ellenőrizze a működést. Figyelje meg a programszámláló értékét, az utasításkódokat, valamint az A és B regiszterek értékeit. Az utasításmemóriában 5.10. ábra szerinti program található. 5.10. ábra - A mintaprogram mnemonikjai és utasításkódjai A szimuláció után próbálja meg letölteni a kapcsoláshoz tartozó konfigurációs fájlt az FPGA-ba és ellenőrizze a működést. Az FLAG bitek ellenőrzésére és az órajel megjelenítésére használja az FPGA fejlesztőpanelen található LED-eket. 5.11. ábra - Ki-bemeneti egységek 92

Négybites CPU tervezés A következő táblázat tartalmazza a laborgyakorlaton felhasznált ki-és bemeneti portokat (I/O port) (5.8. táblázat). 5.8. táblázat - Portkiosztás PBLeí ourás r s t z n é v S84d E b Gb hét 4i sze ( t gm 7 ens : es 0 kij ) elz ő sze gm ens 93

Négybites CPU tervezés 94 ei. A N 4 ( 3 : 0 ) 4 b i t 4d b hét sze gm ens es kij elz ő kiv ála szt ó jel ei. S E G 8 ( 7 : 0 ) 8 b i t A kie gés zít ő pa nel sze gm ens ei. A N 8 ( 7 : 0 ) 8 b i t A kie gés zít ő pa nel kiv ála szt ó jel ei. M C L K - A Cl oc k_ div ide be me net e. 50 Mh z- es óra jel U- btn

Négybites CPU tervezés P 3. Le ny om ása kor a ren dsz er óra jel ma gas ért ék ű les z D- btn O 2. WLe N ny om ása kor a ren dsz er óra jel ala cso ny ért ék ű les z O- btn C 1. L Le K ny _ om E ása N kor a ren dsz er óra jel 10 Hz, ell en kez 95

Négybites CPU tervezés 96 ő ese tbe n az UP /D O W N R S T - btn 0. Re nds zer ala pál lap otb a hel yez ése. Mi nd en szá ml áló t tör öl. S W ( 7 : 0 ) 8 b i t 8d b ka pcs oló be me net. S W( 3:0 ) az inp ut0 és S W( 7:4 ) az inp ut1 ada tbe

Négybites CPU tervezés me net e a CP U- na k. L4LE E D Db ki ( i me 3t net :. 0 FL ) A G- ek bit ek és óra jel kij elz ése. LE D( 0): O VF ; LE D( 1): CA RR Y; LE D( 2): ZE RO ; LE D( 3): clo ck 5.4. Kimeneti regiszterek, memória, ugró utasítás A processzor két kimeneti regiszterrel rendelkezik (out0, out1). Ezek a négybites regiszterek az A regiszterből kaphatnak értéket. A kimeneti értékek tárolásához FD4CE tárolót használjon. A megfelelő kimeneti regiszter kiválasztása és az értékadás engedélyezése az OEN vezérlőbitekkel történik. A két kimeneti regiszter értékének kijelzőkön való megjelenítése megjelenítése a Bin_to_7_segment_x4 makróval történik a következő táblázatnak megfelelően. 5.9. táblázat - Kijelzők portkiosztása 97

Négybites CPU tervezés 98 B e m e n e t J e l i n _ A A o u t ( 3 : 0 ) i n _ B B o u t ( 3 : 0 ) i n _ C O u t 0 i n _ D O u t 1 5.12. ábra - A processzor blokkvázlatának részlete

Négybites CPU tervezés A processzor az adatok tárolására adatmemóriát (RAM32X4S 1 ) használ (Harvard architektúra). Az A regiszter értékét, az utasításban megadott című memóriarekeszbe lehet tölteni, vagy a megcímzett memóriarekesz értékét ki lehet olvasni. A memória 32 darab 4 bites adatot tud tárolni. A címzését az utasítás operandusának megfelelő része adja. Írás az MWE vezérlőjel logikai egyes értéke esetén történik. Oldja meg, hogy az mwe=1 jel esetén az A regiszter értéke töltődjön be a memória utasításban megadott című rekeszébe. Memóriából regiszterbe töltés (rekesz kiolvasása) az mwe=0 jel és az A és B regiszter bemenetét adó multiplexer megfelelő vezérlésével érhető el. Az ALU kimeneti jelzőbitjei (flag-ek) az A és B regiszter változása esetén módosulhatnak. Egy FD4CE tárolóval oldja meg, hogy a jelzőbitek mindig az utolsó ALU művelet eredményét mutassák (ALU műveletnek tekintjük, ha az A és B regiszterek bemenetére az ALU kimeneti értéke kerül). Normál esetben az utasítás számláló minden utasítás után eggyel növekszik. Ugró utasítás esetén a program végrehajtását az utasításkódban megadott címtől kell folytatni (INSTR(7:0)). Ehhez az utasításszámlálót a következő ciklus előtt módosítani kell. Az ugróutasítás lehet feltétel nélküli, vagy feltételes. Feltétel nélküli ugrás esetén mindenképpen megváltozik az utasításszámláló értéke. A feltételes ugrásnál az ugrás bekövetkezése feltételhez kötött. A feltételeket az ALU Z (zero), C (carry), O (overflow) jelzőbitjei szolgáltatják. Az ugró utasítás előtti ALU művelet módosítja a jelzőbitek értékét, és ennek függvényében az ugróutasítás vagy bekövetkezik (ekkor módosul a PC az utasításban megadott címre), vagy nem következik be (ekkor a PC értéke eggyel növekszik). 5.10. táblázat - Ugró utasítások UF U t e g al r st ó í éut t t a áesí sl k ó d B r 2, B r 1, B r 0 0 0 0 tá s b e k ö v et k e z é s e N in c s u g rá s 1 RAM32X4S: A memória rendelkezik külön adatbemeneti és külön adatkimeneti porttal. Órajel hatására olvasás mindig, de írás csak egy külön engedélyező jel (WE) hatására történhet. WE memóriába írás engedélyezése, D adatbemenet, A cím, O adatkimenet, WCLK adat kiolvasása a memóriából, és adat beírás, ha WE=1. 99

Négybites CPU tervezés 100 0 0 1 h a Z = 1 U g rá s fe lt ét el te lj e s ül t h a Z = 0 N i n c s u g r á s 0 1 0 h a Z = 1 N in c s u g rá s h a Z = 0 U g r á s f e l t é t e l t e l j e s ü l t......... 1 1 1 U g rá s fe lt ét el

Négybites CPU tervezés te lj e s ül t 5.13. ábra - A mintaprogram mnemonikjai és utasításkódjai 5.14. ábra - Ki-bemeneti egységek 101

Négybites CPU tervezés A szimuláció után próbálja meg letölteni a kapcsoláshoz tartozó konfigurációs fájlt az FPGA-ba és ellenőrizze a működést. A LED-eken az utolsó ALU művelet eredményét jelző FLAG bit értékeket és az órajelet jelenítse meg. 5.11. táblázat - Portkiosztás PBLeí ourás r s t z n é v S84db E hét Gb sze 4i gm ( t ens 7 es : kije 0 lző ) sze gm ens ei. 102

Négybites CPU tervezés 103 A N 4 ( 3 : 0 ) 4 b i t 4db hét sze gm ens es kije lző kiv ála szt ó jele i. S E G 8 ( 7 : 0 ) 8 b i t A kie gés zítő pan el sze gm ens ei. A N 8 ( 7 : 0 ) 8 b i t A kie gés zítő pan el kiv ála szt ó jele i. M C L K - A Clo ck_ div ide be me net e. 50 Mh z- es óra jel U P - btn 3. Le nyo má sak or a

Négybites CPU tervezés ren dsz er óra jel ma gas érté kű les z D- btn O 2. WLe N nyo má sak or a ren dsz er óra jel ala cso ny érté kű les z O- btn C 1. L Le K nyo _ má E sak N or a ren dsz er óra jel 10 Hz, elle nke ző ese tbe n az UP /D O W N R- btn S 0. T Re 104

Négybites CPU tervezés 105 nds zer ala páll apo tba hel yez ése. Mi nde n szá mlá lót tör öl. S W ( 7 : 0 ) 8 b i t 8db kap cso lób em ene t. SW (3: 0) az inp ut0 és SW (7: 4) az inp ut1 ada tbe me net e a CP U- nak. L E D ( 3 : 0 ) 4 b i t LE D ki me net. FL AG -ek bite k és óra jel

Négybites CPU tervezés kije lzé se. LE D( 0): OV F; LE D( 1): CA RR Y; LE D( 2): ZE RO ; LE D( 3): clo ck 5.5. Programkód írás A laborgyakorlaton az előző órák során elkészült négybites CPU-ra saját programot kell készíteni. A processzor INST_MEM nevű utasításmemóriájának kezdeti tartalmát egy VHDL fájl (INST_MEM.vhd) írja le. A fájlban lehetőség van kézzel átírni az egyes rekeszek értékét egy megadott utasítás hexadecimális kódjára. Ezáltal szerkeszthetőek a processzor utasításmemóriájában lévő utasítások. A programkód készítésének egyszerűbb módja, ha az utasításokat azok memonikjaival adjuk meg, majd az így leírt programot egy fordító gépi kódra fordítja le. A laborgyakorlat során a dt4bit_cpu_assembler nevű program (5.15. ábra) segítségével készíthetjük el a forráskódot, fordíthatjuk le gépi kódra és cserélhetjük ki az utasításmemória alapértelmezett tartalmát. Miután az utasításmemória (INST_MEM.vhd) tartalma megváltozott, az ISE WEBPACK szoftver segítségével újra le kell fordítani a projektet, és lehetőség van a szimulációra, vagy az FPGA-ra való letöltésre. Az így letöltött CPU konfigurációs fájl, már az új programkódot tartalmazza. A Szerkesztő felület-en van lehetőség a program forráskódjának szerkesztésére, ide kell leírni az utasításokat. A fordító számára elérhető utasítások az Elérhető utasítások listája nevű részben található. A szerkesztő felületen csak a következő karakterekhasználhatóak: az angol ABC kisbetűi (a..z), számjegyek (0 9), kettőspont, címke megadására (:), tabulátor az utasítások tagolására (TAB), enter a sorok elválasztására (ENTER). Egy sor tagolása a következő kell, hogy legyen: A címkét és az argumentumot nem kötelező megadni. Ha az utasítás nem tartalmaz argumentumot, akkor az utasítás után új sort kell kezdeni. Ha a sor címkét nem tartalmaz, akkor a sort tabulátorral kell kezdeni, egyébként a címkének kettősponttal megadva kell a sor elején szerepelnie. A címke hossza maximum 3 karakter lehet a kettőspontot nem számolva. Az egyes részeket (címke, utasítás, argumentum) tabulátorral kell elválasztani egymástól. A Forrásfájl műveletek-nél lehetőség van a forráskód elmentésére, vagy egy már meglévő program betöltésére. 106

Négybites CPU tervezés 5.15. ábra - Fordító program felépítése A Fordítási opciók terület két gombot tartalmaz, az egyik a Szintaktikai ellenőrzés, ilyenkor a szerkesztőfelületen elkészült programnak a szintaktikai ellenőrzése történik meg. Az esetleges hibaüzenetek a Fordítási üzenetek panelen jelennek meg. Amennyiben szintaktikai hibát vétettünk, a hibaüzenetre kattintva a fordító megjelöli a hibás sort (5.17. ábra). A Fordítási eredmények panelen az utasítások programmemóriában elfoglalt helye, az utasítás és az utasítás hexadecimális kódjalátható. A Fordítás gombot választva először egy szintaktikai elemzés fut le, és ha nem volt szintaktikai hiba a programkódban, a fordító az utasításmemória (INST_MEM.vhd) tartalmát kicseréli az aktuális programkódra. Ebben az esetben a "Szintaktikai ellenőrzés és Fordítás kész!" üzenetet kapjuk. Első feladatként indítsa el a projektkönyvtárban található assemblerdtcpu4.exe fájlt. Nyissa meg a prog/example_for.txt fájlt (5.16. ábra). A példaprogram egy for ciklust valósít meg. Az első utasítások az input0 bemenet értékét olvassák be, majd az out0 kijelzőt nulla értékre állítják be. Végül az out0 értéke addig fog növekedni, amíg eléri az input0-ról beolvasott értéket. Fordítsa le a programot, majd az ISE WEBPACK szoftver segítségével készítse el az FPGA-ra letölthető konfigurációs fájlt, és töltse le az FPGA fejlesztőpanelre. Figyelje meg a program működését. 5.16. ábra - Mintaprogram for ciklusra 107

Négybites CPU tervezés A programrészlet c szintaktikai megfelelője: vhd-6. ábra -../sections/src/codefor.vhd 5.17. ábra - Mintaprogram for ciklusra, hibaüzenettel 108

Négybites CPU tervezés 109

II. Könyv. rész - Gadgeteer

Tartalom 6.... 112 6.1. Kiknek szól a tananyag?... 112 6.2. Miért.NETGadgeteer?... 112 6.3. Szükséges előismeretek... 112 7. Bevezetés a.net Gadgeteer használatába... 113 7.1..NET Gadgeteeralkalmazások készítéséhez szükséges eszközök... 113 7.2. FEZ Spider Starter Kit... 113 7.3. A FEZ Spider demóapanel használata... 116 7.4. Jelölések a demópanelen... 116 7.5. Jelölések a próbamodulokon... 117 7.6. A demópanel csatlakoztatása PC-hez... 117 7.7. Egy egyszerű Gadgeteer program elkészítése... 118 7.8. Felkészülést segítő kérdések... 123 8. Stopper alkalmazás készítése.netgadgeteer-el... 125 8.1. A feladat célja... 125 8.2. A projekt létrehozása... 125 8.3. Az eszköz elkészítése... 126 8.4. Az program megírása... 128 8.4.8.4.1. Stopper osztály készítése... 128 8.4.8.4.1.8.4.1.1. A főprogram elkészítése... 132 8.5. A program futtatása... 134 8.6. Felkészülést segítő kérdések... 134 9. Fényerő szabályozó lámpa érintő kapcsoló.netgadgeteer használatával... 135 9.1. A feladat célja... 135 9.2. A projekt létrehozása... 135 9.3. A program megírása... 136 9.4. A teljes forráskód... 141 9.4.9.4.1. Felkészülést segítő kérdések... 143 10. SD kártya olvasó.net Gadgeteer használatával... 144 10.1. A feladat célja... 144 10.2. A projekt létrehozása... 144 10.3. A program megírása... 145 10.4. A teljes forráskód... 152 10.5. Felkészülést segítő kérdések... 154 10.6. Felhasznált irodalom... 154 111

6. fejezet - 6.1. Kiknek szól a tananyag? A tananyag minden olyan hallgatónak tapasztalatot nyújthat, aki érdeklődik a beágyazott rendszerek iránt, programozási tudását és tapasztalatait kipróbálná egy olyan eszközön, mely merőben más egy megszokott asztali PC-hez, vagy egy mobileszközhöz képest.a Gadgeteer alapú alkalmazások fejlesztése objektumorientáltan, magasszintű programozási nyelven (C#) történik, így alkalmazkodik napjaink trendjéhez. Minden fejezet úgy került kialakításra, hogy lépésről lépésre vezesse be a hallgatókat a beágyazott rendszerek programozásának világába. A feladatokban szereplő eszközök összeállításához nem szükségesek mély elektronikai ismeretek, így a kizárólag programozási ismeretekkel rendelkező hallgatók is egyszerűen elvégezhetik azokat. 6.2. Miért.NETGadgeteer? A.NETGadgeteer újdonság a beágyazott rendszerek világában.a.net alapú szoftverfejlesztés lehetővé teszi, hogy ne kelljen alacsonyszintű, nehézkes programozási nyelvekkel végezni az alkalmazásfejlesztést. A.NETGadgeteer kompatibilis FEZ Spider Starter Kit olcsón beszerezhető és tartalmazza mindazon modulokat, melyek segítségével az alapvető tudás elsajátítható. A fejlesztést támogató SDK a Microsoft Visual Studio 2010 (és 2012) verzióját támogatja. Ennek segítségével gyorsan és egyszerűen lehet alkalmazásokat készíteni az asztali PC-knélmegszokott módon. A fejlesztőkörnyezet Express Edition változata bárki számára ingyenesen letölthető. 6.3. Szükséges előismeretek A.NETGadgeteer alkalmazásfejlesztéshez elsősorban programozási előismeretek szükségesek. A kidolgozott tananyag feltételezi, hogy a hallgatók rendelkeznek az objektumorientáltsággal kapcsolatos alapismeretekkel és a C# programozási nyelv alapjaival.ezen ismeretek mellett előnyt jelent, ha a hallgatónak vannak elektronikai, vagy beágyazott rendszerekkel kapcsolatos ismeretei is. 112

7. fejezet - Bevezetés a.net Gadgeteer használatába A Microsoft.NET Gadgeteer egy nyílt forrású eszközkészlet, melynek segítségével kisméretű elektronikus eszközökön futtatható,.net Micro Framework alapú alkalmazások készíthetők Visual Studio használatával. 7.1..NET Gadgeteeralkalmazások készítéséhez szükséges eszközök Hardver: Demópanel (pl.: Fez Spider, Fez Hydra, Sytech NANO) Piros modul (USBClientDP), mely táplálja a demópanelt és lehetővé teszi a program feltöltést, illetve hibakeresést Próbamodulok teszteléshez (pl.: különféle szenzorok, megjelenítők, tárolók, hálózati eszközök, stb.) Szoftver: Visual Studio 2010 (vagy az ingyenes Visual C# 2010 Express).NET Micro Framework SDK Ademópanelhez szükséges illesztőprogramok és egyéb szoftverek (gyártónként eltérő) 7.2. FEZ Spider Starter Kit A FEZ Spider Starter Kitegy NET Gadgeteer kompatibilis fejlesztőkészlet.ademópanelen és a piros modulon kívül számos próbamodult is tartalmaz. A fejlesztőkészlet tartalma: FEZ Spider demópanel T35 kijelző modul (3.5" méret, érintőképernyő) USB kliens DP modul (piros modul) Kamera modul 2 db Multicolor LED modul 2 db nyomógomb modul J11D Ethernet modul SD kártya modul USB Host modul Bővítő modul Josytick modul Szalag kábelek 7.1. ábra - FEZ Spider Starter Kit 113

Bevezetés a.net Gadgeteer használatába A FEZ Spiderdemópanel a GHI Electronics EMX moduljára épül. A.NET Micro Framework támogatáson kívül lehetővé teszi az USB és WiFi eszközök kezelését, valamint az ún. RLP (natív kód) használatát is. 7.2. ábra - FEZ Spider demópanel A demópanel jellemzői: 114

Bevezetés a.net Gadgeteer használatába 14.NET Gadgeteer kompatibilis csatlakozó aljzat a következő jelölésekkel: X, Y, A, C, D, E, F, H, I, K, O, P, S, T, U, R, G, B, Z. Konfigurálható LED-ek Konfiguráló kapcsolók EMX modul: 72MHz 32-bit ARM7 processzor 4.5 MB Flash memória 16 MB RAM LCD vezérlő TCP/IP Stack SSL, HTTP, TCP, UDP, DHCP támogatással Ethernet, WiFi meghajtó és PPP (GPRS/ 3G modemekhez), illetve DPWS USB hoszt USB eszköz specializált könyvtárakkal különféle eszközök emulálásához, pl.: thumb-drive, virtual COM (CDC), egér, billentyűzet 76 GPIO Pin 2 SPI (8/16bit) I2C 4 UART 2 CAN busz 7 10-bit Analóg Bemenet 10-bit Analóg Kimenet (WAV audio visszajátszáshoz) 4-bit SD/MMC memóriakártya interfész 6 PWM Egyvezetékes interfész Beépített Valós Idejű Óra (RTC) Processzor regiszter elérés Kimeneti komparátor hanghullámok létrehozásához RLP natív kód támogatás (C/Assembly) valósidejű programozáshoz Matematikai osztály kétszeres pontosságú számításokhoz FAT Fájlrendszer Kriptográfia támogatás (AES és XTEA) Alacsony fogyasztási és hibernált mód támogatása Frissítés SD kártyáról, hálózatról, vagy más forrásból 115

Bevezetés a.net Gadgeteer használatába 7.3. A FEZ Spider demóapanel használata A FEZ Spider demópanel 14 db aljzattal rendelkezik a próbamodulok illesztéséhez, melyek körül megtalálható azok sorszáma és egy karaktersorozat. E sorozat határozza meg a csatlakoztatható modultípusokat. A demópanelen elhelyezett Reset gomb segítségével bármikor újraindítható az eszköz. A bekapcsolt állapotot a D1 jelzésű LED mutatja. Az USB Client Dual Power modul, ( piros modul ) táplálja árammal a demópanelt és a csatlakoztatott eszközöket USB bemeneten keresztül, vagy egy 7-30 voltos DC adapter segítségével. Szintén ezzel az eszközzel csatlakoztatható PC-hez a demópanel(usb interfészen keresztül) program feltöltés, illetve hibakeresés céljából (ebben az esetben a tápellátás és a programozás is egyazon bemeneten történik). 7.3. ábra - "Piros modul" A piros modul egyetlen aljzattal rendelkezik, melynek D jelölése van, ezért a demópanelen kizárólag a vele egyező D jelölésű aljzattal párosítható! 7.4. Jelölések a demópanelen A demópanelen és a modulokon található aljzatokat különféle címkékkel látták el az egyszerű kezelhetőség érdekében. E jelölések határozzák meg, hogy mely eszközök kapcsolhatók össze egymással. Minden egyes aljzat körül található egy szám egyértelmű azonosítás céljából, valamint karakterek bizonyos sorozata az elektronikus és kommunikációs csatlakoztathatóság meghatározásához. 7.4. ábra - Csatlakozó aljzat a demópanelen 116

Bevezetés a.net Gadgeteer használatába 7.5. Jelölések a próbamodulokon A próbamodulokon szintén egy karaktersorozattal jelölik, hogy azok mely aljzatokkal párosíthatók. Az ábrán látható XY címkéjű modul például X vagy az Y jelöléssel rendelkező aljzathoz kapcsolható a demópanelen (tehát elég az egyik karakternek egyeznie). 7.5. ábra - Csatlakozó aljzat a próbamodulon Előfordulhat, hogy egyes modulok csak bizonyos funkciókat használnak, a panelen találhatótovábbikarakterek által jelzett szolgáltatást pedig nem. A csatlakoztatás során mindig ügyelni kell arra, hogy a megfelelő címkével rendelkező csatlakozó felületeket párosítsuk. 7.6. A demópanel csatlakoztatása PC-hez A piros modult a FEZ Spider 1-es csatlakozójához kell kapcsolni (az egyetlen aljzat, mely D jelzéssel rendelkezik). A készlethez mellékelt USB kábelt csatlakoztassuk a piros modulhoz, de annak másik végét még ne kapcsoljuk a PC-hez. 7.6. ábra - Demópanelhez kapcsolt piros modul 117

Bevezetés a.net Gadgeteer használatába Ezt követően lehet a demópanelhez kapcsolni a különböző próbamodulokat szalagkábelek segítségével, mindegyiket a megfelelő aljzat kiválasztásával. Amint a művelettel végeztünk, a demópanel áram alá helyezhető az USB kábel segítségével és elkezdhető annak programozása. Figyelem!!! A próbamodulok csak a kikapcsolt demópanelhez csatlakoztathatók, vagy távolíthatók el abból! 7.7. Egy egyszerű Gadgeteer program elkészítése Előkészületek: 1. Győződjünk meg róla, hogy a demópanel nincs-e áram alatt 2. A Starter Kit-ből válasszunk ki egy Button(nyomógomb) és egy Multicolor LED modult A nyomógomb modul hátoldalán XY jelölés található, ami azt jelenti, hogy a demópanelen olyan aljzatba kell csatlakoztatni az eszközt, melynek címkéje tartalmaz X vagy Y karaktert (pl. az 5-ös aljzat). Hasonlóképpen kell a LED modult is bekötni (pl. a 6-os aljzatba).a demópanelt ezután csatlakoztathatjuk a számítógéphez. Indítsuk el a Visual Studio 2010-et, majd kattintsunk a File/New/Project menüpontra. 7.7. ábra - Új projekt létrehozása A felugró ablakbanbaloldaltválasszuk az Installed Templates listából a Gadgeteer sablont. Ekkor felkínálásra kerül egy új NET Gadgeteer Application az ablak közepén, melynek neve megadható a Name adatmezőnél, vagy elfogadható a felajánlott változat (jelen esetben GadgeteerApp1 ). Kattintsunk az OK gombra. 7.8. ábra - A létrehozni kívánt Gadgeteer projekt opciói 118

Bevezetés a.net Gadgeteer használatába Előfordulhat, hogy az újonnan létrehozott projekt alapesetben egy FEZ Hydratípusúdemópanelt tartalmaz. 7.9. ábra - A létrehozott Gadgeteer projekt 119

Bevezetés a.net Gadgeteer használatába Mivel nekünk FEZ Spider típusú a demópanelünk, ezért csere szükséges. Jelöljük ki a FEZ Hydra-t, majd nyomjuk meg a Del billentyűt. Az eszközkészletből ( Toolbox ) húzzunk be egy FEZ Spider típusú panelt a grafikus tervezőbe. 7.10. ábra - A demópanel csere után A fordítónak is ismernie kell az összeállított demópanel konfigurációt, ezért a grafikus tervezőben meg kell jelölni, hogy az egyes aljzatokba milyen eszközök kerültek bekötésre. Ezt a Toolbox-ban elhelyezett próbamodulok elhelyezésével kell elvégezni.drag and drop technikával húzzunk a grafikus tervezőbe egy Button és egy Multicolor LED komponenst. 7.11. ábra - Próbamodulok a grafikus tervezőben 120

Bevezetés a.net Gadgeteer használatába Az egyes alkatrészek szabadon mozgathatók a tervezőben az átláthatóság javításának céljából (fizikai szerepe nincs). Az alkatrészek aljzatokba történő bekötéséhez először jelöljük ki kattintással a bekötni kívánt Button alkatrész csatlakozóját (sárga rész), majd a program által felajánlott kompatibilis aljzatok közül (zölden jelölt) a bal-egérgomb megnyomásával válaszuk ki az 5-ös aljzatot (a demópanelen ugyanis ide kötöttük be a nyomógombot). A sikeres bekötést kék színű vonal jelöli. 7.12. ábra - A demópanelra bekötött nyomógomb Hasonlóképpen kössük be a led komponenst is a 6-os aljzatba! 7.13. ábra - A bekötött alkatrészek Ezt követően a hardver konfiguráció a fordító számára is ismert lesz és elkezdhető a programkód írása. Kattintsunk duplán a Solution Explorer ablakban található Program.cs fájlra. 7.14. ábra - A programkódot tartalmazó fájl kiválasztása 121

Bevezetés a.net Gadgeteer használatába A megjelenő ablakban bővíthetjük és módosíthatjuk a Gadgeteer sablon által létrehozott program keretet. A program indításakor a ProgramStarted() metódus fut le először. using System; using System.Collections; using System.Threading; using Microsoft.SPOT; using Microsoft.SPOT.Presentation; using Microsoft.SPOT.Presentation.Controls; using Microsoft.SPOT.Presentation.Media; using Microsoft.SPOT.Touch; using Gadgeteer.Networking; using GT = Gadgeteer; using GTM = Gadgeteer.Modules; using Gadgeteer.Modules.GHIElectronics; 122

Bevezetés a.net Gadgeteer használatába namespace GadgeteerApp1 { public partial class Program { void ProgramStarted() { Debug.Print("Program Started"); } } } A programot az alábbi módon egészítsük ki: public partial class Program { void ProgramStarted() { button.buttonpressed += new Button.ButtonEventHandler(button_ButtonPressed); Debug.Print("Program Started"); } void button_buttonpressed(button sender, Button.ButtonState state) { led.blinkrepeatedly(gt.color.red); } } A módosításokat követően nyomjuk meg az F5 billentyűt. Ennek hatására megtörténik a fordítás és a programkód feltöltésre kerül az eszközre, mely újraindul, majd futtatja az elkészített alkalmazást (a feltöltés és újraindítás hosszabb ideig is eltarthat). A program a nyomógomb megnyomását követően piros színnel, folyamatosan villogtatja a csatlakoztatott LED-et. A futtatás során a hibakereső folyamatosan fut, ezért csak akkor tudunk további módosításokat végezni, ha a Shift+F5 billentyűkombinációval bezárjuk azt (ettől még az eszközön tovább fut a program). 7.15. ábra - a program futtatás közben 7.8. Felkészülést segítő kérdések 123

Bevezetés a.net Gadgeteer használatába Milyen eszközök szükségesek.net Gadgeteer alkalmazások készítéséhez? Mi a szerepe a demópanelen, illetve a próbamodulokon elhelyezett jelöléseknek (címkék)? Milyen lépéseket kell elvégezni egy új Gadgeteer projekt létrehozásához? Mire való a ProgramStarted() metódus? 124

8. fejezet - Stopper alkalmazás készítése.netgadgeteer-el 8.1. A feladat célja A feladat célja egy egyszerű stopper alkalmazás készítése: Az időmérés egy nyomógomb segítségével indítható. Ha eztelindították, a gomb másodszori megnyomásával a művelet leállítható, és az eltelt idő leolvasható a grafikus kijelzőn. A gomb harmadszori megnyomásával a mért idő rögzítésre kerül, majd a stopper újraindul. A kijelzőn megjelenítésre kerül az elmúlt három időmérés eredménye. 8.2. A projekt létrehozása Indítsuk el a Visual Studio 2010 fejlesztőkörnyezetet, majd hozzunk létre egy új projektet (File/New/Project ): 8.1. ábra - Új projekt létrehozása A megjelenő ablakban válasszuk a.net GadgeteerApplication sablont a felkínált elemek közül. A projekt neve ( Name ) legyen Stopper. 8.2. ábra - Projekt tulajdonságainak beállítása 125

Stopper alkalmazás készítése.netgadgeteer-el 8.3. Az eszköz elkészítése A vizuális tervezőben hozzuk létre a stoppert reprezentáló eszközt a következő modulokból: Fez Spider próbapanel Button (nyomógomb) Display_T35 (érintőképernyős kijelző) A fejlesztőkörnyezet képes meghatározni, hogy a demópanelen melyik aljzathoz csatlakozzanak az egyes eszközök. A vizuális szerkesztő ablakában nyomjuk meg a jobboldali egérgombot, majd a felugró menüből válasszuk a Connectallmodues lehetőséget. 8.3. ábra - Stopper készülék tervező nézetben 126

Stopper alkalmazás készítése.netgadgeteer-el Ezt követően készítsük el a stopper készüléket az ábrának megfelelően. Ügyeljünk arra, hogy a készülék még ne legyen csatlakoztatva a PC-hez, illetve ne legyen áram alatt. A szükséges modulok: Piros modul FEZ Spider demópanel Nyomógomb Érintőképernyős kijelző 127

8.4. Az program megírása Stopper alkalmazás készítése.netgadgeteer-el 8.4.8.4.1. Stopper osztály készítése Készítsünk egy Stopper osztályt, az időmérésre szolgáló eszköz reprezentálásához. Az osztályt egy új kódfájlban definiáljuk. Ennek létrehozásához a jobb-egérgombbal kattintsunk a Stopper projekt ikonján, majd válasszuk ki az Add/New Item opciót. 8.4. ábra - Új elem létrehozása a projektben A megjelenő ablakban válasszuk a Class opciót, névnek ( Name ) adjuk a következőt: Stopper.cs. 8.5. ábra - Új osztály hozzáadása a projekthez 128

Stopper alkalmazás készítése.netgadgeteer-el Az Add gombra kattintva létrejön az új kódfájl a Stopper osztály definíciójával: 8.6. ábra - Az új kódfájlban elhelyezett osztálydefiníció A stopper állapotának reprezentáláshoz szükséges egy StopperStatus nevű enum. Két állapot vehet fel az eszköz: Started: a stopper elindított állapotban van 129

Stopped: a stopper leállított állapotban van A forrásfájlt bővítsük az enum definícióval: Stopper alkalmazás készítése.netgadgeteer-el public enum StopperStatus { Started, Stopped } A stopper osztályon belül vegyük fel a következő mezőket: public static readonly int TimerResolution = 100; public static readonly int BufferCapacity = 3; private Timertimer; public TimeSpan[] LastTimes { get; private set; } private int timeindex; public TimeSpanMeasuredTime { get; private set; } public StopperStatus Stopperstatus { get; private set;} public event EventHandlerStopperUpdated; Az időmérést egy időzítő (Timer) objektum végzi, mely periódikusan, megadott időközönként (TimerResolution) növeli ameasuredtime változót TimerResolution egységgel, illetve kiváltja a StopperUpdated eseményt. Ebből következik, hogy a mérőeszköz pontosságát is ez a változó határozza meg (jelen esetben 100 ms, azaz a mérési pontosság egytized másodperc). Az elmentett mérési eredmények a LastTimes tömbbe kerülnek. Az eltárolt eredmények számát a BufferCapacity nevű változó segítségével lehet beállítani. Ha a bejegyzések száma elérte a maximumot, akkor körbeforgó módszerrel elölről kezdődik az indexelés, melyhez a timeindex változó kerül felhasználásra. A stopper indításakor, illetve leállításakor állapotátmenet következik be. Az aktuális állapotot a StopperStatus mező tárolja. Készítsük el az inicializálást végző konstruktort: public Stopper() { LastTimes = new TimeSpan[BufferCapacity]; timer = new Timer(TimerResolution, Timer.BehaviorType.RunContinuously); timer.tick += new Timer.TickEventHandler(timer_Tick); StopperStatus = StopperStatus.Stopped; } Amennyiben az időzítő Tick eseménye bekövetkezik, a timer_tick metódus kerül meghívásra, ahol a mért időt egységnyivel növeljük, majd kiváltjuk a frissítést jelző eseményt: void timer_tick(timertimer) { MeasuredTime = MeasuredTime.Add(new TimeSpan(0, 0, 0, 0, TimerResolution)); OnStopperUpdated(); } A mért idő frissítését az OnStopperUpdated() metódus jelzi a StopperUpdated eseménykezelő meghívásával, ellenőrizve, hogy az eseményre történt-e feliratkozás: private void OnStopperUpdated() 130

Stopper alkalmazás készítése.netgadgeteer-el { } if (StopperUpdated!= null) { StopperUpdated(this, EventArgs.Empty); } A stopper állapotváltását metódusok szabályozzák: Start(): elindítja az időmérést, illetve újraindítja azt, ha már elindult Stop(): leállítja az időmérést 8.7. ábra - A stopper állapotátmenet diagramja Az egyszerűség kedvéért bevezetésre kerül egy NextState() nevű metódus is, mivel gombnyomás hatására mindig a következő állapotba kell lépni, és ez az objektum státusza alapján egyértelműen elvégezhető, így tehát nem kell kívülről lekérdezni az aktuális állapotot és ez alapján állapotot váltani. A fentiek tükrében folytassuk az implementációt: public void Start() { MeasuredTime = new TimeSpan(); timer.start(); StopperStatus = StopperStatus.Started; } public void Stop() { timer.stop(); StopperStatus = StopperStatus.Stopped; } public void NextState() { switch (StopperStatus) { case StopperStatus.Started: SaveMeasuredTime(); Stop(); break; case StopperStatus.Stopped: Start(); break; default: break; } } A mért idő tárolását a SaveMeasuredTime() nevű metódus végzi: 131

Stopper alkalmazás készítése.netgadgeteer-el private void SaveMeasuredTime() { LastTimes[timeIndex++ % BufferCapacity] = MeasuredTime; } A LastTimes nevű tömb soron következő elemébe kerül beírásra az aktuálisan mért idő (MeasuredTime). A maradékos osztás biztosítja a körbeforgó indexelést. Az idő típusú változók megjelenítéséhez szükséges azok karakterlánccá konvertálása. A.NET Micro Framework nem tartalmaz Format() metódust, és a tostring() metódus sem alkalmas erre a feladatra, ezért egy sajátkészítésű Format() metódus szükséges, mely hasonló funkciót lát el: public string Format(TimeSpan timespan) { string formattedstring = String.Empty; formattedstring = WithLeadingZero(timeSpan.Minutes) + ":" + WithLeadingZero(timeSpan.Seconds) + "." + timespan.milliseconds / 100; return formattedstring; } Ez a metódus visszatérési értékként a paraméterben megadott idő perc, másodperc, és ezredmásodperc értékét szolgáltatja szöveges formában. Mivel a megjelenítés így nem hasonlít a hagyományos stoppereknél megszokott vezető-nullás megjelenítéshez, ezért szükség van még egy segédmetódusra, amely a megadott számot string-é konvertálja, és ha szükséges vezető-nullával látja el: private string WithLeadingZero(int number) { if (number< 10) { return "0" + number.tostring(); } else { return number.tostring(); } } A mért idő grafikus megjelenítéséhez készítsünk egy GetTimeText() nevű metódust: public string GetTimeText() { return Format(MeasuredTime); } Ezzel elkészült a Stopper osztály. A példányosított objektum szolgáltatásaita főprogramban használjuk fel. 8.4.8.4.1.8.4.1.1. A főprogram elkészítése A Progam osztály feladata a stopper vezérlése felhasználói interakciók alapján, illetve a grafikus megjelenítés. Az alkalmazás készítését ebben az osztályban kell folytatni (Program.cs fájl). Definiáljuk a következő mezőket: public static readonly GT.ColorMeasuredTimeColor = GT.Color.Red; 132

Stopper alkalmazás készítése.netgadgeteer-el public static readonly GT.ColorLastTimesColor = GT.Color.White; private Stopper stopper; private Bitmap bitmap; A sablon által létrehozott ProgramStarted() metódust bővítsük az alkalmazás inicializálásához szükséges hívásokkal: void ProgramStarted() { stopper = new Stopper(); stopper.stopperupdated += new EventHandler(stopper_StopperUpdated); button.buttonpressed += new Button.ButtonEventHandler(button_ButtonPressed); bitmap = new Bitmap((int) display.width, (int) display.height); UpdateUI(); } Az stopper indítása, illetve annak megállítása az eszközhöz csatlakoztatott gomb megnyomásával történik. Az interakció kezeléséhez a button.buttonpressed eseményre való feliratkozáskor megadott button_buttonpressed metódus implementálása szükséges. voidbutton_buttonpressed(buttonsender, Button.ButtonState state) { stopper.nextstate(); UpdateUI(); } Amennyiben a stopper által mért idő frissül, a StopperUpdated esemény bekövetkezik és végrehajtásra kerül a stopper_updated metódus, mely a felhasználói felület frissítését végzi: void stopper_stopperupdated(objectsender, EventArgs e) { UpdateUI(); } A frissítés során meg kell jeleníteni az aktuálisan mért időt és a rögzített időket. A rajzolás a bitmap objektum által szolgáltatott bitképre történik, majd az így elkészült kép megjelenítésre kerül a kijelzőn: private void UpdateUI() { string timetext = stopper.gettimetext(); Font font = Resources.GetFont(Resources.FontResources.NinaB); bitmap.clear(); bitmap.drawtext(timetext, font, MeasuredTimeColor, 0, 0); TimeSpan[] lasttimes = stopper.lasttimes; for (int i = 0; i <lasttimes.length; ++i) { bitmap.drawtext(stopper.format(lasttimes[i]), font, LastTimesColor, 0, ((i + 2) * font.height)); } display.simplegraphics.displayimage(bitmap, 0, 0); } 133

8.5. A program futtatása Stopper alkalmazás készítése.netgadgeteer-el A program futtatásához nyomjuk meg az F5 billentyűt és várjuk meg a program feltöltését az eszközre, mely újraindítást követően futtatja az elkészített alkalmazást. 8.8. ábra - Aprogram futtatás közben 8.6. Felkészülést segítő kérdések Mi a szerepe a Stopper osztálynak? Mire szolgál a StopperStatus típus? Mire használjuk a Timer-t és hogy működik? 134

9. fejezet - Fényerő szabályozó lámpa érintő kapcsoló.netgadgeteer használatával 9.1. A feladat célja A feladat célja megismertetni a.netgadgeteer eszköz T35-ös kijelzőjének és a többszínű ledjének működését. A feladathoz szükség lesz a FEZ Spider panelre, multicolorled modulra és a T35-ös kijelzőre. A program az elindulást követően a kijelző érintésére vár kikapcsolt világítással. A világítást a multicolor (többszínű) led imitálja. A kijelző érintésének hatására a led fényereje fokozatosan növekszik, miközben a fényerő százalékos értéke megjelenítésre kerül a kijelzőn. Másodszori lenyomásra a fényerő csökken, és így tovább. 9.2. A projekt létrehozása Első lépésként nyissunk meg a Visual Studio 2010-et, majd hozzunk létre egy új.netgadgeteerapplication-t: Fájl New Project Visual C# / Gadgeteer Adjunk nevet a projektnek (pl. Light_Switch ), illetve egy elérési utat. Az OK gomb megnyomása után a következő képernyő fog megjelenni: 9.1. ábra - A Visual Studio 2010 új.netgadgeteer projekt A program alapértelmezés szerint a FEZ Hydra panelt rakja ki, ezt le kell cserélni a Spider-re, hiszen azzal dolgozunk. Töröljük ki a Hydrát és a bal oldali toolbox alján lévő GadgeteerMainboards kategóriából válasszuk a FEZ Spider-t. A toolbox GHI Electronics kategóriájából húzzuk a képernyőre a következő elemeket: Display_T35 135

MulticolorLed Fényerő szabályozó lámpa érintő kapcsoló.netgadgeteer használatával A Spider alaplapjára kattintsunk jobb egérrel, majd a Connectallmodules -ra. Az összekapcsolt panelünknek így kell kinéznie: 9.2. ábra - az összekötött rendszer 9.3. A program megírása Az alapértelmezetten létrejön egy Program.cs nevű fájl, amibe a fejlesztőkörnyezet automatikusan egy programkódot generál. A kommentezést nyugodtan töröljük ki, a generált kód a következőképpen néz ki: namespace Light_Switch { public partial class Program { void ProgramStarted() { Debug.Print("Program Started"); } } } A Program nevű osztály az alkalmazás főosztálya, ezen belül a ProgramStarted() függvény indul el elsőként. Futtatásnál, a Debug.Print("Program Started") utasítás hatására a kimeneti ablakban (output window) megjelenik a felirat. A Program.cs fájlban találhatunk további sorokat. Ezek különböző osztálykönyvtár referenciák, amiket az alkalmazás használni fog. A példakódban külön nem jelöltem. Futtassuk a projektet! Ehhez az USB kliensbe (piros modul, ami az 1. portba van illesztve) csatlakoztassuk az USB kábel megfelelő végét, majd a másikat a PC egyik USB portjába. Az F5 gomb megnyomása után a program lefordul (build) és az eszközre feltöltődik (deploy). Amennyiben az előbbi folyamatok hiba nélkül lefutottak, a kimeneti ablakban megjelenik a Program Started felirat. A kijelző képernyője fekete és az 136

Fényerő szabályozó lámpa érintő kapcsoló.netgadgeteer használatával alapértelmezés szerinti gyári információkat írja ki (verzió, felbontás). Ennek az az oka, hogy még nincs használatban a modul. Egészítsük ki a programot, úgy, hogy képes legyen a led intenzitását egy adott értékre beállítani, és erről írásos információt adjon a kijelzőn keresztül! Ehhez először helyezzünk el egy változót a ProgramStarted() függvény előtti sorokba: byte lightintensity = 0; A lightintensity változó a fényerőt tárolja 0-255 érték között. Ha 0, akkor teljesen ki van kapcsolva, ha pedig 255 akkor pedig teljesen fel van kapcsolva a lámpa. Folytatólagosan (a ProgramStarted() függvény után) hozzunk létre két visszatérés nélküli függvényt: renderintensity() és setlightntensity(). void renderintensity() { display.simplegraphics.clear(); display.simplegraphics.displaytext("the light is on " + ((int)(lightintensity /2.55)).ToString() + "% power", Resources.GetFont(Resources.FontResources.NinaB), Colors.White, 50, 50); } voidsetlightintensity() { led.setblueintensity(lightintensity); led.setredintensity(lightintensity); led.setgreenintensity(lightintensity); } A renderintensity() függvény letörli a kijelzőt, és kiírja az aktuális fény intenzitást (lightintensity) százalékos formában. Például, ha a fényforrás teljesen fel van kapcsolva, ez a szöveg jelenik meg: "The light is on 100% power". A százalékot oly módon számoljuk ki, hogy a byte típusú lightintensity értéket elosztjuk 2.55-el, és integerré változtatjuk a típusát (typecast). A DisplayText metódus első paramétere ez a string lesz, a második a betűtípus, amelyet az erőforrásokból kell betölteni (Resources.FontResources.NinaB). Az ezt követő paraméterek a szöveg színe (fehér), és a képernyőre történő kiírás kezdő koordinátái (50,50). A setlightintensity() függvény beállítja az aktuális fény (led) intenzitást (lightintensity). A három színcsatornán azonos értéket kell beállítani. Ha mindegyik azonosan nulla, akkor a led nem ég, ha mindegyik azonosan 255, akkor a maximális erejű közel fehér fényt kapunk. Az additív színkeverés miatt, ha a színcsatornák értékei azonosak, akkor az azt jelenti, hogy a keletkező fény (megközelítőleg) fehér. A kapcsoló oly módon fog működni, hogyha először hozzáérünk, akkor a kikapcsolt fényforrás fényét folyamatosan növeli vagy a maximumig, vagy pedig amíg el nem engedjük. Ehhez definiálni kell egy irány típust (enum) és egy ilyen típusú változót. enum lightupdowndirection { up, down } lightupdowndirection lightdirection = lightupdowndirection.up; A lightupdowndirection típusnak két értéke van, az up és a down, amely a lámpa kapcsolás irányát mutatja. Kezdetben a lámpa ki van kapcsolva, így az irány up. A következő lépésben írjuk mega fényerő irányváltásért felelős programrészt. Ehhez szükség van további változókra: 137

byte previouslightintensity = 0; GT.Timertimer; int TimerResolution = 200; int timercount = 0; Fényerő szabályozó lámpa érintő kapcsoló.netgadgeteer használatával Amennyiben a fényerőváltozásnál nem a szélsőértékekről (0, 255) történik az irányváltás, szükséges eltárolni a megelőző állapotot (previouslightintensity), illetve amíg a kapcsolót nyomva tartjuk, egy 200ms felbontású (TimerResolution) időzítő (GT.Timertimer) segítségével tudjuk a fényerőváltást lekezelni, a timercount változóba pedig a lenyomás idejét összegezzük. Kicsivel később visszatérünk rájuk. A ProgramStarted() függvényen belül, a Debug.Print("Program Started"); sor alá írjuk be a következőt: display.simplegraphics.autoredraw = true; led.turnoff(); display.wpfwindow.touchdown += new Microsoft.SPOT.Input.TouchEventHandler(WPFWindow_TouchDown); display.wpfwindow.touchup += new Microsoft.SPOT.Input.TouchEventHandler(WPFWindow_TouchUp); display.wpfwindow.invalidate(); timer = new GT.Timer(TimerResolution); timer.tick += new GT.Timer.TickEventHandler(timer_Tick); A display.simplegraphics.autoredraw() metódus a képernyő automatikus újrarajzolását engedélyezi. A led.turnoff() utasítással kikapcsoljuk induláskor a ledet, így létrehozzuk a kezdeti állapotot. Ezután a kapcsoló (érintő kijelző) kezelését kell megoldani. Ez rendelkezik egy TuchDown és TuchUp, azaz egy kijelző megnyomva és elengedve eseménnyel. Erre az eseményre való feliratkozást valósítja meg a fenti kódrészlet. Érdemes úgy csinálni, hogy beírjuk a += karakterekig, majd két darab tab gombot nyomunk. Így a környezet legenerálja a kód többi részét, valamint az eseményt kezelő függvényt (WPFWindow_TouchUp, WPFWindow_TouchDown). Az invalidate() metódus érvényteleníti a kijelző tartalmát, ami ezáltal egy újra renderelést valósít meg. A new GT.Timer(TimerResolution) utasítással példányosításra kerül az időzítő, amelynek 200ms időnként kiváltódik a timer.tick() eseménye. void WPFWindow_TouchDown(object sender, Microsoft.SPOT.Input.TouchEventArgs e) { timercount = 0; timer.start(); } A WPFWindow_TouchDown függvény (érintőképernyő lenyomás) nullázza a nyomás idejét összegző timercount változót, és elindítja a timer időzítőt. voidwpfwindow_touchup(object sender, Microsoft.SPOT.Input.TouchEventArgs e) { timer.stop(); if (lightdirection == lightupdowndirection.up) lightdirection = lightupdowndirection.down; else lightdirection = lightupdowndirection.up; previouslightintensity = lightintensity; } A WPFWindow_TouchUp függvény (érintőképernyő elengedés) megállítja az időzítőt, valamint invertálja a lámpa kapcsolás irányát, és frissíti az előző fényintenzitás értékét az aktuális fényintenzitással. void timer_tick(gt.timer timer) { 138

} Fényerő szabályozó lámpa érintő kapcsoló.netgadgeteer használatával if (timer.isrunning) { int intensity; timercount += timer.interval.milliseconds; if (lightdirection == lightupdowndirection.up) intensity = (previouslightintensity + timercount / 10); else intensity = (previouslightintensity - timercount / 10); if (intensity>byte.maxvalue) { intensity = Byte.MaxValue; timer.stop(); } if (intensity<byte.minvalue) { intensity = Byte.MinValue; timer.stop(); } lightintensity = (byte)intensity; setlightntensity(); renderintensity(); } A timer_tick eseménykezelő függvény addig hívódik meg, ameddig nyomva tartjuk a kapcsolót (érintőképernyőt), és 200ms időközönként hívódik meg. Első feladat, hogy meg kell vizsgálni, valóban fut e még az időzítő (nyomva van-e a gomb ). A WPFWindow_TouchUp eseménykezelőben ugyan leállítjuk az időzítőt, de előfordulhat, hogy ezután még egyszer kiváltódik maga az Tick esemény. A timercount változóhoz hozzá kell adni az eltelt időt (timer.interval.milliseconds), majd ez alapján ki kell számítani a fényintenzitást (intensity) a kapcsolási iránynak megfelelően az előző intenzitást figyelembe véve. Ha a kiszámított intenzitás eléri, vagy meghaladja az egyik szélsőértéket, akkor határolni kell, illetve leállítani az időzítőt (mivel teljesen fel vagy le kapcsoltuk a lámpát). Ezek után a kiszámított intenzitást át kell adni a byte típusú lightintensity változónak, valamint utolsó lépésként frissíteni kell a fényforrás fényességét, és ki kell írni ugyanezt a kijelzőre a setlightntensity() és renderintensity() függvények segítségével. Az elkészült alkalmazásról néhány fénykép: 9.3. ábra - Teljesen kikapcsolt lámpa 139

Fényerő szabályozó lámpa érintő kapcsoló.netgadgeteer használatával 9.4. ábra - 7%-os kitöltésű lámpa 140