beágyazott rendszerek a mérnöki gyakorlatban...created by xmlmind xsl-fo converter. beágyazott...

Created by XMLmind XSL-FO Converter.

Beágyazott rendszerek a mérnöki gyakorlatban

Molnár, András Turóczi, Antal

Stojcsics, Dániel Léczfalvy, Ádám

Kelemen, József Somlyai, László


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

iii Created by XMLmind XSL-FO Converter.

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

Beágyazott rendszerek a mérnöki

gyakorlatban

iv Created by XMLmind XSL-FO Converter.

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


gyakorlatban

v Created by XMLmind XSL-FO Converter.

10.2. A projekt létrehozása .......................................................................................... 144 10.3. A program megírása ........................................................................................... 145 10.4. A teljes forráskód ................................................................................................ 152 10.5. Felkészülést segítő kérdések ............................................................................... 154 10.6. Felhasznált irodalom ........................................................................................... 154

Irodalomjegyzék ............................................................................................................................. 155

vi Created by XMLmind XSL-FO Converter.

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


gyakorlatban

vii Created by XMLmind XSL-FO Converter.

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


gyakorlatban

viii Created by XMLmind XSL-FO Converter.

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

ix Created by XMLmind XSL-FO Converter.

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

x Created by XMLmind XSL-FO Converter.

Az egyenletek listája

4.1. (4.1) ........................................................................................................................................... 48 4.2. (4.2) ........................................................................................................................................... 48 4.3. (4.3) ........................................................................................................................................... 48 4.4. (4.4) ........................................................................................................................................... 48 4.5. (4.5) ........................................................................................................................................... 48 4.6. (4.6) ........................................................................................................................................... 48 4.7. (4.7) ........................................................................................................................................... 48 4.8. (4.8) ........................................................................................................................................... 52 4.9. (4.9) ........................................................................................................................................... 52 4.10. (4.10) ....................................................................................................................................... 53 4.11. (4.11) ....................................................................................................................................... 53


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

2 Created by XMLmind XSL-FO Converter.

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

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:

A B C Y

0 0 0 0 0

1 0 0 1 0

2 0 1 0 1

3 0 1 1 0

4 1 0 0 1

5 1 0 1 0

6 1 1 0 1

7 1 1 1 0

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ó a gyártó honlapján érhető el:

http://www.xilinx.com/support/documentation/spartan-3.htm

http://www.xilinx.com/support/documentation/spartan-3.htm



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

ihoz é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ív-

ké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 ( ): Buszos vonalra csatlakozás hozzáadása.

• Add I/O Marker ( ): Be-, kimeneti pontok hozzáadása.

• Add Symbol ( ): Szimbólum (alkatrész, könyvtári, vagy saját) hozzáadása.

Mindegyik művelethez a bal alsó ablakban (Process/Options) találunk beállítási lehetőségeket, illetve

műveleteket. A kényelmesebb szerkesztés érdekében megnövelhetjük a lap méretét is. Ezt a rajz területen jobb

kattintásra felugró Object Properties parancs kiválasztásával tehetjük meg. A megjelenő ablakban a Sheets sort

kiválasztva módosíthatjuk a lap méretét (Size). Vezeték vagy busz elnevezéséhez válasszuk az Add Net Name

parancsot majd a bal alsó ablakban az Options fülnél a Name sorba írjuk a nevet. Ezután kattintsunk az

elnevezni kívánt vezetékre. A vezetékek neveire a kapcsolási rajz átláthatósága érdekében is hivatkozhatunk,

ugyanis ha két vagy több vezetéket ugyan úgy nevezünk el, az olyan, mintha fizikailag összehuzaloztuk volna

őket (lásd az és kapuk bemeneteit és a tárolók kimeneteit). A tárolók q(0), q(1), q(2) és q(3) kimenetei a

speciális q(7:0) un. buszvezetékre csatlakoznak (buszvezetékeket a kapcsolási rajzokban az összetartozó

vezetékek ábrázolása érdekében használunk). A buszok, illetve leágazásaik elnevezése utal arra, hogy adott

buszon belül melyik vonalra (bitre) csatlakozunk. Az előző példa (3.5.ábra) kapcsolásán a q(7:0) jel egy 8 bites

busz, melyre az adott helyértékű bitvezeték (q(0)…q(7)) buszcsatlakozáson (Bus Tap) keresztül kapcsolódik. A

kapcsolódás be- és kimeneti jelei I/O buffer-eken keresztül kapcsolódnak a külvilágot reprezentáló I/O Marker-

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



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

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



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



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



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.



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

S Y

0 I0

1 I1

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

S

1 S

0 Y

0 0 I0

0 1 I1

