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ó

Created by XMLmind XSL-FO Converter.

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 Created by XMLmind XSL-FO Converter.

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 Created by XMLmind XSL-FO Converter.

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

v Created by XMLmind XSL-FO Converter.

144 145 152 154 154 155

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 Created by XMLmind XSL-FO Converter.

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 Created by XMLmind XSL-FO Converter.

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

viii Created by XMLmind XSL-FO Converter.

141 144 145 147 147 150 151 152

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 Created by XMLmind XSL-FO Converter.

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

x Created by XMLmind XSL-FO Converter.

48 48 48 48 48 48 48 52 52 53 53

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 Created by XMLmind XSL-FO Converter.

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


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.


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]


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]



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]



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





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ó http://www.xilinx.com/support/documentation/spartan-3.htm

a

gyártó


honlapján

érhető

el:


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



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]




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]


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



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






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



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



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.



• Add Bus Tap (

• Add I/O Marker (

• Add Symbol (

): Buszos vonalra csatlakozás hozzáadása.

): Be-, kimeneti pontok hozzáadása.

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



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



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



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 Created by XMLmind XSL-FO Converter.


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



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 Created by XMLmind XSL-FO Converter.


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 Created by XMLmind XSL-FO Converter.


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



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



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



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



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 Created by XMLmind XSL-FO Converter.


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



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 Created by XMLmind XSL-FO Converter.


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


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


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



4.4. ábra - Négy bemenetű multiplexer kapcsolási rajza



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



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



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 Created by XMLmind XSL-FO Converter.


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



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 Created by XMLmind XSL-FO Converter.


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



ABABABABABE 33221100GGQ 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 ABABABABAE 33221100GQ B 10xxxxxx10 ==10xxxx10 ====10xx10 ======1010 ========01

4.12. ábra - Magnitude Comparator egy áramköri megvalósítása



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 YYY 210 I 000 n 0 I 001 n 1 I 010 n 2 I 011 n 3 I 100 n



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 Created by XMLmind XSL-FO Converter.


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 OOOI nnnnnnnnuuuT 01234567t t t 210 xxxxxxx11111 xxxxxx101101 xxxxx1001011 xxxx10001001 xxx100000111 xx1000000101 x10000000011 100000000001 00000000xxx0

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 Created by XMLmind XSL-FO Converter.


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



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 ESSOOOO N10UUUU TTTT 3210 0000000 0010000 0100000 0110000 1000001 1010010 1100100 1111000

4.17. ábra - 4-ről 1-re dekóder blokkrajza



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 SSSSSSSSBBLL WWWWWWWWTTEE



01234567NNDD 0101 AAAABBBBEAEA 01230123QGQG i i oo nnuu tt


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



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



4.21. ábra - Teljes összeadó egy megvalósítása



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



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ó



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.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 Created by XMLmind XSL-FO Converter.


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 Created by XMLmind XSL-FO Converter.


• Másik lehetőség az ALU_out_mux1 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 A (i z ) ’ ＝A A ’ (i és ) ’ &B 1

A makró fájlok a mellékletben megtalálhatóak.



B ’ (i be ) m en et bi te n ké nt i É S ka pc so la ta 011Y A ( z 2 ’ : A 0 ’ ) be ＝m A en ( et 3 ro : tá 1 lá ), sa Y jo ( b 3 br ) a. = A ( 0 ) 100Y A (i z ) ’ ＝A A ’ (i és )| ’ B B (i ’ ) be m en et bi te n ké nt i 60 Created by XMLmind XSL-FO Converter.


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- 61 Created by XMLmind XSL-FO Converter.


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 ao kr r t ó( U C F f á j l 62 Created by XMLmind XSL-FO Converter.


) SB 0T , N S0 1, , B ST 2N 1 , B T N 2 AS ( W 3( : 3 0: ) 0 ) BS ( W 3( : 7 0: ) 4 ) AL LE UD _( O3 U: T0 ( ) 3 : 0 ) OL VE FD ( 5 ) CL AE RD R( Y6 ) ZL EE RD O(



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



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



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



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.



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 Created by XMLmind XSL-FO Converter.


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



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


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



• 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



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 AAAFLeí e e e urá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 ea ’B’ reg iszt er ki 73 Created by XMLmind XSL-FO Converter.


me net e 010RA Areg Miszt oere uk t be me net ea 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



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 SSSFLeí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



’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



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 Created by XMLmind XSL-FO Converter.


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 BBBFLeí 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 Created by XMLmind XSL-FO Converter.


cím re 011BAz RAL CU C flag -je ’1’, ugr ás az utas ítás utol só 8 bitj én me gad ott cím re 100BAz RAL NU CC flag -je ’0’, ugr ás az utas ítás utol só 8 bitj én me gad ott cím re 101BAz RAL OU O flag -je ’1’, ugr ás az utas ítás utol 79 Created by XMLmind XSL-FO Converter.


só 8 bitj én me gad ott cím re 110BAz RAL NU OO 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.



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 OOF Leí e nu 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 0 szte = r Aérté ke a 0. kim ene ti latc hbe ker ül 11o Az u ’A’ t regi 1 szte = r Aérté ke a 1. kim ene ti latc hbe ker ül



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



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



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í e e rás ml e n e t iP 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 3 kij : elz 0 őn ) i 0 Ut n0 asít _0 ás B me 1+ gje len I ítés Ne a S B, TC R és ( D 2 kij 0 elz 84 Created by XMLmind XSL-FO Converter.


) ő i I mo nNdul _S ok BT on 0R ( 1 9 : 1 6 ) iI nN _S CT 1R ( 1 5 : 1 2 ) iI nN _S CT 0R ( 1 1 : 8 ) iI nN _S DT 1R ( 7 : 4 ) iI nN _S DT 0R ( 3 : 0 )



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



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 rs tz n é v S84d Eb Gbhét 4i sze ( t gm 7 ens : es 0 kij ) elz ő sze gm ens



ei. A44d Nb 4bhét ( i sze 3t gm : ens 0 es ) kij elz ő kiv ála szt ó jel ei. S8A E kie Gbgés 8i zít (t ő 7 pa : nel 0 sze ) gm ens ei. A8A N kie 8bgés ( i zít 7t ő : pa 0 nel ) kiv ála szt ó jel ei. M- A C Cl L oc K k_ div ide be me net e. 50 Mh zes óra jel U- btn 88 Created by XMLmind XSL-FO Converter.


P 3. Le ny om ása kor a ren dsz er óra jel ma gas ért ék ű les z D- btn O 2. W Le 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



ő 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



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 iA no _u At ( 3 : 0 ) iB no _u Bt ( 3 : 0 ) 91 Created by XMLmind XSL-FO Converter.


i0 n _ C i0 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ó.


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.




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 rs tz n é v S84d Eb Gbhét 4i sze ( t gm 7 ens : es 0 kij ) elz ő sze gm ens 93 Created by XMLmind XSL-FO Converter.


ei. A44d Nb 4bhét ( i sze 3t gm : ens 0 es ) kij elz ő kiv ála szt ó jel ei. S8A E kie Gbgés 8i zít (t ő 7 pa : nel 0 sze ) gm ens ei. A8A N kie 8bgés ( i zít 7t ő : pa 0 nel ) kiv ála szt ó jel ei. M- A C Cl L oc K k_ div ide be me net e. 50 Mh zes óra jel U- btn 94 Created by XMLmind XSL-FO Converter.


P 3. Le ny om ása kor a ren dsz er óra jel ma gas ért ék ű les z D- btn O 2. W Le 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



ő 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. S88d Wb ( bka 7i pcs : t oló 0 be ) me net . S W( 3:0 ) az inp ut0 és S W( 7:4 ) az inp ut1 ada tbe



me net ea CP Una k. L4LE ED Dbki ( i me 3t net : . 0 FL ) A Gek 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 Created by XMLmind XSL-FO Converter.


BJ ee ml e n e t iA no _u At ( 3 : 0 ) iB no _u Bt ( 3 : 0 ) iO nu _t C0 iO nu _t D1

5.12. ábra - A processzor blokkvázlatának részlete



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 UFU teg al r st ó í é ut tt a á e sí s l tá k s ó b d e k B ö r v 2 et , k e B z r é 1 s , e B r 0 0 N 0 in 0 c s u g rá s 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. 1



h a 0 U 0 g Z 1 rá = 1s fe hNlt a i ét n el Zc te =s lj 0 e us gül r t á s h a 0 1 Z 0 = 1 hU ag r Zá =s 0 N f in ec l s tu ég t rá es l t e l j e s ü l t . . ... .. .. 1 U 1 g 1 rá s fe lt ét el 100 Created by XMLmind XSL-FO Converter.


te lj e s ül t





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 rs tz n é v S84db E hét Gbsze 4i gm ( t ens 7 es : kije 0 lző ) sze gm ens ei.



A44db N hét 4bsze ( i gm 3t ens : es 0 kije ) lző kiv ála szt ó jele i. S8A E kie Gbgés 8i zítő ( t pan 7 el : sze 0 gm ) ens ei. A8A N kie 8bgés ( i zítő 7t pan : el 0 kiv ) ála szt ó jele i. M- A C Clo L ck_ K div ide be me net e. 50 Mh zes óra jel U- btn P 3. Le nyo má sak or a



ren dsz er óra jel ma gas érté kű les z D- btn O 2. W Le 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 Created by XMLmind XSL-FO Converter.


nds zer ala páll apo tba hel yez ése. Mi nde n szá mlá lót tör öl. S88db W kap ( bcso 7i lób : t em 0 ene ) t. SW (3: 0) az inp ut0 és SW (7: 4) az inp ut1 ada tbe me net ea CP Unak . L4LE ED Dbki ( i me 3t net. : FL 0 AG ) -ek bite k és óra jel



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 Created by XMLmind XSL-FO Converter.


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



A programrészlet c szintaktikai megfelelője:

vhd-6. ábra - ../sections/src/codeFor.vhd

5.17. ábra - Mintaprogram for ciklusra, hibaüzenettel




II. Könyv. rész - Gadgeteer


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


112 112 112 112 113 113 113 116 116 117 117 118 123 125 125 125 126 128 128 132 134 134 135 135 135 136 141 143 144 144 144 145 152 154 154

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.


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 Created by XMLmind XSL-FO Converter.

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:


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



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



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”


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.


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



Előfordulhat, hogy az újonnan létrehozott projekt alapesetben egy FEZ Hydratípusúdemópanelt tartalmaz.

7.9. ábra - A létrehozott Gadgeteer projekt


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


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



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

System; System.Collections; System.Threading; Microsoft.SPOT; Microsoft.SPOT.Presentation; Microsoft.SPOT.Presentation.Controls; Microsoft.SPOT.Presentation.Media; Microsoft.SPOT.Touch;

using using using using

Gadgeteer.Networking; GT = Gadgeteer; GTM = Gadgeteer.Modules; Gadgeteer.Modules.GHIElectronics;


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 Created by XMLmind XSL-FO Converter.

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?


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…):


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


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



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ő



