Digitális Rendszerek

Funkcionális Egységek Előadás

A funkcionális egységek és adatfeldolgozó egységek használata megkönnyíti a digitális rendszerek
tervezését. Az eddigiekben a tervezés logikai kapuk és flip-floppok segítségével történt. A
továbbiakban komplexebb áramkörökkel foglalkozunk, amelyek építőelemei a logikai kapuk és
flip-flopok, azonban ez a fajta tervezés funkcionális egységeket, adatfeldolgozó egységeket használ
és regiszter transzfer szintű tervezésnek nevezzük.

Multiplexer Áramkör
A multiplexer a távközléstechnikából ismert, ahol néhány vonalon igen nagy számú beszédcsatornát
visznek át. A digitális multiplexer olyan áramkör, amely 2N bemenetről adatokat választ le és azokat
egyetlen kimenő vonalon továbbítja. Az adatcsatorna kiválasztása a cim/szelektor vonalak
segítségével választja ki a bemeneti csatornát, amit a kimenetre írányít.
A példában egy 4 bemenetű multiplexert mutatunk be.

Igazságtáblázat
S1 S0 Y
0 0 I0
0 1 I1
1 0 I2
1 1 I3
 Kapcsolási rajza a következő:

Általános függvény:
N
2 −1
Y = ∑ mi ∗ I i
i=0

A multiplexer is használható logikai függvények megvalósítására. A logikai függvénynek azt a

bemenetét, amelynek a megfelelő mintermjénél függvényérték logikai 0, 0 szintre, ahol 1 ott 1
logikai szintre kötjük egy ellenálláson keresztül.

Demultiplexer Áramkör
A demultiplexer N címvezeték segítségével szétosztja az egy adatvezetéken érkező
információt/adatot 2N kimenetre. Ebben az esetben egyetlen adatcsatornán érkeznek az adatok és
ezeket a demultiplexer szétosztja a megfelelő kimenetre.
A 4 bemenetű demultiplexer igazságtáblázata a következő:

Igazságtáblázat
S1 S0 Y3 Y2 Y1 Y0
0 0 0 0 0 D
0 1 0 0 D 0
1 0 0 D 0 0
1 1 D 0 0 0

Az egyes kimeneti függvények algebrai

egyenletei a következők:
Y 0= S̄ 1 ∗ S¯0 ∗ D
Y 1= S̄1 ∗ S 0 ∗ D
Y 2=S1 ∗ S 0 ∗ D
Y 3=S 1 ∗ S 0 ∗ D
A demultiplexer verilog kódja:
A demultiplexer is felhasználható logikai függvények megvalósítására. Vegyünk például egy 8
csatornás demultiplexert. Legyen a következő háromváltozós logikai függvényünk, amelyet a
mintermekkel adunk meg, majd a De Morgan szabályt alkalmazva átalakítjuk a függvényt:
3
F ( C , B , A )=m 0 +m2 +m4 +m6=m0 ∗ m2 ∗m4 ∗ m6 ;
Átalakítás után egy 4 bemenetű nand kapuval összekötjük a demultiplexer megfelelő kimeneteit,
amint azt az ábra mutatja:

Megjegyzés: A példában dekódert használtunk és az engedélyező bemenetre kötöttük az

adatbemenetet. (Ha D=0 a kimenetek 0, ha D=1 a megcímzett kimenet 1)

Regiszterek
Amennyiben a digitális rendszerekben kis mennyiségű információt kell tárolni és az információ
gyors hozzáférése szükséges, akkor a tárolásra – memóriaként – flip-flopokat használunk. Több
flip-flop csoportos alkalmazásosával, amelyeket szinkron órajellel vezérelünk regisztereket tudunk
kialakítani (ppt => 3. oldal).
A regiszterek felhasználásában betöltött szerepük alapján megkülönböztetünk: sztatikus (tároló),
léptető (shift), forgató (rotate) regisztereket. A regiszterek ugyanakkor lehetővé teszik az információ
soros-párhuzamos átalakítását.
Párhuzamos beírású regiszter
A csak párhuzamos beírású regiszterek egyenlete a következő:
Qi=Di ;
Amennyiben nem csak beírni hanem tárolni is szeretnénk az információt, akkor a regiszter
bemenetére egy 2_1 bemenetű multiplexert csatlakoztatunk, amit a „load” bemenettel vezérelünk
(ppt => 4. oldal). Ebben az esetben a párhuzamos beírású regiszter egyenlete a következő:
Qi=LD ∗ D i + LD ∗Qi ;
Ha LD=1 akkor párhuzamos beírás történik, ha LD=0 akkor adattartás van.
Példa a párhuzamos beírású regiszterre a digitális mérleg (ppt => 5. oldal). A (ppt => 6. oldal) a
sínrendszerek jelölését mutatja be. Lásd ISE sin(7:0) vagy sinr(0:7) sínrendszer esetében a sínek
súlyozása különböző:
7.bit 6.bit 5.bit 4.bit 3.bit 2.bit 1.bit 0.bit
D7 D6 D5 D4 D3 D2 D1 D0
D0 D1 D2 D3 D4 D5 D6 D7