1 0 I2

1 1 I3

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

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



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



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



A

3 B

3 A

2 B

2 A

1 B

1 A

0 B

0 A

G

B

B

G

A

E

Q

1 0 x x x x x x 1 0 0

0 1 x x x x x x 0 1 0

= = 1 0 x x x x 1 0 0

= = 0 1 x x x x 0 1 0

= = = = 1 0 x x 1 0 0

= = = = 0 1 x x 0 1 0

= = = = = = 1 0 1 0 0

= = = = = = 0 1 0 1 0

= = = = = = = = 0 0 1

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

A

3 B

3 A

2 B

2 A

1 B

1 A

0 B

0 A

G

B

E

Q

1 0 x x x x x x 1 0

= = 1 0 x x x x 1 0

= = = = 1 0 x x 1 0

= = = = = = 1 0 1 0

= = = = = = = = 0 1

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

Y

2 Y

1 Y

0

I

n

0

0 0 0

I

n

1

0 0 1

I

n

2

0 1 0

I

n

3

0 1 1

I

n

1 0 0



4

I

n

5

1 0 1

I

n

6

1 1 0

I

n

7

1 1 1

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



n

0 n

1 n

2 n

3 u

t

1

u

t

0

T

0 0 0 0 x x 0

1 0 0 0 0 0 1

x 1 0 0 0 1 1

x x 1 0 1 0 1

x x x 1 1 1 1

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

n

0

I

n

1

I

n

2

I

n

3

I

n

4

I

n

5

I

n

6

I

n

7

O

u

t

2

O

u

t

1

O

u

t

0

I

T

x x x x x x x 1 1 1 1 1

x x x x x x 1 0 1 1 0 1

x x x x x 1 0 0 1 0 1 1

x x x x 1 0 0 0 1 0 0 1

x x x 1 0 0 0 0 0 1 1 1

x x 1 0 0 0 0 0 0 1 0 1

x 1 0 0 0 0 0 0 0 0 1 1

1 0 0 0 0 0 0 0 0 0 0 1

0 0 0 0 0 0 0 0 x x x 0

4.4. egyenlet - (4.4)

4.5. egyenlet - (4.5)

4.6. egyenlet - (4.6)

4.7. egyenlet - (4.7)

4.14. ábra - 8 bites prioritáskódoló rajzjele



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

E

N S

1 S

0 O

U

T

3

O

U

T

2

O

U

T

1

O

U

T

0

0 0 0 0 0 0 0

0 0 1 0 0 0 0

0 1 0 0 0 0 0

0 1 1 0 0 0 0

1 0 0 0 0 0 1

1 0 1 0 0 1 0

1 1 0 0 1 0 0

1 1 1 1 0 0 0

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


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

nak 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

S

W

S

W

S

W

S

W

S

W

S

W

S

W

S

W

B

T

B

T

L

E

L

E



0 1 2 3 4 5 6 7 N0

N

1 D

0 D

1

A

0 A

1 A

2 A

3 B

0 B

1 B

2 B

3 E

Q

i

n

A

G

i

n

E

Q

o

u

t

A

G

o

u

t





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

n

0

I

n

1

S

u

m

C

o

u

t

0 0 0 0

0 1 1 0

1 0 1 0

1 1 0 1

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

n

0

I

n

1

C

i

n

S

u

m

C

o

u

t

0 0 0 0 0

0 0 1 1 0

0 1 0 1 0

0 1 1 0 1

1 0 0 1 0

1 0 1 0 1

1 1 0 0 1

1 1 1 1 1

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ó




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.



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

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



• 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

S

2 S

1 S

0 K

i

m

e

n

e

t

L

eí

rá

s

0 0 0 Y＝A

+

B

A

z

’

A

’

és

’

B

’

be

m

en

et

ös

sz

eg

e.

0 0 1 Y＝A

−

B

A

z

’

A

’

és

’

B

’

be

m

en

et

k

ül

ö

n

bs

ég

e

0 1 0 Y(i

)

＝A

(i

)

&

A

z

’

A

’

és

’

B

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

0 1 1 Y(

2

:

0

)

＝A

(

3

:

1

),

Y

(

3

)

=

A

(

0

)

A

z

’

A

’

be

m

en

et

ro

tá

lá

sa

jo

b

br

a.

1 0 0 Y(i

)

＝A

(i

)|

B

(i

)

A

z

’

A

’

és

’

B

’

be

m

en

et

bi

te

n

ké

nt

i



V

A

G

Y

ka

pc

so

la

ta

1 0 1 Y(

3

:

1

)

=

A

(

2

:

0

),

Y

(

0

)

=

A

(

3

)

A

z

’