8.4. Az program megírása 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



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


Stopper alkalmazás készítése .NETGadgeteer-el • Stopped: a stopper leállított állapotban van A forrásfájlt bővítsük az enum definícióval: 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()


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 Created by XMLmind XSL-FO Converter.

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;


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


8.5. A program futtatása 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?


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


Fényerő szabályozó lámpa érintő kapcsoló .NETGadgeteer használatával MulticolorLed 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


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:


Fényerő szabályozó lámpa érintő kapcsoló .NETGadgeteer használatával byte previousLightIntensity = 0; GT.Timertimer; int TimerResolution = 200; int timerCount = 0;

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


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


Fényerő szabályozó lámpa érintő kapcsoló .NETGadgeteer használatával

9.4. ábra - 7%-os kitöltésű lámpa



9.5. ábra - Teljesen felkapcsolt lámpa

9.4. A teljes forráskód using using using using using using using using using using using

System; System.Collections; Microsoft.SPOT; Microsoft.SPOT.Presentation; Microsoft.SPOT.Presentation.Controls; Microsoft.SPOT.Presentation.Media; Microsoft.SPOT.Touch; Gadgeteer.Networking; GT = Gadgeteer; GTM = Gadgeteer.Modules; Gadgeteer.Modules.GHIElectronics;