A másik példa (ppt => 7. oldal) „Adatok a visszapillantó tükörben” egy a személygépkocsikban
használatos példa amit műszerfalba, visszapillantó tükörbe épített kijelző segítségével jelenítenek
meg. A bemeneti demultiplexerrel kiválasztjuk, hogy a pillanatnyi sebességet, a megtett utat, a
környezeti hőmérsékletet, vagy az üzemanyag átlagfogyasztását írjuk be a megcímzett regiszterbe.
Míg a kimeneten a multiplexerrel kiválasztjuk az ábrázolni kívánt paramétert.
A (ppt => 8. és 9. oldalon) egy mikroprocesszorral vezérelt elektronikus sakktábla a regiszteres
példa. A 3x8-as dekóder segítségével kiválasztjuk a megfelelő oszlopot, amelybe a tábla állapotának
megfelelően beírjuk az adatot. A (ppt => 9. oldal) a beírás ütemezését és időben történő lefolyását
ábrázolja.
Shift Regiszter (jobbra/balra shift)
A léptető (shift, helyérték toló) regisztert (ppt => 10. oldal) az információ tárolásra és helyi
értékenkénti léptetésre alkalmazzuk. A léptetés iránya szerint megkülönböztetünk jobbra, balra,
illetve kétirányú (reverzibilis) regisztereket. A jobbra léptető regiszter állapotegyenlete a következő:
n n− 1
Q i =Q i − 1 ; Q0 =0 ;
ahol az alsó index a flip-flopnak a regiszterben elfoglalt helyét, a felső index az n/n-1. órajel
utáni/előtti állapotot jelenti.
A balra léptető regiszter állapotegyenlete pedig a következő:
Qni =Qin+1
− 1 ;Q m=0

ahol m a legsúlyozottabb bit.

A shift regiszter továbbfejlesztése látható a (ppt => 11. oldal), ahol egy soros adatbemenettel
bővítettek a regisztert (lásd az alábbi algebrai egyenletet):
Qni =SHR ∗ Qn+1
i+1 + SHR ∗ Q i
n −1
;Q nm=SHR ∗ SHRIN +SHR ∗Qnm− 1 ; - jobbra shiftel
n n+1 n −1 n n −1
Q i =SHR ∗ Qi −1 + SHR ∗ Q i ; Q 0=SHR ∗ SHRIN + SHR ∗Q 0 ; - balra shiftel
ahol SHR a shiftelés vezérlő bemenet, SHRIN soros adatbemenet Qni az i-edik bit kimenete az n-edik
időpillanatban, ha SHR = 0; akkor állapottartás van; a jobra és balra shiftelés esetében az m. illetve
a 0. bit kimenetét megfelelően a SHRIN bemenetre illetve állapottartásra vezéreljük az SHR-el.
Forgató (Rotate) regiszter
A forgató regiszter (ppt => 12. oldal) abban különbözik a tolató (shift) regisztertől, hogy az lsb (less
sigificant bit - legkissebb súlyozású bit) illetve msb (most significant bit – legnagyobb súlyozású
bit) esetében nem 0 és nem soros adatbemenet kerül, hanem a megfelelő flip-flop adatbemenete
msb_din=lsb vagy lsb_din=msb az lsb/msb flip-flop kimenetéről származik.
Az állapottartás nélküli jobbra és balra forgató regiszterek egyenletei a következők:
n n− 1 n n −1
Qi =Qi − 1 ; Q0 =Qm ; - balra forgató regiszter;
Qni =Qin+1 n n −1
− 1 ; Q m=Q 0 ; - jobbra forgató regiszter;
ahol a jelölések megegyeznek az előző egyenletekben használt jelölésekkel.