A

’

be

m

en

et

ro

tá

lá

sa

ba

lr

a.

1 1 0 Y(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

1 1 1 - -



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.


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


M

a

k

r

ó

P

o

r

t

(

U

C

F

f

á

j

l



)

S

0

,

S

1

,

S

2

B

T

N

0

,

B

T

N

1

,

B

T

N

2

A

(

3

:

0

)

S

W

(

3

:

0

)

B

(

3

:

0

)

S

W

(

7

:

4

)

A

L

U

_

O

U

T

(

3

:

0

)

L

E

D

(

3

:

0

)

O

V

F

L

E

D

(

5

)

C

A

R

R

Y

L

E

D

(

6

)

Z

E

R

O

L

E

D

(



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

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

A B C D E Co

u

n

t

0 0 0 0 0 0

1 0 0 0 0 1

1 1 0 0 0 2

1 1 1 0 0 3

1 1 1 1 0 4

1 1 1 1 1 5

0 1 1 1 1 6

0 0 1 1 1 7

0 0 0 1 1 8

0 0 0 0 1 9

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



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:


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

A

e

n

2

A

e

n

1

A

e

n

0

F

u

n

k

c

i

ó

Leí

rás

0 0 0 Ao

u

t

A

reg

iszt

ere

k

be

me

net

e

az

’A’

reg

iszt

er

ki

me

net

e

0 0 1 Bo

u

t

A

reg

iszt

ere

k

be

me

net

e a

’B’

reg

iszt

er

ki



me

net

e

0 1 0 RA

M

o

u

t

A

reg

iszt

ere

k

be

me

net

e a

me

mó

ria

ki

me

net

e

0 1 1 IN

S

T

A

reg

iszt

ere

k

be

me

net

e

az

uta

sítá

s

arg

um

ent

um

a

(ut

asít

ás

els

ő 4

bite

)

1 0 0 IN

0

A

reg

iszt

ere

k

be

me

net

e

az

inp

ut 0

1 0 1 IN

A

reg



1 iszt

ere

k

be

me

net

e

az

inp

ut 1

1 1 0 AL

U

o

u

t

A

reg

iszt

ere

k

be

me

net

e

az

AL

U

ki

me

net

e

1 1 1 - -

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

S

2 S

1 S

0 F

u

n

k

c

i

ó

Leír

ás

0 0 0 A+

B

Az

’A’

és a

’B’

regi

szte

r

öss

zea

dás

a,

ere

dm

ény

az



’A’

-ba

0 0 1 A-

B

Az

’A’

regi

szte

rből

’B’

kiv

oná

sa,

ere

dm

ény

az

’A’

-ba

0 1 0 A

a

n

d

B

Az

’A’

és a

’B’

regi

szte

r

bite

nké

nti

ÉS

kap

csol

ata,

ere

dm

ény

az

’A’

-ba

0 1 1 RO

R

Az

’A’

regi

szte

r

rotá

lása

job

bra,

ere

dm

ény

az

’A’

-ba

1 0 0 A

o

r

B

Az

’A’

és a

’B’

regi

szte



r

bite

nké

nti

VA

GY

kap

csol

ata,

ere

dm

ény

’A’

-ba

1 0 1 RO

L

Az

’A’

regi

szte

r

rotá

lása

balr

a,

ere

dm

ény

az

’A’

-ba

1 1 0 A

x

o

r

B

Az

’A’

és a

’B’

regi

szte

r

bite

nké

nti

XO

R

kap

csol

ata,

ere

dm

ény

az

’A’

-ba

1 1 1 - -

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



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

B

r

2

B

r

1

B

r

0

F

u

n

k

c

i

ó

Leí

rás

0 0 0 no

B

R

Nin

cs

ugr

ás

0 0 1 BR

Z

Az

AL

U Z

flag

-je

’1’,

ugr

ás

az

utas

ítás

utol

só

8

bitj

én

me

gad

ott

cím

re

0 1 0 BR

N

Z

Az

AL

U Z

flag

-je

’0’,

ugr

ás

az

utas

ítás

utol

só

8

bitj

én

me

gad

ott



cím

re

0 1 1 BR

C

Az

AL

U

C

flag

-je

’1’,

ugr

ás

az

utas

ítás

utol

só

8

bitj

én

me

gad

ott

cím

re

1 0 0 BR

N

C

Az

AL

U

C

flag

-je

’0’,

ugr

ás

az

utas

ítás

utol

só

8

bitj

én

me

gad

ott

cím

re

1 0 1 BR

O

Az

AL

U

O

flag

-je

’1’,

ugr

ás

az

utas

ítás

utol



só

8

bitj

én

me

gad

ott

cím

re

1 1 0 BR

N

O

Az

AL

U

O

flag

-je

’0’,

ugr

ás

az

utas

ítás

utol

só

8

bitj

én

me

gad

ott

cím

re

1 1 1 BR Felt

é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

O

e

n

O

n

b

F

u

n

k

c

i

ó

Leí

rás

0 0 - Ne

m

tört

éni

k

kiír

ás

0 1 - Ne

m

tört

éni

k

kiír

ás

1 0 ou

t

0

=

A

Az

’A’

regi

szte

r

érté

ke

a 0.

kim

ene

ti

latc

h-

be

ker

ül

1 1 ou

t

1

=

A

Az

’A’

regi

szte

r

érté

ke

a 1.

kim

ene

ti

latc

h-

be

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




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.




• Basys2 extBoard #1 kiegészítő panel


• 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

B

e

m

e

n

e

t

J

e

l

Leí

rás

i

n

_

A

1

P

c

n

t

(

7

:

4

)

Pro

gra

ms

zá

ml

áló

me

gje

len

ítés

e

az

A

kij

elz

őn

i

n

_

A

0

P

c

n

t

(

3

:

0

)

i

n

_

B

1

0

0

0

+

I

N

S

T

R

(

2

0

Ut

asít

ás

me

gje

len

ítés

e a

B,

C

és

D

kij

elz



) ő

mo

dul

ok

on

i

n

_

B

0

I

N

S

T

R

(

1

9

:

1

6

)

i

n

_

C

1

I

N

S

T

R

(

1

5

:

1

2

)

i

n

_

C

0

I

N

S

T

R

(

1

1

:

8

)

i

n

_

D

1

I

N

S

T

R

(

7

:

4

)

i

n

_

D

0

I

N

S

T

R

(

3

:

0

)



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


P

o

r

t

n

é

v

B

u

s

z

Leí

rás

S

E

G

4

(

7

:

0

)

8

b

i

t

4d

b

hét

sze

gm

ens

es

kij

elz

ő

sze

gm

ens



ei.

A

N

4

(

3

:

0

)

4

b

i

t

4d

b

hét

sze

gm

ens

es

kij

elz

ő

kiv

ála

szt

ó

jel

ei.

S

E

G

8

(

7

:

0

)

8

b

i

t

A

kie

gés

zít

ő

pa

nel

sze

gm

ens

ei.

A

N

8

(

7

:

0

)

8

b

i

t

A

kie

gés

zít

ő

pa

nel

kiv

ála

szt

ó

jel

ei.

M

C

L

K

- A

Cl

oc

k_

div

ide

be

me

net

e.

50

Mh

z-

es

óra

jel

U- btn



P 3.

Le

ny

om

ása

kor

a

ren

dsz

er

óra

jel

ma

gas

ért

ék

ű

les

z

D

O

W

N

- btn

2.

Le

ny

om

ása

kor

a

ren

dsz

er

óra

jel

ala

cso

ny

ért

ék

ű

les

z

O

C

L

K

_

E

N

- btn

1.

Le

ny

om

ása

kor

a

ren

dsz

er

óra

jel

10

Hz

,

ell

en

kez



ő

ese

tbe

n

az

UP

/D

O

W

N

R

S

T

- btn

0.

Re

nds

zer

ala

pál

lap

otb

a

hel

yez

ése

.

Mi

nd

en

szá

ml

áló

t

tör

öl.

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

B

e

m

e

n

e

t

J

e

l

i

n

_

A

A

o

u

t

(

3

:

0

)

i

n

_

B

B

o

u

t

(

3

:

0

)



i

n

_

C

0

i

n

_

D

0

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



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


P

o

r

t

n

é

v

B

u

s

z

Leí

rás

S

E

G

4

(

7

:

0

)

8

b

i

t

4d

b

hét

sze

gm

ens

es

kij

elz

ő

sze

gm

ens



ei.

A

N

4

(

3

:

0

)

4

b

i

t

4d

b

hét

sze

gm

ens

es

kij

elz

ő

kiv

ála

szt

ó

jel

ei.

S

E

G

8

(

7

:

0

)

8

b

i

t

A

kie

gés

zít

ő

pa

nel

sze

gm

ens

ei.

A

N

8

(

7

:

0

)

8

b

i

t

A

kie

gés

zít

ő

pa

nel

kiv

ála

szt

ó

jel

ei.

M

C

L

K

- A

Cl

oc

k_

div

ide

be

me

net

e.

50

Mh

z-

es

óra

jel

U- btn



P 3.

Le

ny

om

ása

kor

a

ren

dsz

er

óra

jel

ma

gas

ért

ék

ű

les

z

D

O

W

N

- btn

2.

Le

ny

om

ása

kor

a

ren

dsz

er

óra

jel

ala

cso

ny

ért

ék

ű

les

z

O

C

L

K

_

E

N

- btn

1.

Le

ny

om

ása

kor

a

ren

dsz

er

óra

jel

10

Hz

,

ell

en

kez



ő

ese

tbe

n

az

UP

/D

O

W

N

R

S

T

- btn

0.

Re

nds

zer

ala

pál

lap

otb

a

hel

yez

ése

.

Mi

nd

en

szá

ml

áló

t

tör

öl.

S

W

(

7

:

0

)

8

b

i

t

8d

b

ka

pcs

oló

be

me

net

.

S

W(

3:0

)

az

inp

ut0

és

S

W(

7:4

)

az

inp

ut1

ada

tbe



me

net

e a

CP

U-

na

k.

L

E

D

(

3

:

0

)

4

b

i

t

LE

D

ki

me

net

.

FL

A

G-

ek

bit

ek

és

óra

jel

kij

elz

ése

.

LE

D(

0):

O

VF

;

LE

D(

1):

CA

RR

Y;

LE

D(

2):

ZE

RO

;

LE

D(

3):

clo

ck

5.4. Kimeneti regiszterek, memória, ugró utasítás

A processzor két kimeneti regiszterrel rendelkezik (out0, out1). Ezek a négybites regiszterek az A regiszterből

kaphatnak értéket. A kimeneti értékek tárolásához FD4CE tárolót használjon. A megfelelő kimeneti regiszter

kiválasztása és az értékadás engedélyezése az OEN vezérlőbitekkel történik. A két kimeneti regiszter értékének

kijelzőkön való megjelenítése megjelenítése a Bin_to_7_segment_x4 makróval történik a következő táblázatnak

megfelelően.

5.9. táblázat - Kijelzők portkiosztása



B

e

m

e

n

e

t

J

e

l

i

n

_

A

A

o

u

t

(

3

:

0

)

i

n

_

B

B

o

u

t

(

3

:

0

)

i

n

_

C

O

u

t

0

i

n

_

D

O

u

t

1

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



A processzor az adatok tárolására adatmemóriát (RAM32X4S1) 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

U

t

a

s

í

t

á

s

k

ó

d

B

r

2

,

B

r

1

,

B

r

0

F

e

l

t

é

t

e

l

U

g

r

ó

ut

a

sí

tá

s

b

e

k

ö

v

et

k

e

z

é

s

e

0

0

0

N

in

c

s

u

g

rá

s

1RAM32X4S: 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.



0

0

1

h

a

Z

=

1

U

g

rá

s

fe

lt

ét

el

te

lj

e

s

ül

t

h

a

Z

=

0

N

i

n

c

s

u

g

r

á

s

0

1

0

h

a

Z

=

1

N

in

c

s

u

g

rá

s

h

a

Z

=

0

U

g

r

á

s

f

e

l

t

é

t

e

l

t

e

l

j

e

s

ü

l

t

.

.

.

.

.

.

...

1

1

1

U

g

rá

s

fe

lt

ét

el



te

lj

e

s

ül

t






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.


P

o

r

t

n

é

v

B

u

s

z

Leí

rás

S

E

G

4

(

7

:

0

)

8

b

i

t

4db

hét

sze

gm

ens

es

kije

lző

sze

gm

ens

ei.



A

N

4

(

3

:

0

)

4

b

i

t

4db

hét

sze

gm

ens

es

kije

lző

kiv

ála

szt

ó

jele

i.

S

E

G

8

(

7

:

0

)

8

b

i

t

A

kie

gés

zítő

pan

el

sze

gm

ens

ei.

A

N

8

(

7

:

0

)

8

b

i

t

A

kie

gés

zítő

pan

el

kiv

ála

szt

ó

jele

i.

M

C

L

K

- A

Clo

ck_

div

ide

be

me

net

e.

50

Mh

z-

es

óra

jel

U

P - btn

3.

Le

nyo

má

sak

or a



ren

dsz

er

óra

jel

ma

gas

érté

kű

les

z

D

O

W

N

- btn

2.

Le

nyo

má

sak

or a

ren

dsz

er

óra

jel

ala

cso

ny

érté

kű

les

z

O

C

L

K

_

E

N

- btn

1.

Le

nyo

má

sak

or a

ren

dsz

er

óra

jel

10

Hz,

elle

nke

ző

ese

tbe

n

az

UP

/D

O

W

N

R

S

T

- btn

0.

Re



nds

zer

ala

páll

apo

tba

hel

yez

ése.

Mi

nde

n

szá

mlá

lót

tör

öl.

S

W

(

7

:

0

)

8

b

i

t

8db

kap

cso

lób

em

ene

t.

SW

(3:

0)

az

inp

ut0

és

SW

(7:

4)

az

inp

ut1

ada

tbe

me

net

e a

CP

U-

nak

.

L

E

D

(

3

:

0

)

4

b

i

t

LE

D

ki

me

net.

FL

AG

-ek

bite

k

és

óra

jel



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.



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. .................................................................................................................................................... 112 6.1. Kiknek szól a tananyag? ................................................................................................. 112 6.2. Miért .NETGadgeteer? ................................................................................................... 112 6.3. Szükséges előismeretek .................................................................................................. 112

7. Bevezetés a .NET Gadgeteer használatába ................................................................................. 113 7.1. .NET Gadgeteeralkalmazások készítéséhez szükséges eszközök .................................. 113 7.2. FEZ Spider Starter Kit ................................................................................................... 113 7.3. A FEZ Spider demóapanel használata ............................................................................ 116 7.4. Jelölések a demópanelen ................................................................................................ 116 7.5. Jelölések a próbamodulokon .......................................................................................... 117 7.6. A demópanel csatlakoztatása PC-hez ............................................................................. 117 7.7. Egy egyszerű Gadgeteer program elkészítése ................................................................ 118 7.8. Felkészülést segítő kérdések .......................................................................................... 123

8. Stopper alkalmazás készítése .NETGadgeteer-el ........................................................................ 125 8.1. A feladat célja ................................................................................................................ 125 8.2. A projekt létrehozása ...................................................................................................... 125 8.3. Az eszköz elkészítése ..................................................................................................... 126 8.4. Az program megírása ..................................................................................................... 128

8.4.8.4.1. Stopper osztály készítése ............................................................................. 128 8.4.8.4.1.8.4.1.1. A főprogram elkészítése ......................................................... 132

8.5. A program futtatása ........................................................................................................ 134 8.6. Felkészülést segítő kérdések .......................................................................................... 134

9. Fényerő szabályozó lámpa érintő kapcsoló .NETGadgeteer használatával ................................ 135 9.1. A feladat célja ................................................................................................................ 135 9.2. A projekt létrehozása ...................................................................................................... 135 9.3. A program megírása ....................................................................................................... 136 9.4. A teljes forráskód ........................................................................................................... 141

9.4.9.4.1. Felkészülést segítő kérdések ........................................................................ 143 10. SD kártya olvasó .NET Gadgeteer használatával ..................................................................... 144

10.1. A feladat célja .............................................................................................................. 144 10.2. A projekt létrehozása .................................................................................................... 144 10.3. A program megírása ..................................................................................................... 145 10.4. A teljes forráskód ......................................................................................................... 152 10.5. Felkészülést segítő kérdések ........................................................................................ 154 10.6. Felhasznált irodalom .................................................................................................... 154


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

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:


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


használatába


7.3. A FEZ Spider demóapanel használata

A FEZ Spider demópanel 14 db aljzattal rendelkezik a próbamodulok illesztéséhez, melyek körül megtalálható

azok sorszáma és egy karaktersorozat. E sorozat határozza meg a csatlakoztatható modultípusokat.

A demópanelen elhelyezett Reset gomb segítségével bármikor újraindítható az eszköz. A bekapcsolt állapotot a

D1 jelzésű LED mutatja.

Az USB Client Dual Power modul, („piros modul”) táplálja árammal a demópanelt és a csatlakoztatott

eszközöket USB bemeneten keresztül, vagy egy 7-30 voltos DC adapter segítségével. Szintén ezzel az eszközzel

csatlakoztatható PC-hez a demópanel(USB interfészen keresztül) program feltöltés, illetve hibakeresés céljából

(ebben az esetben a tápellátás és a programozás is egyazon bemeneten történik).

7.3. ábra - "Piros modul"

A piros modul egyetlen aljzattal rendelkezik, melynek „D” jelölése van, ezért a demópanelen kizárólag a vele

egyező „D” jelölésű aljzattal párosítható!

7.4. Jelölések a demópanelen

A demópanelen és a modulokon található aljzatokat különféle címkékkel látták el az egyszerű kezelhetőség

érdekében. E jelölések határozzák meg, hogy mely eszközök kapcsolhatók össze egymással. Minden egyes

aljzat körül található egy szám egyértelmű azonosítás céljából, valamint karakterek bizonyos sorozata az

elektronikus és kommunikációs csatlakoztathatóság meghatározásához.

7.4. ábra - Csatlakozó aljzat a demópanelen


használatába


7.5. Jelölések a próbamodulokon

A próbamodulokon szintén egy karaktersorozattal jelölik, hogy azok mely aljzatokkal párosíthatók. Az ábrán

látható XY címkéjű modul például X vagy az Y jelöléssel rendelkező aljzathoz kapcsolható a demópanelen

(tehát elég az egyik karakternek egyeznie).

7.5. ábra - Csatlakozó aljzat a próbamodulon

Előfordulhat, hogy egyes modulok csak bizonyos funkciókat használnak, a panelen találhatótovábbikarakterek

által jelzett szolgáltatást pedig nem. A csatlakoztatás során mindig ügyelni kell arra, hogy a megfelelő címkével

rendelkező csatlakozó felületeket párosítsuk.

7.6. A demópanel csatlakoztatása PC-hez

A piros modult a FEZ Spider 1-es csatlakozójához kell kapcsolni (az egyetlen aljzat, mely „D” jelzéssel

rendelkezik). A készlethez mellékelt USB kábelt csatlakoztassuk a piros modulhoz, de annak másik végét még

ne kapcsoljuk a PC-hez.

7.6. ábra - Demópanelhez kapcsolt „piros modul”


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


használatába


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

7.9. ábra - A létrehozott Gadgeteer projekt


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


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


használatába


A megjelenő ablakban bővíthetjük és módosíthatjuk a Gadgeteer sablon által létrehozott program keretet. A

program indításakor a ProgramStarted() metódus fut le először.

using System;

using System.Collections;

using System.Threading;

using Microsoft.SPOT;

using Microsoft.SPOT.Presentation;

using Microsoft.SPOT.Presentation.Controls;

using Microsoft.SPOT.Presentation.Media;

using Microsoft.SPOT.Touch;

using Gadgeteer.Networking;

using GT = Gadgeteer;

using GTM = Gadgeteer.Modules;

using Gadgeteer.Modules.GHIElectronics;


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:


{


{

button.ButtonPressed += new

Button.ButtonEventHandler(button_ButtonPressed);


}

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


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


.NETGadgeteer-el


Ezt követően készítsük el a stopper készüléket az ábrának megfelelően. Ügyeljünk arra, hogy a készülék még ne

legyen csatlakoztatva a PC-hez, illetve ne legyen áram alatt. A szükséges modulok:

• „Piros modul”

• FEZ Spider „demópanel”

• Nyomógomb

• Érintőképernyős kijelző


.NETGadgeteer-el


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


.NETGadgeteer-el


Az „Add” gombra kattintva létrejön az új kódfájl a Stopper osztály definíciójával:

8.6. ábra - Az új kódfájlban elhelyezett osztálydefiníció

A stopper állapotának reprezentáláshoz szükséges egy StopperStatus nevű enum. Két állapot vehet fel az

eszköz:

• Started: a stopper elindított állapotban van


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


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


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


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


{

stopper = new Stopper();

stopper.StopperUpdated += new

EventHandler(stopper_StopperUpdated);



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,


{

stopper.NextState();

UpdateUI();

}

Amennyiben a stopper által mért idő frissül, a StopperUpdated esemény bekövetkezik és végrehajtásra kerül a

stopper_Updated metódus, mely a felhasználói felület frissítését végzi:

void stopper_StopperUpdated(objectsender, EventArgs e)

{

UpdateUI();

}

A frissítés során meg kell jeleníteni az aktuálisan mért időt és a rögzített időket. A rajzolás a bitmap objektum

által szolgáltatott bitképre történik, majd az így elkészült kép megjelenítésre kerül a kijelzőn:

private void UpdateUI()

{

string timeText = stopper.GetTimeText();

Font font =

Resources.GetFont(Resources.FontResources.NinaB);

bitmap.Clear();

bitmap.DrawText(timeText, font, MeasuredTimeColor, 0, 0);

TimeSpan[] lastTimes = stopper.LastTimes;

for (int i = 0; i <lastTimes.Length; ++i)

{

bitmap.DrawText(stopper.Format(lastTimes[i]),

font,

LastTimesColor, 0, ((i + 2) * font.Height));

}

display.SimpleGraphics.DisplayImage(bitmap, 0, 0);

}


.NETGadgeteer-el


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


• 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


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.


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

{


{


{


}

}

}

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



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:



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,


{

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)

{



használatával


if (timer.IsRunning)

{

int intensity;

timerCount += timer.Interval.Milliseconds;

if (lightDirection ==

lightUpDownDirection.up)

intensity = (previousLightIntensity +

timerCount / 10);

else

intensity = (previousLightIntensity -

timerCount / 10);

if (intensity>Byte.MaxValue)

{

intensity = Byte.MaxValue;

timer.Stop();

}

if (intensity<Byte.MinValue)

{

intensity = Byte.MinValue;

timer.Stop();

}

lightIntensity = (byte)intensity;

setLightntensity();

renderIntensity();

}

}

A timer_Tick eseménykezelő függvény addig hívódik meg, ameddig nyomva tartjuk a kapcsolót

(érintőképernyőt), és 200ms időközönként hívódik meg. Első feladat, hogy meg kell vizsgálni, valóban fut e

még az időzítő (nyomva van-e a „gomb”) . A WPFWindow_TouchUp eseménykezelőben ugyan leállítjuk az

időzítőt, de előfordulhat, hogy ezután még egyszer kiváltódik maga az Tick esemény.

A timerCount változóhoz hozzá kell adni az eltelt időt (timer.Interval.Milliseconds), majd ez alapján ki kell

számítani a fényintenzitást (intensity) a kapcsolási iránynak megfelelően az előző intenzitást figyelembe véve.

Ha a kiszámított intenzitás eléri, vagy meghaladja az egyik szélsőértéket, akkor határolni kell, illetve leállítani

az időzítőt (mivel teljesen fel vagy le kapcsoltuk a lámpát).

Ezek után a kiszámított intenzitást át kell adni a byte típusú lightIntensity változónak, valamint utolsó lépésként

frissíteni kell a fényforrás fényességét, és ki kell írni ugyanezt a kijelzőre a setLightntensity() és

renderIntensity() függvények segítségével.

Az elkészült alkalmazásról néhány fénykép:

9.3. ábra - Teljesen kikapcsolt lámpa



használatával


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



használatával


9.5. ábra - Teljesen felkapcsolt lámpa

9.4. A teljes forráskód

using System;






using Microsoft.SPOT.Touch;

using Gadgeteer.Networking;




namespace Light_Switch

{


{

enum lightUpDownDirection

{

up,

down

}

byte lightIntensity = 0;

byte previousLightIntensity = 0;

lightUpDownDirection lightDirection = lightUpDownDirection.up;

int timerCount = 0;

GT.Timertimer;

int TimerResolution = 200;


{




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;


intensity = (previousLightIntensity + timerCount / 10);

else

intensity = (previousLightIntensity - timerCount / 10);

if (intensity>Byte.MaxValue)

{

intensity = Byte.MaxValue;

timer.Stop();

}

if (intensity<Byte.MinValue)

{

intensity = Byte.MinValue;

timer.Stop();

}

lightIntensity = (byte)intensity;

setLightntensity();

renderIntensity();

}

}

void WPFWindow_TouchUp(object sender, Microsoft.SPOT.Input.TouchEventArgs e)

{

timer.Stop();


lightDirection= lightUpDownDirection.down;

else

lightDirection = lightUpDownDirection.up;

previousLightIntensity = lightIntensity;

}

void WPFWindow_TouchDown(object sender,


{

timerCount = 0;

timer.Start();

}

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

}

void setLightIntensity()

{

led.SetBlueIntensity(lightIntensity);

led.SetRedIntensity(lightIntensity);

led.SetGreenIntensity(lightIntensity);

}

}

}



használatával


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


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.


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

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

{


{


{


}

}

}

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.


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.


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


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

{


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:


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


használatával


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


használatával


10.7. ábra - nincs találat

10.4. A teljes forráskód

using System;









namespace SD_card_reader

{


{

private Text txtMessage;

private Text txtResults;

private string[] fileExtension = {"txt,pdf"}; //"*"


{


SetupWindow();



}

private void SetupWindow()

{

Window window = display.WPFWindow;

Font baseFont = Resources.GetFont(Resources.FontResources.NinaB);


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,


{

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)


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

}

}

}

}


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

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

http://10rem.net/blog/2012/03/13/setting-up-ethernet-on-the-net-gadgeteer

http://my.safaribooksonline.com/book/-/9781449330682/4dot-web-messenger/id2837110

http://10rem.net/blog/2011/10/24/getting-started-with-the-net-gadgeteer---part-1-background-setup-and-hello-world

http://10rem.net/blog/2011/10/24/getting-started-with-the-net-gadgeteer---part-1-background-setup-and-hello-world

http://www.netmf.com/gadgeteer/

http://www.w3schools.com/tags/ref_httpmethods.asp

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 2012-10-29 (weblink:

http://www.xilinx.com/support/documentation/data_sheets/ds312.pdf)

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

http://www.xilinx.com/

http://www.xilinx.com/support/documentation/data_sheets/ds312.pdf

beágyazott rendszerek a mérnöki gyakorlatban...created by xmlmind xsl-fo converter. beágyazott...

Documents