namespace Light_Switch { public partial class Program { enum lightUpDownDirection { up, down } byte lightIntensity = 0; byte previousLightIntensity = 0; lightUpDownDirection lightDirection = lightUpDownDirection.up; int timerCount = 0; GT.Timertimer; int TimerResolution = 200; void ProgramStarted() { Debug.Print("Program Started");


Fényerő szabályozó lámpa érintő kapcsoló .NETGadgeteer használatával 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); } void timer_Tick(GT.Timertimer) { 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


9.4.9.4.1. Felkészülést segítő kérdések Hogy kezeljük a kijelzőn kiváltott felhasználói interakciókat? Hogy állítjuk be a LED intenzitását? Hogy lehet a grafikus kijelzőre rajzolni?


10. fejezet - SD kártya olvasó .NET Gadgeteer használatával 10.1. A feladat célja A feladat célja megismertetni a .NET Gadgeteer eszköz SD kártya olvasójának működését. A feladathoz szükség lesz a FEZ Spider panelre, SD kártya olvasó modulra, nyomógombra és a T35-ös kijelzőre. A program az elindulást követően egy gombnyomásra vár. A gombnyomás következtében, amennyiben van az SD kártya olvasó modulban kártya, kilistázza a fájlokat. A forráskódban lehetőség van különféle fájltípusok szűrésére is.

10.2. A projekt létrehozása Első lépésként nyissunk meg a Visual Studio 2010-et, majd hozzunk létre egy új .NET Gadgeteer Application-t: Fájl→New→Project→Visual C# / Gadgeteer Adjunk nevet a projektnek, mondjuk „SD_card_reader”, illetve egy elérési utat. Az „OK” gomb megnyomása után a következő képernyő fog megjelenni:

10.1. ábra - A Visual Studio 2010 új .NET Gadgeteer projekt

A program alapértelmezés szerint a FEZ Hydra panelt rakja ki, ezt le kell cserélnünk a Spider-re, hiszen azzal dolgozunk. Töröljük ki a Hydrát és a bal oldali toolbox alján lévő „Gadgeteer Mainboards” 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: Button Display_T35 SDCard UsbClientDP 144 Created by XMLmind XSL-FO Converter.

SD kártya olvasó .NET Gadgeteer használatával A Spider alaplapjára kattintsunk jobb egérrel, majd a „Connect all modules”-ra. Az összekapcsolt panelünknek így kell kinéznie:

10.2. ábra - az összekötött rendszer

10.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 SD_card_reader { 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.


SD kártya olvasó .NET Gadgeteer használatával 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 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, hogy az elindulást követően egy üzenet jelezze a felhasználó számára a működéssel kapcsolatos teendőket! Ehhez először helyezzünk el két változót a ProgramStarted() függvény előtti sorokba: private Text txtMessage; private Text txtResults;

A Text változó szöveges objektum tárolására alkalmas, amit a megjelenítő felület ki tud rajzolni. A txtMessage fogja tartalmazni az instrukciót. Előre gondolkodva, a txtResult majd a kilistázott fájlokat fogja megjeleníteni. Folytatólagosan (a ProgramStarted() függvény után) hozzunk létre egy privát visszatérés nélküli függvényt: SetupWindow(). Ez fog felelni a kezdőképernyő beállításáért. Illesszük be a következő kódrészletet: private void SetupWindow() { Window window = display.WPFWindow; Font baseFont = Resources.GetFont(Resources.FontResources.NinaB); Canvas canvas = new Canvas(); window.Child = canvas; Text txtIntro = new Text(baseFont, "Press the button to search for files."); canvas.Children.Add(txtIntro); Canvas.SetTop(txtIntro, 30); Canvas.SetLeft(txtIntro, 20); txtResults = new Text(baseFont, string.Empty); canvas.Children.Add(txtResults); Canvas.SetTop(txtResults, 60); Canvas.SetLeft(txtResults, 35); txtMessage = new Text(baseFont, string.Empty); txtMessage.Width = 300; txtMessage.TextWrap = true; canvas.Children.Add(txtMessage); Canvas.SetTop(txtMessage, 110); Canvas.SetLeft(txtMessage, 10); }

Nézzük meg részletesen a fenti néhány sort. A függvény első részében létrehozunk egy új Window típusú objektumot. Ez fogja a képernyőt képviselni. Ez egy WPF ablak lesz, ami lehetővé teszi a rajzolást. A következő sorban létrehozunk egy Font típust. Ez tartalmazza a szövegmegjelenítési információkat, ami alapján az egyes szövegek megjelenítésre kerülnek. Ehhez az erőforrásokból (Resources) le kell kérnünk az adott karakter típust, ami jelen esetben a NinaB. A Canvas az az objektum, amire a tényleges kirajzolás történni fog, azaz olyan, mint egy vászon. Ahhoz, hogy a program tudja használni, hozzá kell csatolni a megjelenítő felülethez, ezt hajtja végre a window.child = canvas utasítás. Az előbb definiáltunk két Text változót. Ezeket létre is kell hozni. A konstruktor mindkét esetben ugyanúgy fog kinézni: new Text(baseFont, string.Empty). Tehát megadjuk, hogy milyen kartertípust használjon, valamint egy üres szöveget. Amint létrejött a txtResults változó, hozzáadjuk a vászonhoz. A canvas.Children.Add(txtResults) ezt hajtja végre. A megjelenítést tudjuk pozícionálni. A következő két sor beállítja a bal felső saroktól számított pozíciót a le, illetve bal irányokban. Ezt nem a példányon, hanem a Canvas osztály segítségével tesszük. A txtMessage létrehozása és beállítása hasonló módon történik. A különbség az, hogy fix szélességet állítunk be, illetve bekapcsoljuk a hosszú sorok tördelése opciót (wrap). Természetesen az előző szöveg alá pozícionáljuk.


SD kártya olvasó .NET Gadgeteer használatával Hívjuk meg ezt a függvényt a ProgramStarted() metódusból. Amennyiben futtatjuk a programot, a következő képet kell látnunk a kijelzőn:

10.3. ábra - a kezdőképernyő

A következő lépésben írjuk meg a gombnyomás lekezeléséért felelős programrészt. Ehhez a ProgramStarted() függvényen belül, a SetupWindow() sor alá írjuk be a következőt: button.ButtonPressed += new Button.ButtonEventHandler(button_ButtonPressed);

A button változón keresztül érhetjük el a panelhez fizikailag csatlakoztatott gombot. Ez rendelkezik egy ButtonPressed, azaz egy gomb megnyomva 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 (button_buttonPressed). A program további részében az SD kártyáról való beolvasást kell megoldani. Ennek úgy kell működnie, hogy vagy minden fájltípust kiír, vagy pedig előre meghatározott kiterjesztéseket vizsgál. A feldolgozás folyamatábrája a következő:

10.4. ábra - a beolvasás folyamatábrája


SD kártya olvasó .NET Gadgeteer használatával

Hozzuk létre a következő két függvényt: private string[] GetFiles(string[] extensions, bool recursive) { GT.StorageDevice storage = sdCard.GetStorageDevice(); for (int i = 0; i < extensions.Length; i++) {


SD kártya olvasó .NET Gadgeteer használatával if((extensions[i])[0] != '.') extensions[i] = '.' + extensions[i]; } ArrayList list = new ArrayList(); DirectoryTraversal(storage, null, extensions, recursive, list); return (string[])list.ToArray(typeof(string)); } private void DirectoryTraversal(GT.StorageDevice storage, string path, string[] extensions, bool recursive, ArrayList list) { var files = storage.ListFiles(path); foreach (var fileName in files) { if (extensions[0].Equals(".*")) list.Add(fileName); else { foreach (var extension in extensions) { if System.IO.Path.GetExtension(fileName).ToLower()== extension.ToLower()) list.Add(fileName); } } } if (recursive) { var directories = storage.ListDirectories(path); foreach (var directoryName in directories) directoryTraversal(storage, directoryName, extensions, recursive, list); } }

A 10.3. ábrán felvázolt folyamat megvalósítását végzi a két függvény. GetFiles: Ez a függvény valósítja meg a fájlok keresését. A bemenő paraméterei: egy string tömb, ami kiterjesztéseket tartalmaz (vagy * karaktert, ha minden fájltípus érdekel), a másik pedig egy logikai változó, ami az alkönyvtárak bejárásának engedélyezését jelzi. Első lépésként létrehozunk egy StorageDevice típusú változót, amin keresztül a csatlakoztatott SD kártyához hozzáférünk. Egy for ciklussal végigmegyünk a kiterjesztéseken és leellenőrizzük a helyes formátumot (legyen előtte pont). Létrehozunk egy listát, amibe a kritériumoknak megfelelő fájlok nevei fognak kerülni. Meghívjuk a directoryTraversal függvényt, ami a tényleges listafeltöltést végzi. Végül ezt a listát string tömbbé konvertálva visszatérési értékként visszaadjuk. DirectoryTraversal: A függvény visszatérés nélküli, a paraméterei: egy storage példány, amivel hozzáférünk a kártyához; egy elérési út, ahol a fájlkeresést végezzük; a kiterjesztés tömb; az alkönyvtárban való keresést engedélyező logikai változó; valamint a lista, amibe a fájlok nevei kerülnek. Első lépésben egy files nevű változóba az átadott elérési út alapján lekérjük a fájlok listáját. Ez nem fogja tartalmazni a könyvtárakat, illetve null paraméterre a gyökérkönyvtárban keres.Végig kell nézni az összes fájlt és meg kell állapítani, hogy a kiterjesztésük benne van-e az extensions tömbben. Ehhez egy foreach ciklust használunk, ami minden elemen végigmegy. Az egyes elemekre a következő vizsgálatokat végezzük el:


SD kártya olvasó .NET Gadgeteer használatával Ha az összes kiterjesztésű fájlt listázni akarjuk (.*), akkor mindenképpen hozzáadjuk a fájlt a listához. Ellenkező esetben végigmegyünk a kiterjesztés tömb minden elemén, és megnézzük, hogy az aktuálisan vizsgált fájl kiterjesztése benne van-e. A fájlok kiterjesztését egy beépített függvény segítségével elérhetjük, így nem kell külön string művelettel előállítani: System.IO.Path.GetExtension(fileName). Amennyiben benne volt a kiterjesztés, akkor a fájlt hozzáadjuk a listához, ha nem, vesszük a következő fájlt és kezdődik elölről a vizsgálat. Végezetül, megvizsgáljuk az alkönyvtárakban való keresés lehetőségét. Ha ezt engedélyeztük, akkor lekérjük az aktuális elérési útban lévő könyvtárakat. Ezeken egyenként végigmenve rekurziót hajtunk végre, azaz meghívjuk a DirectoryTraversal függvényt. Az előzőleg átadott paramétereket használjuk fel újra, annyi kivétellel, hogy a path változó helyére a ciklusban lévő aktuális könyvtár elérési útját adjuk meg. Így az újrahívás után, már nem a gyökérben, hanem abban fog keresni. Belátható, hogy ha mély könyvtárstruktúra van kialakítva, akkor a rekurzió miatt hosszú ideig is eltarthat az összes fájl listázása. A fenti algoritmuson ezért még lehetne optimalizálni, pl. a kiterjesztés vizsgálatnál egy új logikai változót bevezetve csak egyszer kellene megvizsgálni, hogy minden típust keresünk-e. Ugyanis egy logikai változó értékének eldöntése jóval gyorsabb, mint két string összehasonlítása. A másik dolog, hogy minden fájlnál–amennyiben csak bizonyos kiterjesztésekre vagyunk kíváncsiak–, végig megyünka tömb összes elemén. Ennek a problémának a megoldását az olvasóra bízom, amennyiben érdekli! Most már megvannak a keresést végző programrészek is. Még két dologra van szükségünk, hogy teljes legyen a program. Létre kell hoznunk egy tömböt, amibe a kiterjesztések kerülnek, valamint biztosítani kell, hogy a gomb megnyomására a fenti függvények működésbe lépjenek. Tehát vegyük fel a következő változót: private string[] fileExtension = {"txt,pdf"}; //"*"

Ez fogja tartalmazni a már említett fájl kiterjesztéseket, ami alapján a listázást végezzük. Tartalmazhat csak egy * karaktert is, ekkor, mint már említettem, minden kiírásra kerül a képernyőre. A button_ButtonPressed függvénybe helyezzük el a következő kódrészletet: if (sdCard.IsCardMounted) { var textFiles = GetFiles(fileExtension, true); txtResults.TextContent = "Your SD Card contains " + textFiles.Length +" files"; string fileList = string.Empty; foreach (var fileName in textFiles) fileList += fileName + ", "; if (fileList.Length > 0) fileList = fileList.Substring(0, fileList.Length - 2); txtMessage.TextContent = fileList; }

Elsőként megvizsgáljuk, hogy az SD kártya használatra kész állapotban van-e. Erre szolgál az IsCardMounted változója.Ha nincs, akkor nincs mit vizsgálni. Ellenkező esetben egy textFiles nevű változóba lekérjük a fájlokat a már megírt GetFiles függvénnyel. A korábban létrehozott és képernyőhöz csatolt Text típusú txtResult változó szövegének beállítjuk a megtalált fájlok számát. A következő lépésben létrehozunk ez új string típusú változót, amibe összefűzzük vesszővel elválasztva a fájlokat. Az utolsó if feltételben megvizsgáljuk van-e találat. Amennyiben igen, akkor az utolsó vesszőt eltávolítjuk. Végezetül a txtMessage változó szövegét beállítjuk az imént összefűzött string-re. Így minden szükséges adat most már megjelenik a képernyőn. Optimalizálásképpen, a fileList string helyett lehetne StringBuilder-t használni. Az elkészült programról néhány kép működés közben:

10.5. ábra - csak txt-re keresés



10.6. ábra - minden fájlra keresés



10.7. ábra - nincs találat

10.4. A teljes forráskód using using using using using

System; Microsoft.SPOT; Microsoft.SPOT.Presentation; Microsoft.SPOT.Presentation.Controls; Microsoft.SPOT.Presentation.Media;

using using using using

GT = Gadgeteer; GTM = Gadgeteer.Modules; Gadgeteer.Modules.GHIElectronics; System.Collections;

namespace SD_card_reader { public partial class Program { private Text txtMessage; private Text txtResults; private string[] fileExtension = {"txt,pdf"}; //"*" void ProgramStarted() { Debug.Print("Program Started"); SetupWindow(); button.ButtonPressed += new Button.ButtonEventHandler(button_ButtonPressed); } private void SetupWindow() { Window window = display.WPFWindow; Font baseFont = Resources.GetFont(Resources.FontResources.NinaB);


SD kártya olvasó .NET Gadgeteer használatával Canvas canvas = new Canvas(); window.Child = canvas; Text txtIntro = new Text(baseFont, "Press the button to search for files."); canvas.Children.Add(txtIntro); Canvas.SetTop(txtIntro, 30); Canvas.SetLeft(txtIntro, 20); txtResults = new Text(baseFont, string.Empty); canvas.Children.Add(txtResults); Canvas.SetTop(txtResults, 60); Canvas.SetLeft(txtResults, 35); txtMessage = new Text(baseFont, string.Empty); txtMessage.Width = 300; txtMessage.TextWrap = true; canvas.Children.Add(txtMessage); Canvas.SetTop(txtMessage, 110); Canvas.SetLeft(txtMessage, 10); } private void button_ButtonPressed(Button sender, Button.ButtonState state) { if (sdCard.IsCardMounted) { var textFiles = GetFiles(fileExtension, true); txtResults.TextContent = "Your SD Card contains " + textFiles.Length +" files"; string fileList = string.Empty; foreach (var fileName in textFiles) fileList += fileName + ", "; if (fileList.Length > 0) fileList = fileList.Substring(0, fileList.Length - 2); txtMessage.TextContent = fileList; } } private string[] GetFiles(string[] extensions, bool recursive) { GT.StorageDevice storage = sdCard.GetStorageDevice(); for (int i = 0; i < extensions.Length; i++) { if((extensions[i])[0] != '.') extensions[i] = '.' + extensions[i]; } ArrayList list = new ArrayList(); DirectoryTraversal(storage, null, extensions, recursive, list); return (string[])list.ToArray(typeof(string)); } private void DirectoryTraversal(GT.StorageDevice storage, string path, string[] extensions, bool recursive, ArrayList list) { var files = storage.ListFiles(path); foreach (var fileName in files) { if (extensions[0].Equals(".*")) list.Add(fileName); else { foreach (var extension in extensions)


SD kártya olvasó .NET Gadgeteer használatával { if System.IO.Path.GetExtension(fileName).ToLower()== extension.ToLower()) list.Add(fileName); } } } if (recursive) { var directories = storage.ListDirectories(path); foreach (var directoryName in directories) directoryTraversal(storage, directoryName, extensions, recursive, list); } } } }