Feladat: Próbálja meg leírni a jobbra/balra forgató és állapottartó regiszter egyenletét!

Többfunkciós regiszter
A (ppt => 13. oldal) visszatér az előzőekben ismertetett példára „adatok a visszapillantó tükörben”
azzal a különbséggel, hogy a jelenlegi megoldás abban különbözik az előzőtől, hogy itt az adatokat
egy soros bemeneten küldjük a regiszterek bemenetére és az adat csupán a megadott regiszterbe
léptetjük be. A párhuzamos beíráshoz (4x8 adat + 3 vezrélő jel) képest itt a vezetékek száma jóval
kisebb (1 adat és 3 vezérlő jel).
A többfunkciós regiszter (ppt => 14. oldal) regiszterek esetében a kötelező állapottartás mellett még
rendelkezhet további választható bemenetekkel (párhuzamos beírás, jobbra/balra forgatás,
jobbra/balra shiftlés, stb.). A funkció kiválasztását a multiplexer vezérlő bemeneteivel lehet
kiválasztani (S1, S0).
A regiszter által végzendő műveletek kiválasztásának egyik lehetőségét mutatja a multiplexer által
választható műveleti függvény tábla a következő:
S1 S0 Művelet
0 0 Állapótartás
0 1 Párhuzamos beírás
1 0 Jobbra shift
1 1 Most nem használt
A (ppt => 15. oldal) által mutatott többfunkciós regiszter az alábbi igazságtábla alapján tartalmazza
a teljes bekötést:

S1 S0 Művelet
0 0 Állapótartás
0 1 Párhuzamos beírás
1 0 Jobbra shift
1 1 Értéktartás
A regiszter logikai függvénye pedig:
Qni =S 1 ∗ S 0 ∗ Qni −1 +S 1 ∗ S 0 ∗ Di+ S 1 ∗ S 0 ∗ Qni+1−1 + S1 ∗ S 0 ∗Qni −1
−1
;
n n−1 n −1
Qmsb =S1 ∗ S0 ∗Qi + S 1 ∗ S0 ∗ D i + S1 ∗ S 0 ∗ SHRIN +S 1 ∗ S 0∗ Q i −1 ;
n n −1 n −1
Qi =S 1 ∗ S 0 ∗ Qi +S 1 ∗ S 0 ∗ Di+ S 1 ∗ S 0 ∗ Qi+1 + S1 ∗ S 0 ∗ SHLIN ;
ahol a jelölések a fentiek szerint értendők. Az egyenlet az i. bemenet egyenlete, míg az lsb és msb
egyenletek esetében az egyenletek a (ppt => 15. oldal) megfelelően változnak.
Tervezési Példa
Feladat: A továbbiakban bemutatjuk egy multifunkciós regiszter tervezési példáját. Tervezzük meg
a (ppt => 16. oldal) által megadott többfunkciós regiszter tervezését. A regiszter által végzett
műveletek: értéktartás, balra shift, jobbra shift, párhuzamos beírás. A regiszter legyen 3 bites.
Megoldás:
A regiszter vezérlő bemenetei ld – párhuzamos beírás, shr – jobbra shift, shl – balra shift. Ennek
alapján az elvégezhető műveletek táblája a következő:
ld(22) shr(21) shl(20) Művelet
0 0 0 Állapottartás
0 0 1 Balra shift
0 1 0 Jobbra shift
0 1 1 Jobbra shift
1 0 0 Párhuzamos beírás
1 0 1 Párhuzamos beírás
1 1 0 Párhuzamos beírás
1 1 1 Párhuzamos beírás

A regiszter funkciójának kiválasztásában elsőbbséget élvez a nagyobb súlyozású vezérlő bemenet. A

példában az ld („mindent visz”), míg az shr csupán az shl-el szemben van elsőbbsége.
A multiplexer vezérlő bemeneteinek (S) számát megkapjuk, ha az elvégzendő műveletek számának
(4) kettes alapú logaritmusát vesszük:
log 2 ( 4 )=2 ;=> a multiplexernek 2 vezérlő bemenet lesz (S1, S0). Ezért hozzárendeljük a multiplexer
vezérlő bemeneteihez a regiszter vezérlő bemenetei által mutatott funkciót. Amely megadja azt a
kombinációs hálózatot, amely kialakítja az S1 és S0 logikai egyenletét (kombinációs hálózat) az ld,
shr, shl változók függvényében.
Si=F(ld, shr, shl); aho i=0,1;