10.5. Felkészülést segítő kérdések 1. Milyen eszközök szükségesek a kártyaolvasó elkészítéséhez, mi a szerepük? 2. Hogyan történik a könyvtárak rekurzív feltérképezése? 3. A feldolgozás milyen lépésekből áll?

10.6. Felhasznált irodalom 1. Simon Monk: GettingStartedwith .NETGadgeteer, 2012 O’Reilly Media, ISBN: 978-1-449-32823-8 2. GusIssa: .NETGadgeteerUltimateGuide, 2011, GHI Electronics 3. Nicolas Villar, James Scott, Steve Hodges, KerryHammil, and Colin Miller: .NETGadgeteer: A Platform forcustomDevices, 2012 Springer Berlin Heidelberg, ISBN:978-3-642-31204-5 4. http://10rem.net/blog/2012/03/13/setting-up-ethernet-on-the-net-gadgeteer http://my.safaribooksonline.com/book/-/9781449330682/4dot-web-messenger/id2837110 5. http://10rem.net/blog/2011/10/24/getting-started-with-the-net-gadgeteer---part-1-background-setup-andhello-world 6. http://www.netmf.com/gadgeteer/ 7. http://www.w3schools.com/tags/ref_httpmethods.asp 8. http://www.w3.org/TR/html401/interact/forms.html


Irodalomjegyzék [1] Xilinx Inc. (weblink: http://www.xilinx.com) [2]

Xilinx Spartan-3E FPGA Family Data Sheet Xilinx Inc., DS312 http://www.xilinx.com/support/documentation/data_sheets/ds312.pdf)

2012-10-29

[3] Digilent Diigiillentt Basys2 Board Refference Manuall Digilent, Inc., Doc: 502-155, 2010-11-11


(weblink:

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ó

Recommend Documents