Bemenetek Kimenetek Megjegyzés

ldr shr shl S1 S0 Művelet
0 0 0 0 0 Állapottartás
0 0 1 1 1 Balra shift
0 1 0 1 0 Jobbra shift
0 1 1 1 0 Jobbra shift
1 0 0 0 1 Párhuzamos beírás
1 0 1 0 1 Párhuzamos beírás
1 1 0 0 1 Párhuzamos beírás
1 1 1 0 1 Párhuzamos beírás
Ha KV táblán ábrázoljuk a kimeneteket, akkor az S1 és S0 multiplexert vezérlő jelek logikai
egyenletei a KV tábla szerint alakulnak.
S1 shr S0 =ld∗ shr ∗ shl ;

0 1 1 1
ld 0 0 0 0
shl

S1=ld ∗ shl+ld ∗ shr =ld ∗ shl∗ ld ∗ shr ;

S0 shr
0 1 0 0
ld 1 1 1 1
shl

Ezek alapján a muliplexert vezérlő S1 és S0 a következő műveleteket végezteti a regiszterrel:

S1 S0 Művelet
0 0 Állapot tartás
0 1 Párhuzamos beírás
1 0 Jobbra shift
1 1 Balra shift

A fentiekben megtervezett többfunkciós regiszter és az S1, S2 jeleket vezérlő kombinációs hálózat

kapcsolási rajza az következő:
A (ppt => 17. oldal) azt mutatja, hogyan alakítható ki egy összevont [S1, S0] vezérlő tábla. Mivel a
vezérlés 2 hatványai szerinti súlyozású, azaz a súlyozottabb a fontosabb így ha egy súlyozottabb
vezérlő jel 1 értékű, akkor már az alacsonyabb súlyozású jel a multiplexer vezérlő jelének
alakításában közömbös lesz (lásd ppt => 17. oldal).

A (ppt => 18. oldal) a többfunkciós regiszter megtervezésének lépéseit.

A (ppt => 19. oldal) és a (ppt => 20. oldal) egy második példa a többfunkciós regiszter
megtervezésére.

Beadandó házi feladat:

Tervezzen többfunkciós regisztert, amely a következő funkciókat valósítja meg (legsúlyozottabb
funkció először): shift balra, párhuzamos beírás, jobbra forgatás, (értélemszerűen még állapottartás).
Összeadó áramkörök
Ppt => 21. oldal
Két bináris N bites szám összeadását megvalósító áramkör megtervezése több módszerrel
lehetséges. Az egyik módszer ha megterezzük az N bites számok összeadását hagyományos
kombinációs hálózat tervezésével. Ez esetben például már kétbites számok összeadása esetén még
elfogadható az igazságtábla mérete.
A bináris összeadás szabályait figyelembe véve:
0 + 0 = 0;
0 + 1 = 1;
1 + 0 = 1;
1 + 1 = 10;
Felírhatjuk az két kétbites szám összeadásának igazságtábláját:

Be Összeg
me C B1
net
0 0 0 0
ek
0 0 1 0
A A0 B B0 C S1 S0 A0
1 1 0 1 1 1
A1
0 0 0 0 0 0 0 0 0 1 1
0 0 0 1 0 0 1 B0
0 0 1 0 0 1 0
C= A1 ∗ A0 + A 0 ∗ B 1 ∗ B0 + A 1 ∗ B0
0 0 1 1 0 1 1
0 1 0 0 0 0 1 S1 B1
0 1 0 1 0 1 0 0 0 1 1
0 1 1 0 0 1 1 0 1 0 1
A0
0 1 1 1 1 0 0 1 0 1 1
A1
1 0 0 0 0 1 0 1 1 0 0
1 0 0 1 0 1 1 B0
1 0 1 0 1 0 0
1 0 1 1 1 0 1
1 1 0 0 0 1 1
1 1 0 1 1 0 0
1 1 1 0 1 0 1
1 1 1 1 1 1 0
Két N-bites szám összege mindig N+1 bites lesz. N>2 bit esetében a kombinációs tábla mérete 2N+N
sor.
Például:
(8+8)
8-bites összeadó: 2 = 65 536 sor
(16+16)
16-bites összeadó: 2 sor
32-bites összeadó: 2(32+32) sor
ppt => 23. oldal
Az egyszerű összeadó áramkör megtervezésének alapja a „paír-ceruza” algoritmus. Először
összeadjuk a legkisebb helyi értékű számjegyeket, ha van továbbvitel, azt megjegyezzük, majd a
következő számjegy következő helyi értékű számjegyeit és az alulról jövő továbbvitelt adjuk össze,
és így tovább az összeadás befejezéséig. Az alkatrész, amely ezt a számjegyenkénti (bitenkénti)
összeadást elvégzi a félösszeadó.
Félösszeadó
ppt => 25. oldal
A félösszeadó áramkör összeadja a bemenetére érkező két bitet és képezi az összeget és a
továbbvitelt.
C= A ∗ B ;
Bemenetek Összeg S= A ∗ B + A ∗ B= A ⊗ B
A B C S
0 0 0 0
0 1 0 1
1 0 0 1
1 1 1 0

Az igazságtáblázat alapján a félösszeadó

egyenletei megállapíthatóak.

A félösszeadó azonban csak két egyedülálló bit összeadására képes, a kisebb helyi érték felől érkező
átvitelt, amely a több jegyű bináris számok összeadása során megjelenhet, nem tudja figyelembe
venni. Ilyen művelet elvégzéséhez a teljes összeadó alkalmas.
Teljes Összeadó
ppt => 26. oldal
A teljes összeadó segítségével megvalósíthatók az összeadó áramkörök anélkül, hogy sok logikai
kaput használnánk fel. A teljes összeadó igazságtáblázata, algebrai egyenletei és kapcsolási rajza a
következő:

Bemenetek Összeg Co= A ∗ B+ A ∗ Ci + B ∗C i ;

S= A ⊗ B ⊗Ci ;
A B Ci Co S
0 0 0 0 0
0 0 1 0 1
0 1 0 0 1
0 1 1 1 0
1 0 0 0 1
1 0 1 1 0
1 1 0 1 0
1 1 1 1 1

Az algebrai egyszerűsítéskor felhasználjuk a következő tulajdonságot:

 A ∗ B ∗ B=A ∗ B∗ C+ A ∗ B ∗ C+ A ∗ B ∗C ;
Co= A ∗ B ∗C + A ∗ B ∗C + A ∗ B ∗C+ A ∗ B∗ C ;
Co= A ∗ B ∗ C+ A ∗ B ∗C + A ∗ B ∗C + A ∗ B ∗C+ A ∗ B∗ C+ A ∗ B ∗ C ;
Co= ( A + A ) ∗ B∗ C+ ( B+ B ) A ∗C + ( C+C ) ∗ A ∗ B ;
Co=B ∗C + A ∗C + A ∗ B ;
Hasonló módon levezethető:
S= A ⊗ B ⊗C

ppt: 27.oldal
Fél összeadó és teljes összeadó áramkör segítségével megvalósítható N-bites összeadó. Ezt a fajta
összeadót „Carry-riple” összeadónak nevezzük. Azonban előnyösebb a 0. bit félösszeadója helyett
is teljes összeadó áramkört betenni, így létrehozhatunk egy komplex áramkört, melyet majd a
kivonó áramkörök megvalósításánál is felhasználunk. Lásd:
ppt => 28. oldal
Azonban a hullám összeadónak is van hátránya. Az áramköri késleltetések miatt az msb bit n*t d
késleltetési idő után jelnitti meg a helyes eredményt. Lásd:
ppt => 29. oldal
ppt => 30. oldal
ppt => 31. oldal
A hullám összeadókat lehet kaszkádban használni, figyelem kell azonban venni a késleltetési időket.
ppt => 32. oldal, 33. oldal, 34. oldal
Példát mutat egy egyszerű összeadó számológép megvalósítására (akár ISE-vel is kipróbálható),
illetve egy alkalmazási példát mutat a 34. fólia, ahol a mérleg „0 - ázását” lehet beállítani.

Beadandó Házi Feladat

Elemezze az ISE elemkönyvtárában lévő ADD4 – négy bites összeadó felépítését. Írja le az S3, S2,
S1, S0 működési egyenleteit. (Belső felépítés megtekintése: „kat” a szimbólumra, egér jobb gomb
és symbol – push into symbol)
ppt => 35. oldal

Inkrementáló Egység
A mikroprocesszorok egyik gyakori művelete az inkrementálás, ami a fólián látható módon
valósítható meg.

Összehasonlító – komparátor egység

Két N bites szám összehasonlításakor a két szám közötti reláció érdekel minket. Például két 4 bites
szám egyenlősége esetén a bitenkénti egyenlőség kell teljesüljön:
EQ : A 3=B3 , A 2=B 2 , A1=B1 , A 0=B0 ;

Ez pedig az ekvivalencia függvénnyel valósítható meg:

Bemenet Ki
Ai Bi EQi
0 0 1
0 1 0
1 0 0
1 1 1

EQ i= A ∗ B+ A ∗ B=A ⊙ B

Két N bites szám összehasonlításakor az érdekel minket, hogy A<B? vagy A=B? vagy A>B?
ppt => 37. oldal
N bites magnitúdó komparátor tervezésekor felhasználható az az algoritmus, amely bitenkénti
összehasonlítást végez, a legsúlyozottabb bitektől (msb) a legkevésbé súlyozottabb bitekig (lsb).
Egyenlőség esetén mint az előzőekben már bemutattuk, hogy minden bitnek egyenlőnek kell lennie,
a nagyobb és a kisebb reláció esetében addig kell végezni az összehasonlítást, míg valamelyik (i)
bitenkénti összehasonlításkor különbséget nem észlelünk.
Egy ilyen magnitúdó komparátort mutat be:
ppt => 38. oldal,
ahol két négy bites számot hasonlítunk össze. A felhasznált egy bitet összehasonlító egység
megtervezésekor figyelembe kell vennünk a felülről érkező összehasonlítási eredményt.
Mivel a felülről jövő összehasonlítási (GT – nagyobb, EQ – egyenlő, LT – kisebb) eredmények
egymást kizárják, ezért egy ilyen egység igazságtáblázata a következő:
ppt => 39. oldal,

Bemenetek Komparátor ki GTo=GTi+GTi ∗ EQ ∗ A ∗ B ;

EQo=EQi∗ A ⊗ B ;
GTi EQi LTi Ai Bi GTo EQo LTo LTi=LTi+GTi ∗ EQi∗ A ∗ B ;
0 0 1 0 0 0 0 1
Azonban, ha a relációkat szigorúan vesszük
0 0 1 0 1 0 0 1
azaz nem engedjük meg a A ⩽ B vagy A ≥ B
0 0 1 1 0 0 0 1 relációkat, akkor a fenti egyenletek
0 0 1 1 1 0 0 1 egyszerűbbek lehetnek, úgy ahogyan a fólia
mutatja.
0 1 X 0 0 0 1 0
0 1 X 0 1 0 0 1 GTo=GIi+ EQ ∗ A ∗ B ;
EQo=EQi ∗ A ⊗ B ;
0 1 X 1 0 1 0 0 LTi=LTi+ EQi ∗ A ∗ B ;
0 1 X 1 1 0 1 0
1 X X 0 0 1 0 0 Nézzük meg a következő fólián lévő példát!

1 X X 0 1 1 0 0
1 X X 1 0 1 0 0
1 X X 1 1 1 0 0
Az igazságtábla szerinti komparátor algebrai
egyenletei az alábbiak szerint alakulnak:

ppt => 40. oldal, 41. oldal:

Jó példa erre két szám bináris szám 4'B1011 és 4'B1001 összehasonlításakor figyelembe kell
vennünk a komparátor megvalósításánál az msb bit esetében, hogy GTi=0, EQi=1, LTi=0. Az
eredmény a komparátor jobb oldalán a kimeneten jelenik, meg az egyes komparátor egységek
összesített késleltetési ideje után (td=n*tdi).
ppt => 42. oldal
Példa magnitúdó komparátorral két 8 bites bináris szám minimum (A, B) megadó függvény
megvalósítására. Ahogyan az ábra mutatja a komparátor reláció bemeneteit GTi=0, EQi=1, LTi=0
logikai szintre rögzítjük. A komparátor A< B kimenetét pedig felhasználjuk egy két bemenetű
multiplexer vezérlésére. Amennyiben (A < B) => min(A, B)=A VAGY HA (A=B) ÉS (A>B) =>
min(A,B) = B;
ppt => 43. oldal

Szorzó egység
A szorzás hagyományosan történő megvalósítása esetében figyelembe kell vennünk, hogy:
0x0=0
0x1=1x0=0
1x1=1
A szorzási művelet megvalósításához az ÉS kapcsolatot használjuk. Ahogyan annak idején
tanították az elemi osztályban a szorzás megvalósítható ÉS kapcsolatokkal és összeadó
áramkörökkel. (lásd ppt => 43. oldal és hálózat 45. oldal)
lásd ppt => 43. oldal
Amint az észrevehető a szorzás hagyományos úton történő megvalósítása bonyolult és nagy logikai
erőforrásokat emészt föl (lásd következő fólia).
ppt => 45. oldal
Az összeadó hálózat esetében a a bemenetek megfelelő eltolással vannak bekötve, az egyes al-
szorzatok eltolása miatt.
ppt => 46. oldal
Kivonó egység
A kivonás is megvalósítható kombinációs hálózattal, hasonló módon mint a teljes összeadó áramkör
esetében – ennek ismertetésétől eltekintünk. A kivonás megvalósításakor a kölcsönvétel (borrow) az
amit figyelembe kell venni a teljes kivonó áramkör ilyenfajta megvalósításakor.
ppt => 47. oldal
A mellékelt példa egy 8 bites összeadó-kivonó áramkört valósít meg. A megoldás tartalmaz egy
összeadó és egy kivonó áramkört. A művelet eredményének kiválasztását a választó multiplexer
segítségével valósul, majd az eredményt tároljuk egy regiszterben.
Ez a fajta megoldás igen pazarló, mivel párhuzamosan végezzük az összeadást és a kivonást is.
ppt => 48. oldal – 51. oldal
A kivonás alkalmazására példa a színes nyomtató festékkeverésének megvalósítása.
ppt => 52. oldal – 56.oldal
Negatív számok ábrázolása – Kettes komplemens
A kettes komplemens segítségével negatív számokat ábrázolhatunk. A kettes komplemenst úgy
képezzük, hogy bitenként invertáljuk a binárisan ábrázolt számot, majd hozzáadunk 1-et.
Pl: 01001 (+9) => 10110 => 10110 + 1 =10111 (-9)
ppt => 57. oldal – 58.oldal

Összeadó/kivonó áramkör
ppt => 61. oldal – 62.oldal

Túlcsordulás érzékelés
1. és 2. módszer
ppt => 63. oldal – 67.oldal

Aritmetikai-Logikai egység
ppt => 68. oldal – 72.oldal
Shift regiszteres szorzás, osztás, Barrel shifter
ppt => 73. oldal – 83.oldal

Számláló egységek
N-bites előre számláló: incrementer +shift regiszter; túlcsordulás (Carry) jelzése AND kapuval,
Vezérlőjelek: clr – törlés, cnt – számlálás engedélyezés, clk órajel; Példa: utasszámláló
Előre/vissza számláló: incrementer vagy dekrementer + shift regiszter; túlcsordulás jelzése AND
kapuval, alul csordulás (borrow) NOR kapuval,
Vezérlőjelek: dir számlálási irány, clr -törlés (reset), cnt (ld) számlálás engedélyezés, clk – órajel;
Betölthető számláló: ld -re adott ld jel a bemeneten (d) adatot betölti a regiszterbe és innen indul a
számlálás. Példa: párhuzamos beírású számláló; BÚÉK számlálás – tűzijáték indítás;
Számláló alkalmazása: frekvencia osztó; Példa 6 bites előre számláló digitális óra (perc, óra, stb.),
sebesség mérés,
Számláló alkalmazása: Időzítő; Példa: Lézeres sebészeti rendszer.

Tervezés számláló áramkörökkel

Tervezzük meg CB4CLED számlálóval a következő állapotgráf által megadott sorrendi hálózatot.

S0 S1 S2 S3

S1
S11 S9 S8
0

S1 S1 S1 S1
5 4 3 2

S4 S5 S6 S7

Mivel 16 állapotunk van ezért a jól ismert képlet alapján (log 2N=log216=4) megállapítható, hogy
egy számlálóra van szükségünk.
Először megvizsgáljuk a számláló adatlapját, amelynek segítségével megállapítjuk a számláló
működését és a tervezéshez szükséges jeleket (bemenetek, kimenetek).

A számláló logikai táblájából (lásd lenti táblázat), megállapítható, hogy a számláló 4 bites.
Jelek:
CLR – clear törlés – ha CLR=1 => Qi=0, TC=0, CEO=0; ha CLR=1 a számláló működik a vezérlő
jelek állapota alapján
L – load betöltés – ha L=1 => Qi=Di CLK felfutó élre! ; ha L=0 => számlálás
CE – órajel engedélyezés – ha CE=0 nincs változás; ha CE =1 működés engedélyezése
C – órajel felfutó élre vezérel
UP – számlálás iránya – ha UP=1 => Q=Q+1 inkrementál, ha UP = 0 => Q=Q-1;
TC – túlcsordulás: egyenletét lásd a táblázatban 0-1-0 impulzust ad ha Q=> 1111 => 0000 vagy Q
=> 0000 => 1111 változás történik;
CEO=TC*CE kaszkád a következő számláló egység felé.
Állapottábla

Jelenlegi állapotok Következő állapotok Vezérlő függvények

Qi Q3 Q2 Q1 Q0 Q3+ Q2+ Q1+ Q0+ UP L D3 D2 D1 D0
0 0 0 0 0 0 0 0 1 1 0 X X X X
1 0 0 0 1 0 0 1 0 1 0 X X X X
2 0 0 1 0 0 0 1 1 1 0 X X X X
3 0 0 1 1 1 0 0 0 1 1 1 0 0 0
4 0 1 0 0 0 0 0 0 0 1 0 0 0 0
5 0 1 0 1 0 1 0 0 0 0 X X X X
6 0 1 1 0 0 1 0 1 0 0 X X X X
7 0 1 1 1 0 1 1 0 0 0 X X X X
8 1 0 0 0 1 0 0 1 1 0 X X X X
9 1 0 0 1 1 0 1 0 1 0 X X X X
10 1 0 1 0 1 0 1 1 1 0 X X X X
11 1 0 1 1 1 1 1 1 1 1 1 1 1 1
12 1 1 0 0 0 1 1 1 0 1 0 1 1 1
13 1 1 0 1 1 1 0 0 0 0 X X X X
14 1 1 1 0 1 1 0 1 0 0 X X X X
15 1 1 1 1 1 1 1 0 0 0 X X X X

UP Q1 D3 Q1
1 1 1 1 X X 1 X
0 0 0 0 0 X X X
Q2 Q2
0 0 0 0 0 X X X
Q3 Q3
1 1 1 1 X X 1 X
Q0 Q0
UP=[ Q 2 ] D 3=Q 1

D2 Q1
L Q1 X X 0 X
0 0 1 0 0 X X X
Q2
1 0 0 0 1 X X X
Q2 Q3
1 0 0 0 X X 1 X
Q3
0 0 1 0 Q0
Q0 D 2=D 1=D 0=Q3
L=Q 2 ∗Q 1+ Q2 ∗Q 1=Q 2 ⊕Q1
CE=1
Megvalósítás:

Megjegyzés: A szimuláció során megfigyelhető, hogy az órajel frekvenciája mennyire befolyásolja

az áramkör működését.
Tervezési példa 2.

RESET

S0 S1 S2 S3

SD SC SB S4

SE SF
 Jelenlegi állapotok Következő állapotok Vezérlő függvények
Qi Q3 Q2 Q1 Q0 Q3+ Q2+ Q1+ Q0+ UP L D3 D2 D1 D0
0 0 0 0 0
1 0 0 0 1
2 0 0 1 0
3 0 0 1 1
4 0 1 0 0
5 0 1 0 1
6 0 1 1 0
7 0 1 1 1
8 1 0 0 0
9 1 0 0 1
10 1 0 1 0
11 1 0 1 1
12 1 1 0 0
13 1 1 0 1
14 1 1 1 0
15 1 1 1 1

UP Q1 D3 Q1 D1 Q1

Q2 Q2 Q2
Q3 Q3 Q3

Q0 Q0 Q0

L Q1 D2 Q1 D0 Q1

Q2 Q2 Q2
Q3 Q3 Q3

Q0 Q0 Q0
Megtervezett áramkör:

Elemzés:

Regiszter Tömbök