ARHITEKTURA MIKROSISTEMA

- Materijal za pripremu ispita -

SMER: Elektoronska kola i sistemi, IV semestar
Godina: 2006
 SADRŽAJ

1 Uvod u projektovanje digitalnih sistema ...................................................4

1.1 IC tehnologije ......................................................................................................................................5
1.2 Domeni projektovanja .........................................................................................................................7
1.3 Nivoi apstrakcije..................................................................................................................................7
1.4 Proces projektovanja............................................................................................................................8
1.5 Jezici za opis hardvera .......................................................................................................................12

2 VHDL ..........................................................................................................15
1.1 Uvod............................................................................................................ Error! Bookmark not defined.
2.1.1 Struktura VHDL kôda ..............................................................................................................15
2.1.2 Stilovi projektovanja ................................................................................................................18
2.2 Tipovi podataka .................................................................................................................................23
2.2.1 Objekti podataka ......................................................................................................................23
2.2.2 Predefinisani tipovi podataka ...................................................................................................23
2.2.3 Korisnički tipovi podataka .......................................................................................................26
2.2.4 Podtipovi ..................................................................................................................................27
2.2.5 Polja .........................................................................................................................................27
2.2.6 Polja portova ............................................................................................................................29
2.2.7 Označeni i neoznačeni tipovi podataka ....................................................................................29
2.2.8 Konverzija podataka.................................................................................................................30
2.3 Operatori i atributi .............................................................................................................................31
2.3.1 Operatori ..................................................................................................................................31
2.3.2 Atributi .....................................................................................................................................34
2.3.3 Korisnički-definisani atributi ...................................................................................................35
2.3.4 Preklapanje operatora...............................................................................................................36
2.3.5 GENERIC ................................................................................................................................36
2.3.6 Primeri......................................................................................................................................37
2.3.7 Pregled operatora i atributa ......................................................................................................40
2.4 Konkurentni kôd ................................................................................................................................41
2.4.1 Konkurentni i sekvencijalni kôd...............................................................................................41
2.4.2 Konkurentna naredba dodele....................................................................................................41
2.4.3 WHEN......................................................................................................................................42
2.4.4 GENERATE.............................................................................................................................50
2.5 Sekvencijalni kôd...............................................................................................................................52
2.5.1 PROCESS ................................................................................................................................52
2.5.2 Signali i varijable .....................................................................................................................53
2.5.3 IF ..............................................................................................................................................54
2.5.4 WAIT .......................................................................................................................................56
2.5.5 CASE .......................................................................................................................................57
2.5.6 LOOP .......................................................................................................................................59
2.5.7 Sekvencijalni kôd za kombinaciona kola .................................................................................63
2.5.8 Leč kola i flip-flopovi ..............................................................................................................65
2.6 Signali i varijable...............................................................................................................................66
2.6.1 CONSTANT ............................................................................................................................66
2.6.2 SIGNAL ...................................................................................................................................67
2.6.3 VARIABLE .............................................................................................................................68
2.6.4 Poređenje signala i varijabli .....................................................................................................68
2.6.5 Sinteza registara .......................................................................................................................70
2.7 Konačni automati...............................................................................................................................75
2.7.1 Kôdni šablon #1 .......................................................................................................................76
2.7.2 Konačni automati Murovog tipa ..............................................................................................77
2.7.3 Konačni automati Milijevog tipa..............................................................................................82
2.7.4 Kôdni šablon #2 .......................................................................................................................85
2.7.5 Kodiranje stanja .......................................................................................................................87

2
 2.7.6 Algoritamske mašine stanja .....................................................................................................88
2.8 Memorijske komponente ...................................................................................................................93
2.9 Paketi i komponente ..........................................................................................................................96
2.9.1 PACKAGE...............................................................................................................................96
2.9.2 COMPONENT.........................................................................................................................98
2.9.3 PORT MAP............................................................................................................................102
2.9.4 GENERIC MAP.....................................................................................................................102
2.9.5 GENERATE naredba u strukturnom opisu ............................................................................106
2.10 Funkcije i procedure ........................................................................................................................108
2.10.1 Funkcije..................................................................................................................................108
2.10.2 Pozicija funkcije.....................................................................................................................110
2.10.3 Procedure ...............................................................................................................................114
2.10.4 Pozicija procedure..................................................................................................................115
2.10.5 Poređenje funkcija i procedura...............................................................................................117
2.10.6 ASSERT.................................................................................................................................117

3 RTL projektovanje...................................................................................118
3.1 Projektovanje odozgo-naniže...........................................................................................................118
3.2 Opis ponašanja.................................................................................................................................118
3.2.1 Interfejs ..................................................................................................................................118
3.2.2 Konverzija algoritma u ASM dijagram ..................................................................................121
3.2.3 ASM dijagrami Milijevog tipa ...............................................................................................127
3.3 Razrada ............................................................................................................................................131
3.4 Realizacija .......................................................................................................................................136

4 Komponente digitalnih sistema...............................................................149

4.1 Kombinacione komponente .............................................................................................................149
4.1.1 Dekoderi.................................................................................................................................149
4.1.2 Multiplekseri ..........................................................................................................................154
4.1.3 Demultiplekseri ......................................................................................................................157
4.1.4 Koderi.....................................................................................................................................158
4.1.5 Komparator magnitude...........................................................................................................160
4.1.6 Kombinacioni pomerači i rotatori ..........................................................................................163
4.2 Aritmetička kola ..............................................................................................................................166
4.2.1 Sabirač sa rednim prenosom ..................................................................................................166
4.2.2 Brzi sabirači ...........................................................................................................................176
4.2.3 Logička jedinica .....................................................................................................................180
4.2.4 Aritmetičko-logička jedinica..................................................................................................181
4.2.5 Množači (*) ............................................................................................................................184
4.2.6 Specifični formati za predstavljanje brojeva ..........................................................................184
4.3 Sekvencijalne komponente ..............................................................................................................190
4.3.1 Flip-flopovi (*).......................................................................................................................190
4.3.2 Registarske komponente ........................................................................................................192

3
1 Uvod u projektovanje digitalnih sistema
Od vremena prvih digitalnih kola do danas, broj tranzistora koji se mogu integrisati na jednom integrisanom
kolu (IC) rastao je eksponencijalno. Sa takvim tempom razvoja, danas srećemo digitalna IC sa više stotina, više
hiljada, pa sve do više stotina miliona tranzistora. U prošlosti, digitalna kola su nalazila glavnu primenu u
računarskim sistemima. Međutim, vremenom, kako su digitalna IC postajala sve manja, brža, sa sve većim
mogućnostima i u isto vreme sve jeftinija, mnogi elektronski, komunikacioni i upravljački sistemi su interno
˝digitalizovani˝ korišćenjem digitalnih kola za memorisanje, obradu i prenos informacija.
Kako su primene postajale veće i složenije, tako je zadatak projektovanja digitalnih kola i sistema postajao sve
teži. Praktično je nemoguće na nivou tranzistora, pa čak ni na nivou logičkih kola, projektovati digitalni sistem
čija je složenost veća od nekoliko hiljada tranzistora. Tako složeni sistemi se moraju projektovati na višem
nivou apstrakcije, uz korišćenje softverskih alata za projektovanje. Zadatak projektanta je da osmisli sistem i
formalno ga opiše, a zadatak softverskog alata da izvrši sintezu sistema, tj. transformiše apstraktni opis u oblik
pogodan za direktnu realizaciju.
Osnovna tema ovog kursa je proučavanje tehnika projektovanja i sinteze digitalnih sistema na registarskom
nivou apstrakcije, tj. na RTL (Register-Transfer Level), odnosno mikro-arhitekturalnom nivou. Na ovom nivou,
projektant konstruiše sistem pomoću modula kao što su: aritmetičke jedinice (sabirač, komparator), registarske
komponente (registri, brojači), i drugi kombinacioni (multiplekser, dekoder) i sekvencijalni moduli (konačni
automati). Na RTL nivou, sistem se opisuje u jeziku za opis hardvera (HDL - Hardware Description Language),
kao što je VHDL ili Verilog. Takav jedan opis ima dvostruku namenu. Prvo, služi kao ulaz u HDL simulator
pomoću kojeg je moguće verifikovati funkcionalnost sistema pre izvršene realizacije. Drugo, koriste se kao ulaz
u softverski alat za sintezu digitalnog hardvera. U ovom predmetu, izučavaćemo jezik VHDL sa naglaskom na
korišćenje u cilju sinteze.
Na Sl. 1-1 prikazan je dijagram koja ukazuje na međuzavisnosti i uslovljenosti različitih teorijskih osnova,
tehnika i metoda koje čine osnovu projektovanja savremenih digitalnih sistema. Osenčena oblast na Sl. 1-1
ukazuje na materiju obuhvaćenu ovim predmetom.
Uopšteno govoreći, projektovanje elektronskih kola i sistema kreće od fizike čvrstog stanja i tehnoloških
postupaka za fabrikaciju poluprovodničkih integrisanih kola, koji određuju tipove i osobine većine osnovnih
elektronskih komponenti, kao što su tranzistori, otpornici i kondenzatori. Ove komponente se zatim povezuju u
digitalna ili analogna kola, shodno osnovnim zakonima elektronike. Digitalna kola procesiraju signale koji
mogu imati samo mali broj fiksnih vrednosti, obično dve, što ih čini robusnim i lakim za projektovanje. Ove dve
osobine su glavni razlog zbog kojeg se danas za obradu informacija prevashodno koriste digitalna kola.
Sa druge strane, analogna kola obrađuju signale koji mogu imati bilo koju vrednost unutar datog opsega. Većina
signala koje čovek generiše ili prepoznaje, kao što je tekst, govor, slika i zvuk su analogni signali. Pošto se
celokupno procesiranje izvodi u digitalnom domenu, jedan generalni elektronski sistem najpre konvertuje
analogne signale u digitalne, zatim u digitalnom domenu obavlja sva potrebna izračunavanja, transformacije i
komunikacije, da bi konačno, rezultat konvertovao nazad u analogni domen. Konverzija iz analognog u digitalni
domen i obrnuto se obavlja uz pomoć interfejsnih kola, kao što su A/D i D/A konvertori.
Digitalno projektovanje kreće od nivoa gejtova (logičkih kola) i flip-flopova. Šta više, projektant digitalnog
hardvera ne mora da poznaje detalje koji se odnose na fabrikaciju logičkih komponenti i VLSI projektovanje,
već je njegov zadatak da koristeći raspoložive komponente kreira opis sistema kojeg projektuje. Teorijsku
osnovu digitalnog projektovanja čini Bulova algebra i teorija konačnih automata, što je u bliskoj vezi sa
načinima reprezentacije podataka u binarnom brojnom sistemu. Koristeći tehnike logičkog projektovanja,
kreiraju se kombinacioni i sekvencijalni moduli, koji predstavljaju bazične gradivne blokove procesorskih
komponenti. Projektovanje procesorskih komponenti zasnovano je funkcionalnom opisu u vidu dijagrama toka
ili kôda u jeziku za opis hardvera (kao što je VHDL). Standardne i specijalizovane procesorske komponente,

4
zajedno sa interfejsnim komponentama i elektro-mehaničkim uređajima, kao što su hard-disk i tastatura koriste
se za projektovanje različitih tipova računarskih sistema opšte i posebne namene, kao što su personalni računari,
radne stanice i komunikacioni kontroleri. Računarski sistemi se dalje koriste za projektovanje složenijih, tzv.
embedded sistema koji se primenjuju u oblastima kao što su digitalna obrada signala, robotika, komunikacije,
medicinska instrumentacija, multimedija i mnoge druge.

Sl. 1-1 Mapa procesa projektovanja elektronskih, digitalnih i računarskih sistema.

Razvoj i realizacija digitalnih sistema je složen proces, koji se ostvaruje kroz veći broj međusobno zavisnih
aktivnosti. RTL projektovanje i sinteza su samo dve aktivnosti u tom procesu. U nastavku ovog poglavlja biće
dat sažet pregled implementacionih tehnologija, sistemskih reprezentacija, nivoa apstrakcije i softverskih alata
koji će nam pomoći da sagledamo mesto i ulogu RTL projektovanja i sinteze u celokupnom razvojnom procesu
digitalnih sistema.

1.1 IC tehnologije
Fabrikacija integrisanih kola
Integrisano kolo je sačinjeno od slojeva dopiranog silicijuma, polisilicijuma, metala i silicijum dioksida
poređanih jedan iznad drugog na silicijumskom podlozi. Na nekim od ovih slojeva formiraju se tranzistori dok
se drugi koriste za izvođenje provodnika za povezivanje tranzistora. Osnovni korak u fabrikaciji IC-a je
formiranje jednog sloja, procesom koji se zove litografija. Raspored materijala na jednom sloju definisan je
maskom. Slično fotografskom filmu, maska se koristi da bi se određene oblasti na površini silicijuma izložile
dejstvu hemikalija u cilju kreiranja različitih slojevi materijala na površini jednog sloja. Izgled maske se naziva

5
layout-om. Savremene IC tehnologije koriste od 10 do 15 slojeva, što znači da u toku fabrikacije jednog
integrisanog kola, litografski proces mora biti ponovljen 10 do 15 puta, uvek sa različitom maskom.
Važan parametar poluprovodničke tehnologije je dužina najmanjeg tranzistora koji se može realizovati u datoj
tehnologiji (obično izražena u mikronima - milioniti deo metra). Sa napretkom poluprovodničke tehnologije,
veličina tranzistora se neprekidno smanjivala i danas se približava dužini od 1/10 mikrona.
Klasifikacija IC tehnologija
Digitalna kola se mogu realizovati u različitim implementacionim, tzv. IC tehnologijama. Jedna od glavnih
karakteristika svake IC tehnologije je način na koji se obavlja prilagođenje ili dorada IC-a u cilju realizacije
željene funkcije. Da bi se smanjili troškovi proizvodnje, kod nekih IC tehnologija veći broj slojeva se uvek
izvodi na isti način, pomoću istih maski, nezavisno od funkcije koju IC treba da realizuje, dok se preostale
maske kreiraju u skladu sa zahtevima konkretne primene. Proces dorade je složen i skup, i može se obaviti samo
u fabrici poluprovodnika. Naručilac IC-a dostavlja fabrici poluprovodnika specifikaciju IC-a u odgovarajućem
obliku, na osnovu koje se u fabrici kompletira set maski, a zatim fabrikuju IC i isporučuju naručiocu. Kod
drugih IC tehnologija, fabrika poluprovodnika isporučuje naručiocima univerzalna IC, koja nemaju unapred
definisanu funkciju, ali se zato mogu programirati. Programiranje vrši sam korisnik, ˝na terenu˝, punjenjem
konfiguracionih podataka u internu memoriju IC-a ili ˝sagorevanjem internih silicijumskih osigurača˝. Prva
grupa IC, koja se dorađuju u fabrici, poznata su pod skraćenicom ASIC, koja potiče od pojma aplikaciono-
specifična IC (Application-Specific Integrated Circuit). Druga grupa IC, koje prilagođava, tj. programira, krajnji
korisnik, poznata su kao programabilne logičke komponente, ili PLD, od Probrammable Logic Devices. Svaka
od ove dve grupe sadrži više specifičnih tehnologije. Tako, ASIC tehnologije se dele na:
IC ˝potpuno po narudžbi˝ (full-custom). Ne koriste se prefabrikovane maske ili slojevi, već se IC ˝iz
početka˝, do nivoa pojedinačnih tranzistora i veza, projektuje i proizvodi za tačnu određenu primenu.
Omogućava integraciju najvećeg broja tranzistora i realizaciju IC-a najveće brzine rada. Međutim, s
obzirom da je projektovanje na nivou tranzistora složeno i dugotrajno, full-custom tehnologija se koristi
samo za IC male složenosti ili za projektovanje bazičnih logičkih komponenti koje se mogu koristiti za
realizaciju većih sistema.
Standardne ćelije (semi-custom). Deo troškova koji prati projektovanje IC potpuno po narudžbi može se
izbeći ako se koristi tehnologija standardnih ćelija (standard cell). Standardne ćelije su moduli
jednostavne funkcije (tipa NOT, AND, OR, NAND, flip-flop i slična), unapred projektovani do nivoa
layout-a, koje se u vidu gradivnih blokova koriste za konstrukciju složenijih struktura na čipu. U poređenju
sa full-suctom tehnologijom, projektovanje je značajno pojednostavljeno, jer projektant umesto na nivou
tranzistora, sistem projektuje na nivou logičkih kola. Međutim, iako je layout pojedinačnih standardnih
ćelija unapred definisan, layout kompletnog IC zavisi od rasporeda i povezanosti standardnih ćelija. Zbog
toga je proces fabrikacija identičan kao kod full custom tehnologije - svi slojevi se iznova kreiraju za svako
novo IC.
Gejtovska polja (gate array). Tehnologija gejtovskih polja zasnovana je na korišćenju polu-fabrikovanih
integrisanih kola. U gejtovskom polju, pojedini delovi čipa su unapred fabrikovani dok se preostali
dorađuju shodno zahtevima konkretne primene. Kod tehnologije gejtovskih polja, proizvođači sprovode
najveći broj koraka, tipično one koji se tiču kreiranja tranzistora, unapred, nezavisno od ciljne primene.
Rezultat je silicijumska pločica nedovršenog čipa. Tipično, gejtovsko polje čini veliki broj identičnih
gejtova raspoređenih na silicijumskoj pločici u vidu regularne dvodimenzione matrice. Gejtovi su obično 3-
ili 4-ulazna NI ili NILI kola, a na jednoj pločici ih može biti i do više miliona. Naknadnom doradom, koja
podrazumeva kreiranje metalnih veza, gejtovi se povezuju na način koji diktira konkretna primena. Ušteda
u proizvodnji, u odnosu na tehnologiju standardnih ćelija, se postiže zato što proizvođač može da
amortizuje cenu fabrikacije gotovih čipova masovnom proizvodnjom polufabrikovanih, identičnih pločica
gejtovskih polja.
Programabilne logičke komponente se dele na:
SPLD (od Simple PLD - Jednostavne PLD komponente). U ovu grupu PLD komponenti spadaju
programabilne strukture kao što su: PLA, PAL i PROM. Koncept SPLD kola zasnovan je na činjenici da se
bilo koja logička funkcija može realizovati u vidu zbira logičkih proizvoda. S toga, glavni deo SPLD kola
čine dve logičke mreže: AND mreža u kojoj se formiraju logički proizvodi i OR mreža na čijim izlazima se
dobijaju logičke sume proizvoda formiranih u AND mreži. Kod PLA obe mreže su programabilne, kod
PAL-a AND mreža je progrmabilna, a OR fiksna, dok je kod PROM-a AND mreža fiksna, a OR
programabilna. Danas se SPLD komponente više ne proizvode u vidu integrisanih kola, već se koriste kao
unutrašnji blokovi ASIC IC ili složenijih tipova PLD kola.

6
 CPLD (od Complex PLD - Složene PLD komponente). Sadrži veći broj programabilnih logičkih blokova
spregnutih putem centralizovane programabilne prekidačke matrice. Svaki programabilni logički blok po
strukturi je sličan PLA ili PAL. Programiranjem CPLD komponente definiše se kako funkcija logičkih
blokova tako način na koji su logički blokovi međusobno povezani.
FPGA (od Field-Programmable Gate Array) Arhitektura FPGA kola nije zasnovana na prekidačkim
mrežama, kao što je to slučaj sa SPLD i CPLD komponentama. Umesto toga, kod FPGA se za realizaciju
logičkih funkcija koriste logičke ćelije koje nalikuju ćelijama gejtovskog polja i tipično sadrže D flip-flop i
tzv. look-up tabelu (u obliku RAM-a malog kapaciteta) za realizaciju logičkih funkcija. Logičke ćelije su
raspoređene u dvodimenziono polje, dok su veze i prekidači smešteni u horizontalnim i vertikalnim
kanalima za povezivanje. Kanali sadrže veze i programabilne prekidače putem kojih se ostvaruje željeno
interno povezivanje logičkih ćelija.
Savremena FPGA kola omogućavaju realizaciju digitalnih sistema složenosti od nekoliko desetina hiljada
do nekoliko miliona ekvivalentnih gejtova. Sa tako velikim logičkim kapacitetom na raspolaganju, primena
FPGA kola nije ograničena samo na realizaciju relativno jednostavnih digitalnih struktura, kao što je to
slučaj kod SPLD i CPLD, već pružaju mogućnost realizacije kompletnih sistema na jednom čipu
zasnovanih na mikroprocesoru.

1.2 Domeni projektovanja

Projektovanje digitalnih sistema se ostvaruje u tri različita domena, kojima odgovaraju tri različita načina
predstavljanja (reprezentacije) sistema:
- funkcionalni,
- strukturni i
- fizički.
Funkcionalni (ili bihejvioralni) domen je onaj u kome se na sistem gleda kao na crnu kutiju, a projektant je
fokusiran na opis ponašanja sistema u funkciji ulaza i proteklog vremena. Drugim rečima, projektant opisuje šta
sistema radi (treba da radi), ali ne i kako sistem treba realizovati. Cilj je definisati odziv sistema na bilo koju
kombinaciju vrednosti ulaznih promenljivih. Projektanti se bave razradom algoritma rada sistema i definišu
kako sistem interaguje sa svojim okruženjem. Rezultat projektovanja je funkcionalna reprezentacija sistema,
koja može biti data u obliku dijagrama toka, programa u višem programskom jeziku, opisa u jeziku za opis
hardvera, matematičke formule, grafikona i sl.
Strukturni domen je onaj u kome se sistem razlaže na skup komponenti i njihovih veza. Projektovanje treba da
da odgovor na pitanje: kako pomoću raspoloživih komponenti realizovati sistem koji će ostvariti zadatu
funkciju. Rezultat projektovanja je strukturna reprezentacija sistema koja može biti data u obliku blok
dijagrama koji prikazuje komponente sistema i njihove veze, šematskog prikaza mreže logičkih kola, ili mreže
tranzistora.
Konačno, fizički domen je onaj u kome se definišu fizičke karakteristike sistema, koje se odnose na dimenzije i
poziciju svake pojedinačne komponente i veze sadržane u strukturnom opisu. Projektovanje u ovom domenu
polazi od strukturne reprezentacije, a bavi se fizičkim raspoređivanjem i povezivanjem komponenti. Rezultat
projektovanja je fizička reprezentacija sistema u obliku layout-a čipa, mehaničkih crteža ili crteža štampane
ploče. Fizička reprezentacija predstavlja konačni produkt projektovanja u obliku proizvodne dokumentacije na
osnovu koje se može direktno realizovati sistem ili fabrikovati čip.

1.3 Nivoi apstrakcije

Projektovanje elektronskih sistema se može obavljati na nekoliko različitih nivoa apstrakcije ili nivoa
detaljnosti, gde je svaki nivo definisan tipom gradivnih elemenata (komponenti) koji se u njemu koriste. U
opštem slučaju, kod elektronskih sistema mogu se identifikovati sledeća četiri nivoa apstrakcije, počev od
najnižeg:
- nivo tranzistora,
- nivo gejtova,
- registarski nivo i
- nivo procesora
Pregled nivoa apstrakcije dat je u sledećoj tabeli, ilustracija na Sl. 1-2:

7
Nivo apstrakcije Bihejvioralna Strukturne komponente Fizički objekti
reprezentacija
Tranzistorski nivo Diferencijalne jednačine, U-I Tranzistori, otpornici, Analogne i digitalne
dijagrami kondenzatori ćelije
Nivo gejtova Logičke funkcije, konačni Logička kola, flip-flopovi Moduli, funkcionalne
automati jedinice
Registarski nivo Algoritmi, dijagrami toka, Sabirači, komparatori, registri, Čipovi
(RTL) ASM dijagrami brojači, multiplekseri
Sistemski nivo Izvršna specifikacija, Procesori, kontroleri, memorije, Štampane ploče,
programi ASIC kola mikročip-moduli

Nivo tranzistora Nivo gejtova

Registarski (RTL) nivo Nivo procesora

Sl. 1-2 Nivoi apstrakcije.

Kao što se može uočiti iz gornje tabele, glavne komponente na tranzistorskom nivou su tranzistori, otpornici i
kondenzatori, koji se povezuju u analogna ili elementarna digitalna kola. Na nivou tranzistora, funkcionalnost
realizovanih kola obično se opisuje diferencijalnim jednačinama ili nekom vrstom prenosne karakteristike koja
pokazuje zavisnost između napona i struja u kolu (U-I dijagrami). Fizička reprezentacija analognih i digitalnih
kola se zove ćelija i definiše se u vidu tranzistorskog layout-a.
Glavne komponente nivoa gejtova su logička kola i flip-flopovi. Gejtovi i flip-flopovi su primeri tipičnih
digitalnih ćelija. Ove ćelije se grupišu, raspoređuju po silicijumskoj površini i međusobno povezuju tako da
čine aritmetičke i memorijske module ili jedinice, koje se dalje koriste kao bazične komponente na
registarskom nivou apstrakcije. Bihejvioralni (funkcionalni) opis registarskih modula, realizovanih pomoću
logičkih kola i flip-flopova, se predstavlja u obliku logičkih funkcija ili dijagrama konačnih automata.
Glavne komponente registarskog nivoa (RTL) su aritmetičke i registarske jedinice, kao što su sabirači,
komparatori, množači, brojači, registri, registarski fajlovi. Registarske komponente se mogu rasporediti i
povezati tako da čine IC koji se koriste kao osnovne komponente na sledećem višem nivou apstrakcije. U
opštem slučaju, IC se opisuju dijagramima toka, ASM dijagramima, tabelama stanja, opisom u jeziku za opis
hardvera (VHDL).
Nivo procesora je najviši nivo apstrakcije, s obzirom da su osnovne komponente na ovom nivou procesori,
memorijska kola i aplikaciono-specifična integrisana kola (ASIC). U opštem slučaju, jedna ili više ovih
komponenti se postavlja na štampanu ploču i povezuje metalnim vezama koje su odštampane na ploči. Sistem
koji je sačinjen od procesorskih komponenti obično se opisuje tekstualno, izvršnom specifikacijom napisanom u
jeziku za opis hardvera ili algoritmom ili programom napisanim u višem programskom jeziku (npr. C).

1.4 Proces projektovanja

Put od ideje i početne specifikacije digitalnog sistema, pa do njegove fizičke realizacije je dug i sastoji se od
više koraka ili faza. Na tom putu, projektantu su na raspolaganju različite tehnike i alati, koji mu pomažu da
opiše svoju zamisao, proveri njenu funkcionalnu ispravnost i transformiše je u oblik pogodan za direktnu fizičku

8
realizaciju. Uopšteno govoreći, projektovanje digitalnog sistema je proces razrade i validacije (provere). Sistem
se postepeno transformiše, počev od apstraktnog opisa visokog nivoa, pa sve do nivoa layout-a, odnosno maski.
Nakon svake faze razrade, projektant verifikuje funkcionalnost razrađenog opisa sistema kako bi pronašao i
korigovao eventualne greške u projektovanju i osigurao da će konačni proizvod korektno funkcionisati i ispoljiti
zahtevane performanse.
Glavni zadaci (aktivnosti) u procesu razvoja digitalnog sistema su:
• Sinteza
• Fizičko projektovanje
• Verifikacija i
• Testiranje
Sinteza
Sinteza je proces razrade čiji je cilj da se uz pomoć komponenti raspoloživih na nižem nivou apstrakcije
realizuje sistem opisan na višem nivou apstrakcije. Polazni opis može biti strukturni ili funkcionalni, dok je
rezultujući opis uvek strukturni ali na nižem apstraktnom nivou. Kako proces sinteze napreduje, tako opis
sistema postaje sve detaljniji. Konačni rezultat je strukturna reprezentacija gejtovskog nivoa koja sadrži bazične
ćelije ciljne implementacione tehnologije. Proces sinteze se obično deli na nekoliko manjih koraka, od kojih
svaki ima za cilj da obavi neku specifičnu vrstu transformacije. Glavni koraci u sintezi digitalnog sistema su:
Sinteza visokog nivoa - transformacija algoritma u funkcionalni RTL opis. Algoritam, koji može biti dat u
programskom jeziku, kao što je C, se transformiše u funkcionalni opis, prilagođen hardverskoj realizaciji,
tipično, u jeziku za opis hardvera, kao što je VHDL.
RTL sinteza - transformacija funkcionalnog RTL opisa u strukturni opis korišćenjem komponenti sa RTL
nivoa, praćena izvesnim optimizacijama sa ciljem da se smanji broj potrebnih komponenti.
Logička sinteza - transformacija strukturnog RTL opis u mrežu logičkih kola (tj. u kombinacionu ili
sekvencijalnu mrežu). Inicijalna transformacija je praćena optimizacijom mreže kako bi se minimizovala
njena veličina i/ili propagaciono kašnjenje. Za sintezu se koriste standardne logičke komponente (I, ILI,
NE, flip-flopovi), a optimizacija se vrši metodama kao što su Karnoove mape, McClusky-jeva metoda i sl.
Logička sinteza je nezavisna od ciljne implementacione tehnologije.
Tehnološko mapiranje - transformacija logičke mreže u mrežu koja sadrži ćelije raspoložive u ciljnoj
tehnologiji (standardne ćelije, za tehnologiju standardnih ćelija, NI ili NILI kola, za tehnologiju gejtovskih
polja, odnosno, logičke blokove, za FPGA tehnologiju). Ovo je poslednji korak u sintezi i, očigledno,
zavistan je od ciljne tehnologije.
Fizičko projektovanje
Fizičko projektovanje uključuje dva aspekta. Prvi se odnosi na transformaciju strukturne u fizičku
reprezentaciju, npr. konverzija mreže dobijene nakon tehnološkog mapiranja u layout. Drugi aspekt se tiče
analize i optimizacije električnih karakteristika kola. Glavni zadaci fizičkog projektovanja su: prostorno
planiranje, raspoređivanje i povezivanje.
U fazi prostornog planiranja, projektant deli sistem na manje funkcionalne blokove (podsisteme) i raspoređuje ih
na odgovarajuće lokacije na čipu (npr. procesor u gornji levi ugao čipa, memorija u donji levi ugao, ostali
moduli u preostalom delu čipa). Na ovaj način, obezbeđuje se da sve komponente koje pripadaju istom bloku
budu fizički raspoređene u definisanu oblast na čipu. U fazi raspoređivanja, određuje se tačna fizička pozicija
svake komponente, dok se u fazi povezivanja, kreiraju sve potrebne veze, pri čemu se za svaku vezu pronalazi
optimalna (najkraća) putanja. Na taj način se kreira konačni layout IC-a.
Nakon obavljenog raspoređivanja i povezivanja, poznate su tačne pozicije i dužine svih veza u kolu, što
omogućava proračun pratećih parazitnih kapacitivnosti i otpornosti. Ovaj proces se naziva ekstrakcijom kola.
Podaci, ekstrahovani iz layout-a, se potom koriste kako bi se obavio proračun propagacionih kašnjenja u kolu.
Verifikacija
Verifikacija se odnosi na proveru da li ostvareni dizajn (projekat) zadovoljava postavljene funkcionalne zahteve
i zadate performanse (npr. brzina rada) i sprovodi se nakon svakog koraka razrade (sinteze), kao i nakon
obavljenog fizičkog projektovanja. Postoje dva aspekta verifikacije: funkcionalni i performansni. Funkcionalna
verifikacija daje odgovor na pitanje: da li sistem generiše očekivani odziv na zadatu pobudu? Performanse se
predstavljaju izvesnim vremenskim ograničenjima (npr. maksimalno kašnjenje signala od ulaza od izlaza).

9
Vremenska verifikacija (ili verifikacija tajminga) znači proveru da li sistem generiše odziv u granicama
postavljenih vremenskih ograničenja.
Metodi za verifikaciju
Simulacija je najčešće korišćeni metod za verifikaciju i podrazumeva: konstrukciju modela sistema,
izvršenje ovog modela na računaru i analizu odziva. Na primer, model može biti opis sistema u jeziku za
opis hardvera (HDL). Takav jedan opis, zajedno sa opisom ulazne pobude, se učitava u HDL simulator i
izvršava, a simulator generiše odziv modela na zadatu pobudu (npr. u obliku talasnih oblika izlaznih
signala). Simulacija nam omogućava da ispitamo rad sistema i detektujemo eventualne greške pre nego što
je sistem i fizički realizovan. Međutim, ispravan rad modela sistema u simulatoru ne predstavlja 100%-nu
garanciju korektnost sistema. Model može da dâ ispravan odziv na sve stimulanse kojima je pobuđen, ali
može se desiti da ni jedan od stimulansa nije doveo do pobude nekog specifičnog dela modela koji
eventualno poseduje grešku. S druge strane, naročito u slučajevima kada model sadrži veliki broj
komponenti, broj stimulansa (kaže se i test-vektora) koji je potreban da bi se postigla potpuna provera može
biti toliko veliki da je računarsko vreme potrebno za simulaciju enormno veliko.
Vremenska analiza je metod verifikacije fokusiran na tajming. Vremenska analiza podrazumeva: analizu
strukture kola kako bi se odredile sve moguće putanje signala od ulaza do izlaza, proračunala propagaciona
kašnjenja duž ovih putanja i odredili relevantni vremenski parametri kola, kao što su: maksimalno
propagaciono kašnjenje i maksimalna frekvencija taktnog signala.
Formalna verifikacija podrazumeva određivanje osobina kola primenom matematičkih tehnika. Jedan takav
metod je provera ekvivalentnosti, koji se koristi za upoređivanje dve formalne reprezentacije sistema kako
bi se ustanovimo da li imaju istu funkciju. Ovaj metod se često primenjuje nakon sinteze kako bi se
proverilo da li je funkcija sintetizovanog kola identična funkciji polaznog funkcionalnog opisa. Za razliku
od simulacije, formalna verifikacija, budući da je zasnovana na rigoroznom matematičkom aparatu, može
garantovati korektnost sintetizovane strukture. Međutim, s obzirom na veliku kompleksnost matematičkih
izračunavanja koje podrazumeva, njena primena je ograničena samo na sisteme male složenosti.
Hardverska emulacija podrazumeva fizičku realizaciju prototipa koji će oponašati rad sistema koji se
projektuje. Primer hardverske emulacije je realizacija FPGA kola koje emulira rad ASIC kola.
Testiranje
Značenje reči ˝verifikacija˝ i ˝testiranje˝, u jezičkom smislu, je približno isto. Međutim, u procesu razvoja
digitalnog sistema, verifikacija i testiranje su dva različita zadatka. Kao što je već rečeno, verifikacija se odnosi
na proveru funkcionalne korektnosti i ostvarenosti zadatih performansi dizajna. Sa druge strane, testiranje je
proces detektovanja (pronalaženja) fizičkih defekta (kvarova) u gotovom proizvodu koji mogu nastati tokom
proizvodnje. Testiranje se obavlja nakon fabrikacije proizvoda sa ciljem da se dobre jedinice razdvoje od loših.
Procedura testiranja se, tipično, obavlja tako što se na jedinicu koja se testira primenjuje odgovarajuća test
sekvenca (niz ulaznih kombinacija), a odziv jedinice na svaku ulaznu kombinaciju poredi sa odzivom koji se
očekuje od jedinice koja radi ispravno. Međutim, zbog ogromnog broja ulaznih kombinacija, ovakav pristup je
praktično neizvodljiv. Umesto toga, projektanti koriste posebne algoritme kako bi, za dato kolo, kreirali što
manji skup test-vektora kojima će kolo biti što potpunije testirano. Ovaj proces je poznat kao generisanje test
sekvenci.
CAD alati
Razvoj većih digitalnih kola i sistema zahteva upotrebu složenih algoritama i manipulaciju velikom količinom
podataka. Zato se za automatizaciju pojedinih zadataka u procesu projektovanja koristi računarski softver, tj.
alati za projektovanje pomoću računara ili CAD (Computer-Aided Design) alati. Postavlja se pitanje da li je
moguće automatizovati kompletan proces projektovanja (uz pretpostavku da su nam dostupni dovoljno moćni
računari). U idealnom scenariju, zadatak projektanta bi bio da razvije polazni, funkcionalni opis visokog nivoa,
a zadatak CAD alata da automatski, i na optimalan način obavi sintezu i fizičko projektovanje. Nažalost ovako
nešto nije izvodljivo, ne zbog neadekvatne moći izračunavanja sadašnjih i budućih računara, već zbog prirode
kombinatornih problema, kakvi su većina problema koji se javljaju i sintezi i fizičkom projektovanju. Bez obzira
na to CAD alati su nezamenljiva podrška projektovanju i koriste se u svim fazama projektovanja. Međutim, alat
za sintezu ne može da promeni prvobitno osmišljenu arhitekturu sistema, niti može loše osmišljeni dizajn da
konvertuje u dobar. Kvalitet krajnjeg rešenja prevashodno zavisi od kvaliteta inicijalnog opisa (zamisli), što u
svakom slučaju predstavlja odgovornost projektanta.

10
Shodno ulozi koju imaju u procesu projektovanja, savremeni CAD alati se mogu podeliti u sledećih pet
kategorija: (1) alati za opis i modelovanje; (2) alati za sintezu; (3) alati za verifikaciju i simulaciju; (4) alati za
raspoređivanje i povezivanje i (5) alati za generisanje test sekvenci.
Tok projektovanja
U suštini, projektovanje digitalnih kola i sistema predstavlja proces razrade i verifikacije, kojim se polazni
apstraktni opis visokog nivoa postepeno transformiše u detaljni strukturni opis niskog nivoa. Konkretne faze i
aktivnosti koje čine ovaj proces zavise kako od veličine sistema koji se projektuje tako i od ciljne
implementacione tehnologije.
Algoritmi za optimizaciju koji se koriste u softverima za sintezu su veoma složeni. Potrebna moć izračunavanja
i memorijski prostor, neophodni za njihovo izvršenje, drastično rastu sa povećanjem veličine sistema.
Savremeni CAD alati za sintezu su najefikasniji za digitalne sisteme srednjeg nivoa složenosti (2000 - 50000
gejtova). Za veće sisteme, neophodno je izvršiti podelu sistema na manje blokove i nezavisno procesirati svaki
blok.
Drugi faktor koji utiče na tok projektovanja je ciljna implementaciona tehnologija. Procesi fabrikacije FPGA i
ASIC se značajno razlikuju. FPGA je unapred projektovano i testirano IC. Sa druge strane, ASIC mora proći
kroz dugotrajan i složen proces fabrikacije, što zahteva dodatne korake u projektovanju kako bi se obezbedila
korektnost konačnog fizičkog IC.
Kao primer, u nastavku će biti izložen tok projektovanja digitalnih sistema srednje složenosti u FPGA
tehnologiji. Projektovanje sistema srednje složenosti (do 50000 gejtova) ne zahteva prethodnu podelu dizajna na
manje blokove. Primeri ovakvih sistema su jednostavni mikroprocesori ili moduli za složenija aritmetička
izračunavanja. Tok projektovanja je prikazan dijagramom sa Sl. 1-3. Dijagram je podeljen na tri kolone, koje
odgovaraju ˝pod-tokovima˝ sinteze, fizičkog projektovanja i verifikacije.
Projektovanje započinje kreiranjem opisa dizajna, najčešće u obliku opisa RTL nivoa (u jeziku VHDL) - dizajn
datoteka na Sl. 1-3. Posebna datoteka, poznata pod nazivom testbenč, sadrži opis virtuelnog eksperimentalnog
okruženja za simulaciju i verifikaciju dizajna. Testbenč sadrži kôd (program) koji generiše ulazne stimulanse i
nadgleda generisane odzive u toku simulacije. Tok projektovanja (u idealnom slučaju) podrazumeva sledeće
korake:
1. Razvoj dizajn-datoteke i testbenča.
2. Funkcionalna simulacija, čiji je cilj verifikacija polaznog opisa.
3. Sinteza. Rezultat sinteze je strukturni opis na nivou gejtova. Rezultujuća logička mreža je opisana
tekstualno u obliku tzv. netliste.
4. Datoteka koja sadrži netlistu se koristi za simulaciju i vremensku analizu kako bi se verifikovala
funkcionalna korektnost sintetizovane logičke mreže i obavila preliminarna provera tajminga.
5. Raspoređivanje i povezivanje.
6. Ekstrakcija preciznih podataka o tajmingu. Netlista, proširena ovim podacima se koristi za simulaciju i
vremensku analizu u cilju verifikacije korektnosti raspoređivanja i povezivanja i provere da li kolo
zadovoljava postavljena vremenska ograničenja.
7. Generisanje konfiguracionog fajla i programiranje FPGA kola
8. Verifikacija rada fizičke komponente.
Opisani tok projektovanja odgovara idealnom scenariju, kada polazni opis dizajna uspešno prolazi funkcionalnu
simulaciju i ispunjava vremenska ograničenja. U realnosti, tok projektovanja može sadržati više iteracija radi
korekcije grešaka ili problema u tajmingu. To, obično, zahteva reviziju polaznog opisa i fino podešavanje
parametara u softverima za sintezu, raspoređivanje i rutiranje.
Veći i složeniji digitalni sistemi mogu sadržati nekoliko stotina ili čak nekoliko miliona gejtova. CAD alati za
sintezu ne mogu efikasno da obavljaju transformacije i optimizacije nad ovako velikim sistemima. Zato je
neophodno da se sistem podeli na manje blokove, adekvatne veličine i funkcionalnosti, i svaki pojedinačni blok
nezavisno projektuje, pre nego što se ˝konstruiše˝ kompletan sistem. Za neke blokove možemo koristiti ranije
projektovane i verifikovane podsistema ili komercijalnih IP jezgara (Intelectualy Property Cores). Drugi
blokovi moraju biti projektovani ˝iz početka˝ na prethodno opisani način.

11
 Legenda Proces Datoteka
:

Sinteza Fizičko projektovanje Verifikacija

RTL
Testbenč
opis 1 1

Sinteza 3 2 Simulacija

Datoteka
Netlista
kašnjenja

Raspoređivanje 5 Simulacija
i povezivanje
4

Konfiguracioni Datoteka
fajl kašnjenja

Programiranje Simulacija/
7
komponente Vremenska
analiza
6

FPGA
8
čip

Sl. 1-3 Tok projektovanja sistema srednje veličine za implementaciju na FPGA.

1.5 Jezici za opis hardvera

Digitalni sistem se može opisati na različitim nivoima apstrakcije i u različitim domenima (funkcionalni,
strukturni, fizički). U toku projektovanja, projektant je u neprekidnoj interakciji sa različitim CAD alatima.
Kako proces projektovanja napreduje, tako se nivoi i domeni menjaju, bilo od strane projektanta, bilo od strane
CAD alata. Poželjno je da postoji jedan zajednički okvir za razmenu informacija između projektanta i CAD
alata. Jezici za opis hardvera, ili HDL (od Hardware Description Language) upravo služe ovoj svrsi. HDL treba
da omogući verno i precizno modelovanje i opisivanje kola i sistema, bilo da se radi o postojećem kolu odnosno
sistemu ili o kolu/sistemu koji se projektuje i to na željenom nivou apstrakciju, kako u funkcionalnom tako i u
strukturno domenu. Po sintaksi, HDL-ovi nalikuju tradicionalnim programskim jezicima. Međutim, s obzirom
da se HDL-ovi koriste za modelovanje hardvera, njihova semantika i način korišćenja se značajno razlikuju od
semantike i korišćenja programskih jezika.
Ograničenja programskih jezika
Danas postoji veliki broj računarskih, programskih jezika, od Fortrana do C-a i Java-e. Nažalost, oni nisu
adekvatni za modelovanje digitalnog hardvera. Programski jezik se karakteriše sintaksom i semantikom.
Sintaksa obuhvata gramatička pravila za pisanje programa, a semantika definiše značenje jezičkih konstrukcija.
Većina tradicionalnih programskih jezika opšte namene (kao što je C) zamišljeni su da modeluju sekvencijalne
procese (ili algoritme). Kod sekvencijalnih procesa, operacije se obavljaju ˝jedna po jedna˝, u strogo
sekvencijalnom redosledu. Redosled operacija se ne može proizvoljno menjati, jer svaka operacija u nizu obično
zavisi od rezultata prethodnih operacija. Na apstraktnom nivou, model sekvencijalnih procesa omogućava
programeru da razvija algoritam ˝korak po korak˝. Na implementacionom nivou, ovaj model je usklađen sa
modelom rada računara i omogućava efikasno prevođenje programa u mašinske instrukcije.
Međutim, karakteristike digitalnog hardvera su značajno drugačije od karakteristika modela sekvencijalnih
procesa. Tipični digitalni sistem je sačinjen od više manjih, međusobno povezanih delova. Kada se neki signal u
kolu promeni, svi delovi koji su povezani sa ovim signalom reaguju tako što izvršavaju odgovarajuću operaciju.
Sve ove operacije se izvršavaju konkurentno (istovremeno, u paraleli), a trajanje svake pojedinačne operacije
zavisi od iznosa propagacionog kašnjenja kroz konkrenti deo. Nakon okončanja operacije, svaki deo postavlja
rezultat na svoje izlaze. Ako su se izlazne vrednosti promenile, izlazni signal će aktivirati sve povezane delove i
inicirati novi ciklus izvršenja operacija. Na osnovu ovog opisa, uočavaju se nekoliko jedinstvenih karakteristika
digitalnih sistema, kao što su: povezanost delova, konkurentne operacije i koncepti propagacionog kašnjenja i
tajminga. Sekvencijalni model, koji se koristi kod tradicionalnih programskih jezika, je previše restriktivan da bi

12
mogao da obuhvati navedene karakteristike hardvera, što nameće potrebu za specijalizovanim jezicima (tj.
HDL-ovima) koji su prevashodno namenjeni modelovanju digitalnog hardvera.
Upotreba HDL programa
Tradicionalni programski jezici se koriste za pisanje programa koji treba da reši neki konkretan problem.
Program prihvata ulazne vrednosti, sprovodi izračunavanja i generiše odgovarajuće izlazne vrednosti. Program
se najpre kompajlira u mašinske instrukcije, a zatim izvršava na računaru. Sa druge strane, primena HDL
programa je značajno drugačija. Naime, HDL programi imaju trostruku namenu:
Formalna dokumentacija
Rad na razvoju digitalnog sistema obično počinje tekstualnim opisom. Nažalost, govorni jezik nije dovoljno
precizan, a tekstualni opis je često nekompletan, dvosmislen i podložan različitim interpretacijama. S obzirom
da HDL-ovi poseduju strogu sintaksu, opis sistema u obliku HDL programa je tačan i precizan. Dakle, HDL
program se može koristiti za formalnu specifikaciju sistema koja se u obliku razumljive i nedvosmislene
dokumentacije može razmenjivati između projektanta i projektantskih grupa.
Ulaz u simulator
Kao što je napomenuto u prethodnoj sekciji, simulacija se koristi za analizu i verifikaciju rada sistema pre nego
što je on i fizički realizovan. U suštini, HDL simulator predstavlja okvir za modeliranje konkurentnih operacija
na seckvencijalnom računaru. Simulator za konkretni HDL u stanju je da tumači semantičko značenje jezičkih
konstrukcija i interpretira program napisan u tom konkretnom HDL-u. HDL program, kombinovan sa
programom za genrisanje test vektora i prikupljanjem podataka, čini testbenč, koji se koristi kao ulaz u HDL
simulator. U toku izvršenja, simulator interpretira HDL program i generiše odgovarajuće odzive.
Ulaz u alat za sintezu
Savremeni tok projektovanja zasnovan je procesu razrade kojim se funkcionalni opis visokog nivoa postepeno
konvertuje u strukturni opis niskog nivoa. Pojedini koraci razrade se mogu obaviti uz pomoć CAD alata za
sintezu. Softver za sintezu, kao ulaz prihvata HDL program i generiše odgovarajuće kolo sačinjeno od
komponenti iz raspoložive biblioteke komponenti. Izlaz alata za sintezu je novi HDL program, ali koji sada
predstavlja strukturni opis sintetizovanog kola.
Karakteristike savremenih HDL-ova
Fundamentalne karakteristike digitalnih kola i sistema se definišu konceptima: entitet, povezanost,
konkurentnost i tajming. Entitet je bazični gradivni blok, modelovan po ugledu na realno kolo. Entitet je samo-
dovoljan i nezavisan i ne poseduje bilo kakve informacije o drugim entitetima. Povezanost modeluje veze koje
povezuju delove sistema i omogućava interakciju između entiteta. Tipično, više entiteta su aktivni u isto vreme,
a mnoge operacije se izvršavaju u paraleli. Konkurentnost opisuje ovakav način ponašanja. Tajming je u vezi sa
konkurentnošću; definiše početak i završetak svake operacije, kao i redosled izvršenja operacija.
Kao što je opisano u prethodnoj sekciji, digitalni sistem može biti opisan na četiri različita nivoa apstraktnosti i
u tri različita domena. Idealno bi bilo posedovati HDL koji bi pokrio sve nivoe i domene. Međutim, to je teško
ostvarljivo zbog velikih razlika koje postoje između različitih nivoa apstrakcije, kao i između različitih domena.
Savremeni HDL-ovi omogućavaju kreiranje opisa u strukturnom i bihejvoralnom (funkcionalnom) domenu, ali
ne i u fizičkom. Takođe, pružaju podršku za modelovanje na nivou gejtova i RTL nivou i, u izvesnoj meri, na
procesorskom i tranzistorskom nivou. Zajedničke karakteristike savremenih HDL-ova su:
• Semantika jezika pruža podršku za koncepte: entitet, povezanost, konkurentnost i tajming.
• U jeziku se mogu predstaviti propagaciona kašnjenja i informacije o tajmingu
• Jezik poseduje konstrukcije kojima se na direktan način može opisati strukturna implementacija kola (npr.
blok dijagram).
• Jezik sadrži konstrukcije kojima se na bihejvioralni način može opisati rad kola, uključujući i konstrukcije
koje nalikuju onima iz tradicionalnih programskih jezika (if-then-else, for, while, ...).
• Jezik može efikasno da modeluje operacije i strukture na gejtovskom i RTL nivou.
• Jezik poseduje konstrukcije za podršku procesu hijerarhijskog projektovanja.

13
1.6 Sadržaj i ciljevi predmeta
Predmet ˝Arhitektura mikrosistema˝ primarno je fokusiran na projektovanje i sintezu digitalnih kola i sistema na
RTL nivou (odnosno, mikro-arhitekturalnom nivou) apstrakcije. Za opis dizajna koristiće se podskup jezika
VHDL, namenjen sintezi. Predmet nema ambiciju da pokrije sve aspekte ASIC i FPGA projektovanja. Ostali
aspekti, kao što su fizičko projektovanje, simulacija i testiranje, biće razmatrani samo iz perspektive RTL
projektovanja i u meri koja je neophodna za razumevanje principa i tehnika RTL projektovanja i sinteze.
Cilj kursa ˝Arhitektura mikrosistema˝ je uvođenje studenata u problematiku projektovanja digitalnih sistema,
kroz izučavanje metodologije sistematskog razvoja efikasnog, portabilnog RTL dizajna koji se može lako
integrisati u veće sisteme. Nakon uspešnog savladavanja materije obuhvaćene ovim predmetom, student bi
trebalo da bude u mogućnosti da samostalno projektuje RTL sisteme i podsisteme. Sveobuhvatno projektovanje
IC, bilo ASIC bilo FPGA, zahteva kako dodatna teorijska znanja tako i poznavanje specijalizovanih CAD alata,
što će biti teme nekih drugih kurseva.

14
2 VHDL
2.1 Uvod
Nagli razvoj tehnologije integrisanih kola, koji se desio osamdesetih godina prošlog veka, nametnuo je potrebu
za unifikacijom metodologija projektovanja digitalnih kola. VHDL je razvijen kao jedan od rezultata napora
učinjenih u tom pravcu. Vremenom, VHDL je postao standardni jezik za opis digitalnih kola i sistema.
VHDL i Verilog su danas dva najšire korišćena HDL-a. Iako su, po sintaksi i ˝izgledu˝, ova dva jezika veoma
različita, nihove mogućnosti i oblasti primene su približno iste. Oba jezika su industrijski standardi i podržani su
većini alata za projektovanje. Prednost VHDL-a je bolja podrška za paremtrizovano projektovanje.
VHDL je skraćenica od “VHSIC Hardware Description Language“ (VHSIC jezik za opis hardvera), gde je
VHSIC takođe skraćenica od “Very High Speed Integrated Circuits” (Integrisana kola veoma velike brzine
rada). Prvobitni VHDL standard usvojen je 1987. godine od strane međunarodne organizacije za standardizaciju
IEEE (Institute of Electrical and Electronics Engineers), pod oznakom IEEE 1076. Revidiran i trenutno aktuelni
VHDL standard, IEEE 1164, usvojen je 1993. godine.
Prvobitno, VHDL je imao dvostruku namenu. Prvo, bio je korišćen kao dokumentacioni jezik za opisivanje
strukture složenih digitalnih sistem. S obzirom da se radi o internacionalnom standardu, VHDL je značajno
olakšao razmenu dokumentacije između različitih projektantskih organizacija. Drugo, s obzirom da poseduje
jezičke konstrukcije za modeliranje ponašanja digitalnih kola, VHDL je korišćen i kao ulaz u softvere koji su u
to vreme bili korišćeni za simulaciju rada digitalnih kola.
U novije vreme, pored korišćenja za dokumentovanje projekta i simulaciju, VHDL je takođe postao popularno
sredstvo za unos dizajna u CAD sisteme za sintezu. Savremeni CAD alati su u mogućnosti da obave sintezu
VHDL kôda u odgovarajuću hardversku implementaciju. Jednom napisan i verifikovan VHDL kôd može se
iskoristiti za realizaciju opisanog kola u različitim tehnologijama, kao što su: programabilne logičke
komponente (PLD - Programmable Logic Devices) ili aplikaciono-specifična integrisana kola (ASIC -
Application Specific Integrated Circuits). U ovoj skripti VHDL će prevashodno biti korišćen za sintezu.
VHDL je kao jezik izuzetno obiman i složen. Učenje svih detalja ovog jezika zahteva dosta napora i vremena,
kao i dobro poznavanje naprednijih tehnika digitalnog projektovanja. Međutim, za upotrebu u sintezi, bitan je
samo jedan manji deo mogućnosti VHDL jezika. U ovoj skripti biće razmatrani samo oni aspekti VHDL jezika
koji će biti korišćeni u prezentovanim primerima. Međutim, nakon upoznavanja sa materijom u vezi VDHL-a
koji će biti izložena u skripti, čitalac bi trebalo da bude u mogućnosti da projektuje širok spektar digitalnih kola.
Napomenimo da je za razliku od programskih jezika koji su sekvencijalni, VHDL u osnovi konkurentni
(paralelni) jezik. Iz tog razloga uobičajeno je da se u kontekstu VHDL-a govori o kôdu, a ne o programu, kao
što je to slučaj kod jezika kao što su C/C++ ili Pascal.

2.1.1 Struktura VHDL kôda

Svaki celovit VHDL kôd, tj. onaj koji se može simulirati ili sintetizovati, sastoji se iz sledeće tri sekcije (Sl. 2-1):
- Deklaracija LIBRARY: sadrži spisak biblioteka koje se koriste u projektu. Na primer: ieee, std, work i
td.
- ENTITY: definiše ulazne i izlazne signale (pinove ili portove) kola.
- ARCHITECTURE: sadrži pravi VHDL kôd koji opisuje ponašanje (funkciju) ili strukturu kola.

15
 Sl. 2-1 Struktura VHDL kôda.
LIBRARY
LIBRARY (biblioteka) je kolekcija često korišćenih delova VHDL kôda. Izvorni kôd biblioteke se sastoji iz
jednog ili više paketa (PACKAGE) koji sadrže funkcije (FUNCTIONS), procedure (PROCEDURES),
komponente (COMPONENTS), konstante (CONSTANTS) i tipove podataka (TYPES) ( Sl. 2-2). Takav izvorni
kôd se jednom piše i kompajlira u biblioteku (LIBRARY) koja se potom može koristiti u različitim projektima
ili razmenjivati sa drugim projektantima.

Sl. 2-2 Struktura biblioteke.

Da bi se u konkretnom projektu omogućio pristup sadržaju neke biblioteke potrebne su dve linije kôda sledeće
sintakse:
LIBRARY ime_biblioteke;
USE ime_biblioteke.ime_paketa.delovi_paketa;
Prva linija definiše ime biblioteke, dok druga sadrži naredbu USE koja definiše pakete i delove pakete iz
izabrane biblioteke koji se žele koristiti. Barem tri paketa iz tri različite biblioteke su neophodna u svakom
projektu:
- std_logic_1164 (iz biblioteke ieee)
- standard (iz biblioteke std) i
- work (iz biblioteke work)
Odgovarajuće deklaracije su:
LIBRARY ieee; -- tačka-zarez (;) označava
USE ieee.std_logic_1164.all; -- kraj naredbe ili deklaracije
LIBRARY std; -- dupla crta (--) označava komentar
std.sdandard.all;
LIBRARY work;
USE work.all;
Reč all na kraju naredbe USE znači da se koristi celokupan sadržaj navedenog paketa. Biblioteke std i work su
po automatizmu uključene u svaki projekat, tako da ih nije neophodno eksplicitno deklarisati. To nije slučaj sa
bibliotekom ieee, pa njena deklaracija uvek mora biti navedena. Treba napomenuti da je biblioteka ieee
neophodna samo ako se u projektu koriste signale tipa STD_LOGIC. U suprotnom, i ona se može izostaviti.
Signali tipa STD_LOGIC se koriste za sintezu tako da, po pravilu, svaki VHDL kôd, namenjen sintezi, počinje
sledećim dvema linijama:
LIBRARY ieee;
USE ieee.std_logic_1164.all;
Pomenuti paketi/biblioteke imaju sledeću namenu: Paket std_logic_1164 biblioteke ieee definiše višenivovske
logičke sisteme; std je biblioteka resursa (standardni tipovi podataka i sl.); work je projektna biblioteka, tj. mesto
gde se smeštaju svi fajlovi projekata (izvorni VHDL fajlovi plus svi fajlovi koje kreiraju kompajler i simulator).

16
 Biblioteka ieee sadrži nekoliko paketa, od kojih su najvažniji sledeći:
- std_logic_1164: definiše višenivovske logičke sisteme: STD_LOGIC (8 nivoa) i STD_ULOGIC (9
nivoa).
- std_logic_arith: definiše tipove podataka SIGNED i UNSIGNED zajedno sa odgovarajućim
aritmetičkim operacijama i funkcijama za konverziju podataka koje omogućavaju da se podatak jednog
tipa konvertuje u podatak nekog drugog tipa.
- std_logic_signed: sadrži funkcije koje omogućavaju da se sa podacima tipa STD_LOGIC_VECTOR
manipuliše na isti način kao sa podacima tipa SIGNED.
- std_logic_unsigned: sadrži funkcije koje omogućavaju da se sa podacima tipa STD_LOGIC_VECTOR
manipuliše na isti način kao sa podacima tipa UNSIGNED.
Detaljniji opis navedenih biblioteka biće dat u sekciji 2.2.2.
ENTITY
Sekcija ENTITY sadrži spisak svih ulaznih i izlaznih pinova, ili portova (PORTS) kola. ENTITY ima sledeću
sintaksu:
ENTITY ime_entiteta IS
PORT (
ime_porta : mode_signala tip_signala;
ime_porta : mode_signala tip_signala;
... );
END ime_entiteta;
Entitetu se mora dati ime, koje se navodi u prvoj i poslednoj liniji sekcije ENTITY. Deklaracija portova se
nalazi u delu sekcije koja počinje ključnom rečju PORT. Za svaki port se navodi ime, mode i tip. Mode, ili režim
rada, porta može biti: IN, OUT ili INOUT. Kao što je prikazano na Sl. 2-3(a), mode IN definiše ulazne, a OUT
izlazne portove kola. Mode INOUT se koristi za deklaraciju dvosmernih portova, tj. portova koji se po potrebi
mogu koristiti bilo kao ulazi, bilo kao izlazi. Preko portova kolo razmenjuje signale sa svojim okruženjem. Tip
signala može biti BIT, STD_LOGIC, INTEGER i td. Više reči o tipovima podataka biće u poglavlju 2.2.

(a) (b)
Sl. 2-3: (a) Mode-ovi portova; (b) NI kolo.
Primer: NI kolu sa Sl. 2-3(b) odgovara entitet:
ENTITY ni_kolo IS
PORT (a, b : IN BIT;
c : OUT BIT);
END ni_kolo;
Značenje gornje ENTITY deklaracije je sledeće: Opisuje se kolo koje ima dva ulazna (a i b) i jedan izlazni port
(c). Sva tri porta su tipa BIT. Kolu je dodeljno ime ni_kolo. Dakle, ENTITY ne govori ništa o funkciji kola, već
samo opisuje spoljni pogled na kolo, tj. interfejs kola. Treba obratiti pažnju na sledeće pojedinosti: Više portova
istog mode-a i tipa mogu biti deklarisani u istoj liniji (kao što je to slučaj sa portovima a i b). Svaka linija u
okviru PORT konstrukcije završava se znakom ΄;΄, osim poslednje, nakon koje sledi zagrada koja zatvara PORT
deklaraciju.
Slično većini programskih jezika, VHDL definiše pravila za formiranje imena entiteta, portova, signala, varijabli
i td. Ime može da sadrži bilo koje slovo ili cifru, kao i crtu za podvlačenje “_”. Ograničenja su da ime ne može
početi cifrom i da ključne reči VHDL jezika ne mogu biti korišćene kao imena. Takođe treba napomenuti da
VHDL ne pravi razliku između malih i velikih slova, kako kod pisanja imena, tako i prilikom pisanja ključnih
reči. Tako, a i A, ni_kolo i NI_Kolo, kao i Port, port i PORT znače isto.
ARHITECTURE
Da bi VHDL opis nekog kola bio kompletan, osim entiteta, koji definiše ulaze i izlaze kola (tj. Interfejs)
neophodno je napisati još jednu programsku celinu koja se zove arhitektura (ARHITECTURE), a koja sadrži
opis funkcionisanja, ili ponašanja, kola. Njena sintaksa je sledeća:

17
 ARCHITECTURE ime_arhitekture OF ime_entiteta IS
[deklaracije]
BEGIN
[kôd]
END ime_arhitekture;
Kao i kod entiteta, ime arhitekture može biti proizvoljno izabrano. Arhitektura je uvek pridružena jednom
konkretnom entitetu, čije se ime navodi posle reči OF. Sekcija ARCHITECTURE se sastoji iz dva dela:
deklarativni deo (koji je opcioni), gde se, između ostalog, deklarišu interni signali i konstante i deo za kôd
(počev od ključne reči BEGIN pa do kraja). Sve naredbe koje čine kôd arhitekture se zovu konkurentne naredbe
i izvršavaju se u paraleli (istovremeno).
Pr. 2-1 NI kolo
Razmotrimo ponovo NI kolo Sl. 2-3(b). Funkcionisanje ovog kola se može opisati sledećom arhitekturom:
ARCHITECTURE ni_funkcija OF ni_kolo IS
BEGIN
c <= a NAND b;
END ni_funkcija;
Gornji kôd se tumači na sledeći način: kolo obavlja NI operaciju (NAND) nad dva ulazna signala, a i b, i
rezultat dodeljuje (˝<=˝) izlaznom pinu c. U ovom primeru ne postoji deklarativni deo, a kôd sadrži samo jednu
naredbu dodele. Naredba se izvršava uvek kada se na nekom od signala a ili b desi događaj. Događaj na signalu
znači da je došlo do promene vrednosti signala. Kaže se da je naredba dodele senzitivna na promenu vrednosti
bilo kog signala sa leve strane znaka <=. U konkretnom primeru, naredba je senzitivna na a i b.

2.1.2 Stilovi projektovanja

U ovoj sekciji biće predstavljeno nekoliko jednostavnih primera VHDL kôda. Iako još uvek nismo proučili sve
konstrukcije koje će se pojaviti u ovim primerima, oni će nam pomoći da bolje razumemo osnovne principe koji
se tiču projektovanja u VHDL-u.
Bihejvioralni opis

Sl. 2-4 Kombinaciona mreža iz Pr. 2-2

Pr. 2-2 Konkurentno izvršenje naredbi
Razmotrimo jednostavnu kombinacionu mrežu sa Sl. 2-4. Interfejs (entitet) mreže čine tri ulazna (a, b i c) i jedan
izlazni port (y), svi tipa BIT. Odgovarajući VHDL opis dat je ispod. Osim signala koji odgovaraju portovima, u
kôdu postoji i jedan interni (unutrašnji) signal, x, koji odgovara istoimenoj vezi u mreži sa Sl. 2-4 koja povezuje
izlaz prvog sa ulazom drugog NI kola. Interni signali se deklarišu u deklarativnom delu arhitekture (linija 8).
Primetimo da deklaracija signala x ne sadrži mode definiciju (mode se koristi samo za portove). Primetimo,
takođe, da dati kôd ne sadrži deklaraciju biblioteka. Razlog za to je što su u ovom primeru svi signali (portovi
plus interni signal) tipa BIT. Ovaj tip podataka je definisan u biblioteci std, koja je po automatizmu uključena u
svaki projekat. Prva naredba dodele (linija 10) postavlja izlaz mreže, y, u zavisnosti od vrednosti signala x i c, a
druga (linija 11) signal x u zavisnosti od a i b.
1 ------------------------------------------------
2 ENTITY primer IS
3 PORT(a, b, c: IN BIT;
4 y : OUT BIT);
5 END primer;
6 ------------------------------------------------
7 ARCHITECTURE dataflow OF primer IS
8 SIGNAL x : BIT;
9 BEGIN
10 y <= x NAND c;
11 x <= a NAND b;
12 END dataflow;
13 ------------------------------------------------
Kao što je već rečeno, izvršenje naredbe u konkurentnom kôdu inicirano je pojavom događaja na nekom signalu
sa leve strane znaka <=, a ne redosledom naredbi, kao što je to slučaj kod programskih jezika. To znači da

18
redosled naredbi u konkurentnom kôdu nije od značaja. Identičnu funkciju imao bi i kôd u kome bi dve naredbe
iz gornje arhitekture zamenile mesta:
x <= a NAND b;
y <= x NAND c;
Pretpostavimo da je mreža sa Sl. 2-4 u stabilnom stanju u kome su svi ulazi postavljeni na 1-cu, a=b=c=1. Pod
ovim uslovima na izlazu mreže je y = (1 NAND 1) NAND 1 = 1. Neka se u nekom momentu vrednost ulaza a
promeni na a=0. Ovaj događaj utiče na naredbu iz linije 11 (x<=a NAND b), zato što je ona senzitivna na signal
a, ali ne i na naredbu iz linije 10 (y <= x NAND c), jer kod nje signal a ne postoji kao operand. Kao rezultat
izvršenja naredbe iz linije 11 signal x dobija novu vrednost x= (0 NAND 1)= 1. Ova promena vrednosti signala x
ima za posledicu izvršenje naredbe iz linije 10, koja na izlaz y postavlja y = 1 NAND 1 = 0. Ovakav način
izvršenja naredbi naziva se dataflow model, ili model toka podataka, s obzirom da je redosled izvršenja naredbi
uslovljen propagacijom ulazne promene.
Iako VHDL kôd iz ovog primera striktno prati strukturu polazne mreže, to u opštem slučaju ne mora biti tako.
Dataflow model, pre svega, omogućava modeliranje (opisivanje) funkcije ili ponašanja kola bez ulaženja u
strukturne detalje. Na primer, funkcija mreže sa Sl. 2-4 može se predstaviti u obliku tabele istinitosti:
a b c y
0 0 0 1
0 0 1 0
0 1 0 1
0 1 1 0
1 0 0 1
1 0 1 0
1 1 0 1
1 1 1 1
Ova funkcija se može u VHDL-u opisati pomoću SELECT naredbe (sekcija 2.4.3), kao u sledećoj arhitekturi:
ARCHITECTURE dataflow OF primer IS
BEGIN
WITH (a & b & c) SELECT
y <= '1' WHEN "000",
'0' WHEN "001",
'1' WHEN "010",
'0' WHEN "011",
'1' WHEN "100",
'0' WHEN "101",
'1' WHEN "110",
'1' WHEN "111";
END dataflow;
Kao što možemo videti, sada kôd nema nikakve veze sa strukturom, već isključivo opisuje funkciju mreže.
Naredba je senzitivna na sva tri ulaza, a, b i c, koji su operatorom & povezana u tro-bitni vektor. Uvek kada se
desi događaj ne nekom od ulaznih signala, naredba se izvrši, tako što izlazu y dodeli vrednost koja odgovara
trenutnoj vrednosti ulaza.
Tehnika (ili stil) programiranja u VHDL-u koji opisuje funkciju kola naziva se bihejvioralno ili funkcionalno
modeliranje. Osnovu bihejvioranog modeliranja čine konkurentne i sekvencijalne naredbe.
Sekvencijalni procesi
Pr. 2-3: D flip-flop sa asinhronim resetom

Sl. 2-5 D flip-flop sa asinhronim resetom.

Na Sl. 2-5 je prikazan grafički simbol D flip-flopa koji se okida rastućom ivicom taktnog signala (clk) i poseduje
mogućnost asinhronog resetovanja (rst). Za sve vreme dok je rst = 1, na izlazu flip-flopa je q = 0, bez obzira na
takt. Kada je rst = 0, u trenucima kada se taktni signal clk menja sa 0 na 1, na izlaz q se prenosi trenutna
vrednost ulaza d, tj. q <= d.

19
Postoji nekoliko načina kako se D flip-flop sa Sl. 2-5 može opisati u VHDL-u. Jedno moguće rešenje
predstavljeno je ispod. Za razliku od standardnih programskih jezika koji su sekvencijalni (naredbe se izvršavaju
jedna za drugom), VHDL je u suštini konkurentni jezik. To znači da prilikom izvršenja VHDL kôda, simulator
pravi iluziju istovremenog (konkurentnog) izvršavanja različitih delova kôda. Ovakav model je pogodan za opis
hardvera gde različiti podsistemi jednog složenog sistema rade u paraleli. Međutim, ponašanje pojedinih
podsistema, ili kola, često je lakše opisati sekvencijalnim kôdom. Konstrukcija PROCESS, iskorišćena u
arhitekturi D flip-flopa, predstavlja jedan od načina kako se u VHDL-u može nametnuti sekvencijalno izvršenje
naredbi. Naime, naredbe obuhvaćene procesom izvršavaju se sekvencijalno (jedna za drugom), kao kod bilo kog
programskog jezika. Drugim rečima, kao što ARCHITECTURE predstavlja okvir za konkurentni, tako
PROCESS predstavlja okvir za sekvencijalni kôd.
1 -----------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -----------------------------------------------
5 ENTITY dff IS
6 PORT (d, clk, rst: IN STD_LOGIC;
7 q: OUT STD_LOGIC);
8 END dff;
9 -----------------------------------------------
10 ARCHITECTURE behavior OF dff IS
11 BEGIN
12 PROCESS (rst,clk)
13 BEGIN
14 IF(rst='1') THEN
15 q <= '0';
16 ELSIF (clk'EVENT AND clk='1') THEN
17 q <= d;
18 END IF;
19 END PROCESS;
20 END behavior;
21 -----------------------------------------------
Objašnjenje:
Linije 2 – 3: Deklaracija ieee biblioteke. (Biblioteke std i work uključene su po automatizmu). U ovoj biblioteci,
odnosno u njenom paketu std_logic_1164 definisan je tip podataka STD_LOGIC koji se koristi u ovom kôdu.
Linije 5 – 8: Entitet dff. Opisuje ulaze i izlaze D flip-flopa.
Linije 10 – 20: Arhitektura behavior. Opisuje unutrašnjost D flip-flopa.
Linija 6: Ulazni portovi. (Mode ulaznog porta može biti samo IN). U ovom primeru svi signali su tipa
STD_LOGIC.
Linija 7: Izlazni port (Mode izlaznog porta može biti OUT ili INOUT). Tip izlaznog porta je takođe
STD_LOGIC.
Linije 12 – 19: PROCESS. Kôd unutar procesa izvršava se sekvencijalno.
Linija 12: PROCESS se izvrši jedanput uvek kada se promeni neki od signala iz njegove liste senzitivnosti. U
ovom primeru, svaka promena signala rst ili clk iniciraće izvršenje procesa.
Linije 14 – 15: Ako je rst=1, flip-flop se resetuje bez obzira na clk (asinhroni reset).
Linije 16 – 17: Ako rst nije aktivan i clk se promenio (desio se EVENT (događaj) na signalu clk) i promena je
takva da je nova vrednost signala clk jednaka 1, tada se vrednost ulaznog signala (d) pamti u flip-flopu (q <= d) .
Linije 15 i 17: Operator ˝<=˝ se koristi za dodelu vrednosti signalu (tj. podatku tipa SIGNAL). Za dodelu
vrednosti promenljivama (tj. podacima tipa VARIABLE) koristi se operator ˝:=˝. Portovi entiteta su uvek
signali.
Linije 1, 4, 9 i 21: Komentarisane linije. (˝--˝ označava komentar). Koristi se radi preglednijeg prikaza kôda.
Simulacija VHDL kôda
Značaj bihejvioralnog modeliranja leži u činjenici da se jedan takav opis digitalnog kola može simulirati i na taj
način verifikovati njegova funkcija. Za simulaciju se koriste namenski softveri, tzv. VHDL simulatori. VHDL
kôd se najpre kompajlira, a zatim se učitava u simulator koji ima mogućnost da izvršava VHDL kôd shodno

20
dataflow i sekvencijalom modelu. Kao rezultat, simulator generiše vremenske dijagrame signala iz VHDL kôda
kako se oni menjaju u toku izvršenja kôda.
Na Sl. 2-6 prikazani su rezultati simulacije VHDL kôda iz Pr. 2-3. Grafikon se može lako interpretirati. U prvoj
koloni navedeni su mode-ovi signala, a drugoj njihova imena. Treća kolona sadrži talasne oblike posmatranih
signala. U zaglavlju ove kolone naznačeni su vremenski trenutci (u ovom primeru u nanosekundama, ns). U
ovom primeru, svi signali su binarni i s toga su njihove vrednosti ΄0΄ ili ΄1΄. Kada se koriste vektori, tj. više-bitni
signali, njihove trenutne vrednosti biće prikazane u obliku binarnog, decimalnog ili heksadecimalnog broja.
Oblik ulaznih signala (rst, d i clk) može se proizvoljno zadati u simulatoru. Na osnovu oblika ulaznih signala i
VHDL kôda, simulator određuje oblik izlaznih signala (u ovom slučaju postoji samo jedan izlaz, q. Poređenjem
rezultata sa Sl. 2-6, sa očekivanim ponašanjem D flip-flopa sa asinhronim resetom, možemo zaključiti da VHDL
kôd sa Sl. 2-5 predstavlja ispravan opis ovog kola.

Sl. 2-6 Rezultati simulacije VHDL kôda iz Pr. 2-3

Sl. 2-7 D flip-flop i NI kolo.

Pr. 2-4: D flip-flop i NI kolo
NI kolo sa Sl. 2-3(b) kombinaciona mreža sa Sl. 2-4, sa jedne i D flip-flop sa Sl. 2-5 sa druge strane su primeri
čisto kombinacionog i čisto sekvencijalnog kola, respektivno. Kolo sa Sl. 2-7 prestavlja kombinaciju ova dva
tipa digitalnih kola. Odgovarajući VHDL opis dat je ispod. Kôd arhitekture (linije 10 – 15) se sastoji iz procesa
koji opisuje D flip-flop (linije 11 – 15) i naredbe dodele koja obavlja NI operaciju (linija 10). Iako se naredbe
unutar procesa izvršavaju sekvencijalno, proces kao celina je konkurentan u odnosu na druge naredbe. Tako,
možemo smatrati da se naredba dodele (linija 10) i proces (linije 11 - 15) izvršavaju konkurentno (slično kao što
u fizičkom kolu, NI kolo i D flip-flop rade istovremeno i nezavisno). Interni signal x se koristi za spregu ove dve
konkurentne naredbe. Za razliku od D flip-flopa iz primera 2-1, D flip-flop iz ovog primera ne poseduje funkciju
asinhronog resetovanja. Iz tog razloga clk je jedini signal na koji je proces osetljiv. Dakle, proces se pokreće pri
svakoj promeni signala clk. Ako promena odgovara rastućoj ivici, u flip-flop se upisuje vrednost signala x (linija
13). Primetimo da signal x nije neophodan i da se može izostaviti ako se naredba dodele q <= x (linija 13)
zameni naredbom q <= d1 NAND d2. Rezultati simulacije dati su na Sl. 2-8.
1 ------------------------------------------------
2 ENTITY primer IS
3 PORT( d1, d2, clk: IN BIT;
4 q : OUT BIT);
5 END primer;
6 ------------------------------------------------
7 ARCHITECTURE primer OF primer IS
8 SIGNAL x : BIT;
9 BEGIN
10 x <= d1 NAND d2;
11 PROCESS(clk)
12 BEGIN
13 IF(clk'EVENT AND clk='1') THEN q <= x;
14 END IF;
15 END PROCESS;
16 END primer;
17 ------------------------------------------------

21
 Sl. 2-8 Rezultati simulacije VHDL kôda iz Pr. 2-4
Strukturni opis
Za razliku od bijhejvioralnog modeliranja koje je usredsređeno na funkciju kola, strukturno modeliranje opisuje
složenije kolo kao skup povezanih pod-kola manje složenosti. Strukturno modeliranje u VHDL-u zasnovano je
na konceptu komponenti. Komponenta je celoviti VHDL opisi (entitet plus arhitektura) koji se jednom piše, a
onda koristi za konstrukciju složenijih modela. Tipično, više komponenti se pakuje u jedan paket, koje se smešta
u biblioteku (Sl. 2-2).
Ispod je dat strukturni opis kola sa Sl. 2-7. U kôdu se koriste dva komponente, ni_kolo i dff. Pretpostavka je da se
funkcionalni opisi ovih komponenti nalaze u paketu nas_paket iz biblioteke nasa_biblioteka. U samom kôdu,
najpre su uključeni biblioteka i paket (linije 3 i 5), zatim su korišćene komponente deklarisane u deklarativnom
delu arhitekture (linije 13-22), i konačno instancirane i na odgovarajući način povezane u telu arhitekture (linije
25 i 26). Deklaracija komponente, slično entitetu, definiše ulazne i izlazne portove komponente. Naredba iz
linije 25 instancira (kreira) jedan primerak komponente ni_kolo i povezuje ga sa portovima i internim signalima
kola koje se projektuje. Tako, port d1, povezuje se na port a, port d2 na port b, a signal x na port q komponente
ni_kolo. Slično, u naredbi iz linije 26, kreira jedan dff i povezuje sa signalom x, i portovima clk i q.
1 ------------------------------------------------
2 LIBRARY ieee;
3 LIBRARY nasa_biblioteka;
4 USE ieee.std_logic_1164.all;
5 USE nasa_bibloteka.nas_paket.all;
6 ------------------------------------------------
7 ENTITY primer IS
8 PORT( d1, d2, clk: IN BIT;
9 q : OUT BIT);
10 END primer;
11 ------------------------------------------------
12 ARCHITECTURE struct OF primer IS
13 ---- komponenta dff -------------------
14 COMPONENT dff IS
15 PORT (d, clk: IN STD_LOGIC;
16 q: OUT STD_LOGIC);
17 END COMPONENT;
18 ---- komponenta ni_kolo ---------------
19 COMPONENT ni_kolo IS
20 PORT (a, b : IN STD_LOGIC;
21 c: OUT STD_LOGIC);
22 END COMPONENT;
23 SIGNAL x : STD_LOGIC;
24 BEGIN
25 K1: ni_kolo PORT MAP(d1, d2, x);
26 K2: dff PORT MAP(x, clk, q);
27 END struct;
28 ------------------------------------------------
Krajnji cilj projektovanja je svakako realizacija fizičkog sistema. Sa jedne strane, rad na višem nivou apstrakcije
predstavlja prirodnu težnju projektanta (projektant je usredsređen na funkciju (algoritma rada) sistema). Sa
druge strane, fizički sistem se može realizovati samo na osnovu preciznog strukturnog modela. Tipično, sistem
se projektuje u više faza, gde se na početku kreira opis visokog nivoa, koji se potom razrađuje postepenim
ubacivanjem strukturnih detalja. U ovom procesu, uloga alata za sintezu je od ključne važnosti. Savremeni alati
za sintezu u mogućnosti su da tumače bihejvioralni opisa relativno visokog nivoa apstrakcije i kreiraju
ogovarajući implementacioni strukturni opis. Na primer, svi primeri VHDL kôd iz ovog poglavlja se mogu
sintetizovati. Međutim, alati za sintezu ne mogu da sintetišu bilo koju VHDL konstrukciju. U tom smislu, cilj
projektanta koji radi u VHDL-u, nije u kreiranju preciznog strukturnog opisa, već opisa koji će biti prihvatljiv
kao ulaz u alat za sintezu, tj. može se sintetizovati. Tipično, opisi složenijih sistema su hijerarhijski

22
organizovani, tako što na najvišem nivou hijerarhije postoji opis strukture koju čine nekoliko podsistema. Neki
od podsistema su opisani bihejvioralno, a drugi strukturno, pomoću još jednostavnijih komponenti, tako da se na
najnižem nivou hijerahije nalaze bihejvioralno opisane komponente koje se mogu sintetizovati.

2.2 Tipovi podataka

Tip podataka definiše skup vrednosti i skup operacija koje se mogu primeniti nad podacima datog tipa. VHDL
je strogo tipiziran jezik, što znači da su operacija koje se javljaju u naredbama legalne samo ako su tipovi
operanada usklađeni. Drugim rečima, nije dozvoljeno u istom izrazu koristiti operande različitog tipa. Primer
nelegalne operacije je sabiranje realnog i celog broja ili dodela binarne vrednosti celobrojnoj promenljivoj.
VHDL je bogat tipovima podataka. Osim tipova koji su ugrađeni u sam jezik (tzv. predefinisani tipovi), i
raspoloživi kroz standardne biblioteke i pakete, VHDL omogućava projektantu da definiše i nove, tzv.
korisničke tipove podataka. Pojedini tipovi podataka se mogu koristiti samo u simulaciji, dok se drugi mogu
koristiti i u sintezi. Dobro poznavanje tipova podataka, načina njihovog korišćenja i ograničenja, od velike je
važnosti za razumevanje VHDL jezika i efikasno pisanje VHDL kôda. U ovoj sekciji biće reči o svim važnim
tipovima podataka VHDL jezika, sa naglaskom na onima koje se koriste u sintezi. Međutim, pre nego što
pređemo na izlaganje o tipovima podatak, ukratko ćemo se upoznati za jezičkim objektima koji se u VHDL-u
koriste za reprezentaciju i manipulaciju podacima.

2.2.1 Objekti podataka

Za reprezentaciju podatka u VHDL-u se koriste tri tipa objekata: signali, varijable i konstante. Signali se koriste
za povezivanje komponenti i razmenu podataka između entiteta. Mogu se zamisliti kao električne veze u
fizičkom kolu. Varijable odgovaraju promenljivama iz programskih jezika. Koriste se za čuvanje lokalnih
podataka u procesu ili proceduri. Konstante se koriste za imenovanje konkretnih vrednosti. Pre korišćenja svaki
od tri objekat mora biti deklarisan. Deklaracija definiše ime objekta, njegov tip i opciono inicijalnu (početnu)
vrednost. Na primer:
SIGNAL vcc : std_logic := ‘1’; -- deklaracija signala tipa std_logic.
-- Inicijalna vrednost signal je ‘1’
VARIABLE state : INTEGER; -- deklaracija varijablu tipa INTEGER
CONSTANT PI: REAL := 3.1414; -- deklaracija konstante tipa REAL
Signal i konstante se mogu deklarisati u entitetu, arhitekturi ili paketu. Deklarisani u paketu, signali i konstante
su globalni, tj. vidljivi u svih delovim kôda koji koriste odgovarajući paket. Varijable se mogu deklarisati samo
u procesu ili proceduri i nisu vidljive izvan procesa/procedure u kome su deklarisane. Vrednost konstante ne
može da se menja u kôdu. Signali i varijable su promenljivi objekti, odnosno može im se dodeliti nova vrednost.
Za dodelu vrednosti signalu koristi se simbol <=, a za dodelu varijabli simbol :=.
Detaljnijim razmatranjem osobina signala, varijabli i konstanti bavićemo se u poglavlju 2.6.

2.2.2 Predefinisani tipovi podataka

Predefinisani tipovi podataka deo su standarda VHDL jezika i definisani su u sledećim paketima/bibliotekama:
- Paket stadard iz biblioteke std definiše tipove: BIT, BOOLEAN, INTEGER i REAL.
- Paket std_logic_1164 iz biblioteke ieee definiše tipove: STD_LOGIC i STD_ULOGIC.
- Paket std_logic_arith iz biblioteke ieee definiše tipove SIGNED i UNSIGNED, kao i nekoliko funkcija
za konverziju podataka iz jednog u neki drugi tip, kao što su conv_integer(p), conv_unsigned(p, b),
conv_signed(p, b) i conv_std_logic_vector(p, b).
- Paketi std_logic_signed i std_logic_unsigned iz biblioteke ieee definišu funkcije koje omogućavaju da
se operacije nad operandima tipa STD_LOGIC_VECTOR obavljaju kao da su tipa SIGNED ili
UNSIGNED, respektivno.
U nastavku će biti opisani svi pomenuti tipovi podataka.
BIT (i BIT_VECTOR): definiše dvonivovsku logiku. Dozvoljene vrednosti tipa BIT su ΄0΄ i ΄1΄.
BIT_VECTOR je vektorska varijanta ovog tipa, tj. definiše niz (vektor) bitova.
SIGNAL x : BIT;
-- deklariše x kao jednobitni signal tipa BIT
SIGNAL y : BIT_VECTOR(3 DOWNTO 0);
-- y je 4-bitni vektor. Krajnji levi bit je bit najveće težine (MSB)

23
SIGNAL w : BIT_VECTOR(0 TO 7);
-- w je 8-bitni vektor. Krajnji desni bit je bit najveće težine (MSB).
SIGNAL z : BIT := ´1´;
-- z je jednobitni signal inicijalne vrednost ´1´.
U gornjim primerima, signal x je skalar (može da sadrži samo jednu binarnu vrednost), a signali y i w vektori
(sadrže niz bitova). Uočimo da je deklaracija vektorskog tip praćena konstrukcijom (n DOWNTO m), odnosno
(n TO m) koja definiše dužinu vektora i opseg indeksa. n i m su vrednosti početnog i krajnjeg indeksa u nizu. Za
DOWNTO važi n≥m, a za TO n≤m. Vektor sadrži m-n+1 elemenata, za DOWNTO, odnosno n-m+1 elemenata,
za TO varijantu. U gornjim primerima, y je vektor dužine 3-0+1=4, a w vektor dužine 7-0+1=8 bita. Svakom
elementu vektora pridružen je indeks koji ukazuje na njegovu poziciju u vektoru. Ključne reči DOWNTO i TO
ukazuju da li kretanjem kroz niz, s leva na desno, indeksi opadaju ili rastu. Za DOWNTO važi da krajnji levi
element vektora ima najveći, a krajnji desni najmanji indeks. Za TO važi obrnuto, krajnji levi element ima
najmanji, a krajnji desni najveći indeks. Kod tipova koji služe za predstavljanje binarnih vrednosti (kao što su
BIT ili STD_LOGIC) element (bit) na poziciji indeksa najveće vrednosti naziva se bitom najveće težine (MSB -
Most Sifnicant Bit). Bit na poziciji najmanjeg indeksa je bit najmanje težine (LSB - Last Significant Bit) .
Prilikom deklaracije signala (varijable), dozvoljeno je postaviti početnu (inicijalnu) vrednost, kao u poslednjem
primeru. Inicijalna vrednost se navodi posle znaka :=. Treba napomenuti da inicijalne vrednosti signala i
varijabli imaju značaj samo u simulaciji, dok se prilikom sinteze ne uzimaju u obzir.
Sledeće naredbe dodele su legalne:
x <= ΄1΄;
-- jednobitnom signalu x dodeljuje se vrednost ‘1΄. Za pisanje
-- jednobitnih vrednosti koriste se jednostruki znaci navoda (΄ ΄).
y <=˝0111˝;
-- 4-bitnom signalu se dodeljuje vrednost ˝0111˝ (MSB=΄0΄). Vektori se
-- pišu pod dvostrukim navodnicima (˝ ˝).
w <=˝01110001˝;
-- 8-bitnom signalu w dodeljuje se vrednost ˝01110001˝ (MSB=΄1΄).
Skalarne vrednosti se pišu pod jednostrukim, a vektorske pod dvostrukim navodnicima. Za pristup pojedinačnim
elementima vektora koristi se indeksiranje. Na primer, elementi vektora y, kod koga važi DOWNTO redosled,
su y(3), y(2), y(1) i y(0), čije su vrednosti redom, ´0´, ´1´, ´1´ i ´1´. Elementi vektora w (TO redosled), su w(0),
w(1), ..., w(7), čije su vrednosti redom ´0´, ´1´, ..., ´1´.
DOWNTO redosled se obično koristi ako se vektor tumači kao binarni broj. Navikli smo da kod zapisivanja
binarnih brojeva krajni levi bit bude bit najveće težine. Tako, zapis ˝0111˝ predstavlja broj 7. Da je signal y bio
deklarisan sa indeksima u TO redosledu (SIGNAL y : BIT_VECTOR(0 DOWNTO 3)), tada bi vrednost
binarnog broja y <=˝0111˝ bila 14.
STD_LOGIC (i STD_LOGIC_VECTOR): definiše 8-nivovski logički sistem. Dozvoljene vrednosti su
sledeće:
΄X΄ Nepoznata vrednost
΄0΄ Nizak nivo (sintetiše se kao logička ΄0΄)
΄1΄ Visok nivo (sintetiše se kao logička ΄1΄)
΄Z΄ Visoka impedansa (sintetiše se kao tro-statički bafer)
΄W΄ ˝Slaba˝ nepoznata vrednost
΄L΄ ˝Slab˝ nizak nivo
΄H΄ ˝Slab˝ visok nivo
΄-΄ Proizvoljna vrednost
SIGNAL x : STD_LOGIC;
-- deklariše x kao jednobitni (skalarni) signal tipa STD_LOGIC
SIGNAL y : STD_LOGIC_VECTOR(3 DOWNTO 0) := ˝0001˝;
-- deklariše y kao 4-bitni vektor i dodeljuje mu inicijalnu vrednost ˝0001˝
-- Inicijalna vrednost je opciona, a dodeljuje se operatorom ˝:=˝ .
-- Krajnji levi bit je bit najveće težine (MSB).
Tip STD_LOGIC je prevashodno namenjen modelovanju električnih veza u digitalnim sistemima. Svaka fizička
veza se pobuđuje najčešće jednim izlazom nekog digitalnog kola (drajver veze). Drajver može da pobuđuje vezu
logičkom ΄1΄ ili ΄0΄. Takođe, izlaz drajvera može biti u stanju visoke impedanse ΄Z΄. U upotrebi su i digitalna
kola sa izlazom tipa ˝otvoreni kolektor˝ koja zahtevaju ugradnju spoljašnjeg otpornika (tzv ΄pull-up΄). Drajver
tipa otvoreni kolektor postavlja ˝jaku˝ ΄0΄, ali ˝slabu˝ ΄1΄, tj. slab visok nivo (΄H΄). Drajver koji zahteva ugradnju

24
˝pull-down˝ otpornika postavlja ˝jaku˝ ΄1΄ i ˝slabu˝ ΄0΄, tj. slab nizak nivo (΄L΄). U nekim slučajevima više
drajvera mogu da pobuđuju istu vezu (tipičan primer su magistrale). S obzirom da u jednom momentu na vezi
može da postoji samo jedan logički nivo, problem se javlja kada drajveri generišu različite logičke vrednosti
(pojava konflikta). Konflikti se razrešavaju tako što se signalu dodeljuje vrednost ˝najjačeg˝ od svih logičkih
nivoa kojima je veza pobuđena. Na primer, ako neku vezu pobuđuju dva drajver, tako da je jedan u stanju
visoke impedanse (΄Z΄), a drugi generiše ΄1΄, rezultujuća vrednost signala na liniji biće ΄1΄. Ili, ako jedan drajver
generiše ΄1΄, a drugi ΄0΄, rezultujuća vrednost biće nepoznata (΄X΄). Pravila za razrešavanje konflikta u logičkom
sistemu tipa STD_LOGIC navedena su u tabeli. Većina dozvoljenih vrednosti tipa STD_LOGIC koriste se samo
u simulaciji. U VHDL kôdu koji je namenjen sintezi dozvoljeno je signalima ovog tipa dodeljivati samo
vrednosti ΄1΄, ΄0΄ ili ΄Z΄.
X 0 1 Z W L H -
X X X X X X X X X
0 X 0 X 0 0 0 0 X
1 X 0 1 1 1 1 1 X
Z X 0 1 Z W L H X
W X 0 1 W W W W X
L X 0 1 L W L W X
H X 0 1 H W W H X
- X X X X X X X X

STD_ULOGIC (i STD_ULOGIC_VECTOR): definiše 9-nivovski logički sistem (΄U΄, ΄X΄, ΄0΄, ΄1΄, ΄Z΄, ΄W΄,
΄L΄, ΄H΄, ΄-΄). U suštini, tip STD_LOGIC je podtip tipa STD_ULOGIC koji definiše još jednu dodatnu vrednost
΄U΄ - nerazrešena vrednost. Za razliku od tipa STD_LOGIC, kod koga se konfliktne vrednosti automatski
razrešavaju, STD_ULOGIC ne dozvoljava ˝kratke spojeve˝, tj. ne predviđa mogućnost da više od jednog
drajvera pobuđuje istu vezu. Ako se to ipak desi, signal dobija vrednost ΄U΄, što ukazuje na projektantsku
grešku.
BOOLEAN: definiše logičke vrednosti true (tačno) i false (netačno).
INTEGER: 32-bitni celi (integer) brojevi. Opseg dozvoljenih vrednosti je -2,147,483,647 do +2,147,483,647
NATURAL: nenegativni celi (prirodni) brojevi (od 0 do +2,147,483,647).
REAL: realni brojevi iz opsega -10 38 do +10 38. (ne sintetišu se).
Fizičke jedinice: za označavanje fizičkih veličina kao što su vreme, napon i td. Korisni u simulaciji, ali nisu
dozvoljene u kôdu za sintezu.
Karakteri: pojedinačni ASCII karakteri (slova, cifre i specijalni znaci) ili stringovi ASCII karaktera.
SIGNED i UNSIGNED: po obliku su identični tipu STD_LOGIC_VECTOR, ali dozvoljavaju primenu
aritmetičkih operacija karakterističnih za tip INTEGER.
Primeri:
x0 <= ΄1΄; -- tip signala x0 može biti bit, std_logic ili std_ulogic
x1 <= ˝00011111˝; -- tip signala x1 može biti bit_vector, std_logic_vector,
-- std_ulogic_vector, signed ili undigned
x2 <= ˝0001_1111˝;-- dozvoljena crta za podvlačenje (poboljšava čitljivost)
x3 <= ˝101111˝; -- binarna reprezentacija decimalnog broja 47
x3 <= B˝101111˝; -- binarna reprezentacija decimalnog broja 47
x3 <= O˝57˝; -- oktalna reprezentacija decimalnog broja 47
x3 <= X˝2F˝; -- heksadecimalna reprezentacija decimalnog broja 47
n <= 1200; -- n je integer
IF ready THEN ... –- ready je tipa boolean. THEN grana se izvršava
-- ako je ready = True
y <= 1.2E-5; -- y je signal tipa real.
q <= d after 10 ns; -- ns je fizička jedinica za vreme (nanosekunde).

Primeri:
SIGNAL a: BIT;

25
SIGNAL b: BIT_VECTOR(7 DOWNTO 0);
SIGNAL c: STD_LOGIC;
SIGNAL d: STD_LOGIC_VECTOR(7 DOWNTO 0);
SIGNAL e: INTEGER RANGE 0 TO 255;
...
a <= b(5); -- ispravno (a i b(5) su skalari tipa BIT)
b(0) <= a; -- ispravno (b(0) i a su skalari tipa BIT)
a <= d(5); -- ispravno (a i d(5) su skalari tipa STD_LOGIC)
d(0) <= c; -- ispravno (d(0) i c su skalari tipa STD_LOGIC)
a <= c; -- neispravno (neslaganje tipova: a - BIT c – STD_LOGIC)
b <= d; -- neispravno (neslaganje tipova: b – BIT_VECTOR
-- d – STD_LOGIC_VECTOR)
e <= b; -- neispravno (neslaganje tipova: e – INTEGER,
-- b – BIT_VECTOR)
e <= d; -- neispravno (neslaganje tipova: e – INTEGER,
-- b – STD_LOGIC_VECTOR)

2.2.3 Korisnički tipovi podataka

VHDL omogućava projektantu da definiše svoje sopstvene tipove podataka (tzv. korisnički tipovi). Postoje dve
kategorije korisničkih tipova podataka: celobrojni (integer) i nabrojivi (enumeration).
Korisnički integer tipovi:
TYPE integer IS RANGE -2147483647 TO +2147483647;
-- ekvivalentno predefinisanom tipu INTEGER
TYPE natural IS RANGE 0 TO +2147483647;
-- ekvivalentno predefinisanom tipu NATURAL
TYPE mali_integer IS RANGE -32 TO 32;
-- podskup celih (integer) brojeva iz opsega -32 do 32
TYPE ocena IS RANGE 5 TO 10;
-- podskup celih ili prirodnih (natural) brojeva iz opsega 5 do 10
Kao što se može zaključiti iz datih primera, celobrojni tipovi su podskup tipa INTEGER definisan opsegom
(RANGE) celih brojeva. Koristi se kada treba ograničiti opseg vrednosti koje se mogu dodeliti celobrojnoj
varijabli ili signalu:
VARIABLE markova_ocena, anina_ocena : ocena; -- deklariše dve varijable tipa ocena
markova_ocena := 8;-- ispravno, dozvoljena ocena
anina_ocena := 11; -- grešaka, ocena ne može biti veća od 10.
-- (kompajler će prijaviti grešku)
Korisnički nabrojivi tipovi:
TYPE bit IS (΄0΄, ΄1΄);
-- ekvivalentno predefinisanom tipu BIT
TYPE nasa_logika IS (΄0΄, ΄1΄, ΄Z΄);
-- podskup std_logic vrednosti
TYPE bit_vector IS ARRAY (NATURAL RANGE <>) OF BIT;
-- ekvivalentno predefinisanom tipu BIT_VECTOR
-- RANGE <> označava opseg bez eksplicitno navedenih granica
-- NATURAL RANGE <> ograničava RANGE <> na opseg NATURAL tipa.
-- ARRAY - službena reč za deklaraciju niza.
TYPE stanje IS (iskljuceno, napred, nazad, stop);
-- definiše nabrojivi tip – dozvoljene vrednosti su eksplicitno navedene
-- (tipična upotreba kod konačnih automata)
TYPE boja IS (crvena, zelena, plava, bela);
-- još jedan primer nabrojivog tipa

26
Deklaracija nabrojivog tipa definiše tip podataka koji čini skup korisnički-definisanih vrednosti. Na primer,
deklaracija tipa boja osim imena tipa (boja) sadrži i imena dozvoljenih vrednosti pridruženih ovom tipu (crvena,
zelena, plava i bela). Ove vrednosti su apstraktne jer ne predstavljaju ni brojnu vrednost ni fizičku veličinu, već
imaju značenje koje je poznato samo korisniku (projektantu). Korišćenje korisničkih tipova poboljšava čitljivost
(razumljivost) kôda i smanjuje mogućnost greške u pisanju kôda. Treba napomenuti da je svakoj vrednosti iz
deklaracije nabrojivog tipa implicitno pridružen redni broj koji odgovara njenoj poziciji u spisku navedenih
vrednosti. Tako, vrednost crvena, iz poslednje navedene deklaracije, ima redni broj 0, zelena 1 i td. Poredak
vrednosti je od značaja ako se one koriste u relacionim izrazima (<, >, =). Tako, na primer, izraz (crvena <
plava) je tačan, a izraz (bela < zelena) netačan. Predefinisani tipovi BIT, STD_LOGIC i STD_ULOGIC su
takođe nabrojivi tipovi.

2.2.4 Podtipovi
Podtip (SUBTYPE) je tip sa ograničenjem. Ograničenje definiše podskup vrednosti osnovnog tipa koje se
pridružuju podtipu. Podtip nasleđuje sve operacije osnovnog tipa.
Sledeći podtipovi izvedeni su iz tipova definisanih u prethodnoj sekciji.
SUBTYPE natural IS INTEGER RANGE 0 TO INTEGER΄HIGH;
-- prirodni brojevi su podtip (podskup) celih brojeva
-- INTEGER'HIGH znači ˝najveća vrednosti tipa INTEGER˝
SUBTYPE nasa_logika IS STD_LOGIC RANGE ΄0΄ TO ΄Z΄;
-- STD_LOGIC = (΄X΄,΄0΄,΄1΄,΄Z΄,΄W΄,΄L΄,΄H΄,΄-΄)
-- nasa_logika = (΄0΄,΄1΄,΄Z΄)
SUBTYPE nasa_boja IS boja RANGE crvena TO plava;
-- boja = (crvena, zelena, plava, bela)
-- nasa_boja = (crvena, zelena, plava)
SUBTYPE mali_integer IS INTEGER RANGE -32 TO 32;
-- podtip tipa INTEGER
Uporedimo definiciju podtipa mali_integer sa definicijom istoimenog tipa iz prethodne sekcije. Oba tipa su
izvedena iz tipa INTEGER, imaju identičan skup vrednosti i skup dozvoljenih operacija. Čini se da se radi o
ekvivalentnim deklaracijama. Međutim, postoji jedna bitna razlika. Vrednosti tipa mali_integer ne mogu se
kombinovati sa vrednostima tipa INTEGER u operacijama kao što su ΄+΄ i ΄-΄. Sa druge strane, dozvoljeno je, u
istom izrazu, kombinovati vrednosti podtipa mali_integer i vrednosti tipa INTEGER.
Primeri:
TYPE nova_logika IS STD_LOGIC RANGE ΄0΄ TO ΄1΄;
SUBTYPE nasa_logika IS STD_LOGIC RANGE ΄0΄ TO ΄1΄;
SIGNAL a: BIT;
SIGNAL b: STD_LOGIC;
SIGNAL c: nasa_logika;
SIGNAL d: nova_logika;
...
b <= a; -- neispravno (b je STD_LOGIC, a je BIT)
b <= c; -- ispravno (isti osnovni tip)
b <= d; -- neispravno (b je STD_LOGIC, d je nova_logika)

2.2.5 Polja
Polja su kolekcije objekata istog tipa. Polja mogu biti jednodimenziona (1D ili vektori), dvodimeniziona (2D ili
matrice) ili 1D x 1D. Polja viših dimenzija (npr. 3D ili 2D x 2D) se ređe koriste i obično nisu podržana u alatima
za sintezu. Na Sl. 2-9 je ilustrovana organizacija polja. Pojedinačna vrednost (ili skalar) prikazana je na Sl. 2-9(a),
vektor (1D polje) na 3-1(b), polje vektora (1D x 1D polje) na 3-1(c) i polje skalara (2D polje) na 3-1(d).

27
 (a) (b) (c) (d)
Sl. 2-9 (a) skalar, (b) 1D, (c) 1D x 1D, (d) 2D polja.
Svi predefinisani tipovi podataka su ili skalari ili vektori (jednodimenziona polja skalara). Sledeći predefinisani
tipovi se mogu sintetizovati:
- Skalari: BIT, STD_LOGIC, STD_ULOGIC i BOOLEAN.
- Vektori: BIT_VECTOR, STD_LOGIC_VECTOR, STD_ULOGIC_VECTOR, INTEGER, SIGNED i
UNSIGNED.
Ne postoje predefinisana 2D ili 1D x 1D polja. Ako su neophodna, takva polja mogu biti definisana od strane
projektanta. Novo polje se definiše shodno sledećoj sintaksi:
TYPE ime_tipa IS ARRAY (opseg_indeksa) OF tip;

Pr. 2-5 1D x 1D polje.

Naš zadatak je da konstruišemo polje od četiri vektora dužine osam bita. Pojedinačne vektore nazvaćemo vrsta,
a celokupnu strukturu matrica. Takođe, usvojićemo da je bit najveće težine (MSB) svakog vektora njegov
krajnji levi bit i da je prva vrsta matrice vrsta 0. Postavljenim zahtevima odgovaraju sledeće deklaracije:
TYPE vrsta IS ARRAY (7 DOWNTO 0) OF STD_LOGIC; -- 1D polje
TYPE matrica IS ARRAY (0 TO 3) OF vrsta; -- 1D x 1D polje
SIGNAL x: matrica; -- 1D x 1D signal
Identično 1D x 1D polje može se definisati i u jednoj liniji, na sledeći način:
TYPE matrica IS ARRAY (0 TO 3) OF STD_LOGIC_VECTOR(7 DOWNTO 0);

Pr. 2-6 2D polje.

Polje definisano sledećom linijom kôda je ˝pravo˝ dvodimenzionalno polje, u potpunosti zasnovano na
skalarima, a ne na vektorima, kao u prethodnom primeru:
TYPE matrica2D IS ARRAY (0 TO 3, 7 DOWNTO 0) OF STD_LOGIC; -- 2D polje

Pr. 2-7 Inicijalizacija polja.

Dodela inicijalnih vrednosti SIGNAL-ima i VARIABLE-ma je opciona. Onda kada je potrebna, može se obaviti
kao u sledećim primerima:
... := “0001”; -- za 1D polje
... := (΄0΄, ΄0΄, ΄0΄, ΄1΄); -- za 1D polje
... := ((‘0΄, ΄1’, '0', '1'), ('1', '1', '0', '1')); -- za 1D x 1D polje

Pr. 2-8 Polja u naredbama dodele.

Najpre, definišimo nekoliko različitih polja i signala:
TYPE vrsta IS ARRAY (7 DOWNTO 0) OF STD_LOGIC; -- 1D polje
TYPE polje1 IS ARRAY (0 TO 3) OF vrsta; -- 1Dx1D polje
TYPE polje2 IS ARRAY (0 TO 3) OF STD_LOGIC_VECTOR(7 DOWNTO 0); -- 1Dx1D polje
TYPE polje3 IS ARRAY (0 TO 3, 7 DOWNTO 0) OF STD_LOGIC; -- 2D polje
SIGNAL x: vrsta;
SIGNAL y: polje1;
SIGNAL v: polje2;
SIGNAL w: polje3;
------------- Ispravne skalarne naredbe dodele: --------------------------
-- Sve navedene skalarne (jednobitne) naredbe dodele su ispravne, zato što
-- je osnovni (skalarni) tip svih signala (x,y,v,w) STD_LOGIC
x(O) <= y(1)(2); -- uočimo dva para zagrada (y je lDxlD)
x(l) <= v(2)(3); -- dva para zagrada (v je 1Dx1D)
x(2) <= w(2,1); -- jedan par zagrada (w je 2D)
y(l)(l)<= x(6);

28
y(2)(0)<= v(0)(0);
y(0)(0)<= w(3,3);
w(l,l) <= x(7);
w(3,0) <= v(0)(3);
----------- Vektorske naredbe dodele: ------------------------------------
x <= y(O); --ispravno (isti tip podataka: vrsta)
x <= v(l); --neispravno (neusklađeni tipovi: vrsta x
--STD-LOGIC-VECTOR)
x <= w(2); --neispravno (pogrešno indeksiranje, w je 2D)
x <= w(2, 2 DOWNTO 0); --neispravno (neusklađeni tipovi: vrsta x i w STD_LOGIC)
v(O) <= w(2, 2 DOWNTO 0); --neispravno (neusklađeni tipovi:
--STD_LOGIC_VECTOR v i STD_LOGIC w)
v(0) <= w(2); --neispravno (w je 2D)
y(l) <= v(3); --neispravno (neusklađeni tipovi: vrsta y i
--STD_LOGIC_VECTOR) v
y(1)(7 DOWNTO 3)<= x(4 DOWNTO 0); --ispravno (isti tip, ista veličina)
v(1)(7 DOWNTO 3)<= v(2)(4 DOWNTO 0); --ispravno (isti tip, ista veličina)
w(l,5 DOWNTO 1) <= v(2)(4 DOWNTO 0); --neispravno (nausklađeni tipovi)
Obratimo pažnju kako se pristupa elementima polja različite dimenzionalnosti. Za pristup 1D polju (vektoru)
koristi se jednodimnezioni indeks (npr. vrsta(2)). Za pristup 1Dx1D polju koristi se par jednodimenzionih
indeksa (npr. y(4)(2) - prvi indeks, (4), se odnosi na vektor, drugi, (2), na element u vektoru). Elementima
matrice se pristupa dvodimenizionim indeksom (npr. w(2,3)). Takođe, VHDL omogućava pristup delovima
polja. Na primer, v(2)(4 DOWNTO 0) označava sve bitove od četvrtog do nultog, drugog vektora polja v.

2.2.6 Polja portova

Kao što je naglašeno u prethodnoj sekciji, ne postoje predefinisani tipovi podataka sa više od jedne dimenzije.
Međutim, u specifikaciji ulaznih i izlaznih portova (u okviru deklaracije entiteta), može se javiti potreba za
portovima koji su polja vektora. Pošto u entitetu deklaracija TYPE nije dozvoljena, rešenje je da se odgovaraju ći
korisnički tip podataka definiše u paketu (PACKAGE) koji će biti priključen projektu, a time vidljiv i u entitetu.
Ispod je dat primer:
------- Paket: ---------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
------------------------------------------------------
PACKAGE nasi_tipovi_podataka IS
TYPE polje_vektora IS ARRAY (NATURAL RANGE <>) OF STD_LOGIC_VECTOR(7 DOWNTO 0);
END nasi_tipovi_podataka;
------------------------------------------------------
------- Glavni kôd: ----------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all
USE work.nasi_tipovi_podataka.all; --korisnički definisani paket
-----------------------------------------------------
ENTITY mux IS
PORT (inp: IN POLJE_VEKTORA(0 TO 3);
...);
END mux;
...;
-----------------------------------------------------
U izloženom primeru kreiran je korisnički tip podataka, nazvan polje_vekotora, koji može sadržati neograničen
broj vektora veličine osam bita. (Konstrukcija NATURAL RANGE <> znači da opseg nije fiksiran, već je jedino
ograničen opsegom tipa NATURAL, od 0 do +2,147,483,647.) Definicija novog tipa podataka smeštena je u
paketu nasi_tipovi_podataka, a potom iskorišćena u entitetu za deklaraciju porta inp. Uočimo da u glavnom delu
kôda postoji klauzula USE kojom se paket nasi_tipovi_podataka uključuje u projekat. Više detalja o paketima
biće dato u sekciji.

2.2.7 Označeni i neoznačeni tipovi podataka

Označeni i neoznačeni tipovi podataka definisani su u paketu std_logic_arith. Njihova sintaksa ilustrovana je u
sledećim primerima:
SIGNAL x: SIGNED(7 DOWNTO 0);

29
SIGNAL y: UNSIGNED(O TO 3);
Uočimo da je sintaksa više liči na sintaksu STD_LOGIC_VECTOR nego na INTEGER, kao što bi se možda
moglo očekivati.
Vrednost tipa UNSIGNED je broj koji nikada nije manji od nule. Na primer, ˝0101˝ predstavlja decimalno 5, a
˝1101˝ decimalno 13. Tip SIGNED sadrži i pozitivne i negativne brojeve (izražene u formatu dvojičnog
komplementa). To znači da SIGNED vrednost ˝0101˝ predstavlja decimalno 5, a ˝1101˝ decimalno -3.
Tipovi SIGNED i UNSIGNED u suštini predstavljaju proširenje tipa STD_LOGIC_VECTOR koje omogućava
primenu aritmetičkih operacija. Nasuprot tome, logičke operacije nisu dozvoljene. U pogledu relacija
(poređenja) ne postoje razlike.
Pr. 2-9. Ispravne i neispravne operacije sa označenim/neoznačenim tipom podataka:
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.std_logic_arith.all; -- dodatni paket je neohodan
. . .
SIGNAL a: SIGNED(7 DOWNTO 0);
SIGNAL b: SIGNED(7 DOWNTO 0);
SIGNAL c: SIGNED(7 DOWNTO 0);
. . .
c <= a + b; -- ispravno (aritmetičke operacije su dozvoljene)
c <= a AND b; -- neispravno (logičke operacije nisu dozvoljene)

Ispravne i neispravne operacija sa tipom STD_LOGIC_VECTOR:

LIBRARY ieee;
USE ieee.std_logic_1164.all;
. . .
SIGNAL a: STD_LOGIC_VECTOR(7 DOWNTO 0);
SIGNAL b: STD_LOGIC_VECTOR(7 DOWNTO 0);
SIGNAL c: STD_LOGIC_VECTOR(7 DOWNTO 0);
. . .
c <= a + b; -- neispravno (aritmetičke operacije nisu dozvoljene)
c <= a AND b; -- ispravno (logičke operacije su dozvoljene)
Uprkos ograničenjima navedenim u prethodnom primeru, postoji jednostavan način da se omogući primena
aritmetičkih operacija nad podacima tipa STD_LOGIC_VECTOR. Dovoljno je u projekat uključiti jedan od
paketa std_logic_signed ili std_logic_unsigned iz biblioteke ieee. Ovi paketi omogućavaju da se sa podacima
tipa STD_LOGIC_VECTOR manipuliše kao da se radi sa podacima tipa SIGNED ili UNSIGNED, respektivno.
Pr. 2-10 Aritmetičke operacije sa podacima tipa STD_LOGIC_VECTOR.
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.std_logic_unsigned.all; -- dodatni paket je neohodan
. . .
SIGNAL a: STD_LOGIC_VECTOR(7 DOWNTO 0);
SIGNAL b: STD_LOGIC_VECTOR(7 DOWNTO 0);
SIGNAL c: STD_LOGIC_VECTOR(7 DOWNTO 0);
. . .
c <= a + b; -- ispravno (aritmetičke operacije su dozvoljene)
c <= a AND b; -- ispravno (logičke operacije su dozvoljene)

2.2.8 Konverzija podataka

VHDL ne dozvoljava direktnu primenu operacija (aritmetičkih, logičkih i td.) nad podacima različitog tipa.
Zbog toga, često je neophodno konvertovati podatak iz jednog u neki drugi tip. To se može postići na dva
načina: napisati poseban VHDL kôd (funkciju) za tu namenu, ili iskoristiti funkcije za konverziju iz
odgovarajućeg predefinisanog paketa.

30
Paket std_logic_arith iz biblioteke ieee sadrži nekoliko funkcija za konverziju podataka. To su:
- conv_integer(p) : Konvertuje vrednost parametra p tipa INTEGER, UNSIGNED, SIGNED, ili
STD_ULOGIC u vrednost INTEGER tipa. Uočimo da tip STD_LOGIC_VECTOR nije podržan.
- conv_unsigned(p, b) : Konvertuje vrednost parametra p tipa INTEGER, UNSIGNED, SIGNED, ili
STD_ULOGIC u b-bitnu vrednost tipa UNSIGNED.
- conv_signed(p, b) : Konvertuje vrednost parametra p tipa INTEGER, UNSIGNED, SIGNED, ili
STD_ULOGIC u b-bitnu vrednost tipa SIGNED.
- conv_std_logic_vector(p, b) : Konvertuje vrednost parametra p tipa INTEGER, UNSIGNED, SIGNED,
ili STD_LOGIC u b-bitnu vrednost tipa SIGNED.
Pr. 2-11 Konverzija podataka.
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.std_logic_arith.all;
. . .
SIGNAL a: UNSIGNED(7 DOWNTO 0);
SIGNAL b: UNSIGNED(7 DOWNTO 0);
SIGNAL y: STD_LOGIC_VECTOR(7 DOWNTO 0);
. . .
y <= CONV_STD_LOGIC_VECTOR((a+b),8);
-- ispravna operacija: a+b se konvertuje iz UNSIGNED u
-- 8-bitnu STD_LOGIC_VECTOR vrednost koja se dodeljuje signalu y
Druga mogućnost je ona pomenuta u prethodnoj sekciji, a odnosi se na korišćenje paketa std_logic_signed ili
std_logic_unsigned iz biblioteke ieee. Ovi paketi omogućavaju da se operacije nad podacima tipa
STD_LOGIC_VECTOR obavljaju kao da se radi o podacima tipa SIGNED ili UNSIGNED, respektivno.

2.3 Operatori i atributi

2.3.1 Operatori
Operatori su specijalni karakteri (ili nizovi karaktera) koji govore kompajleru koju operaciju želim da izvršimo
nad operandima (koji mogu biti signali, varijable, konstante ili složeniji izrazi). VHDL poseduje sledeće
kategorija predefinisanih operatora:
• Operatori dodele
• Logički operatori
• Aritmetički operatori
• Operatori poređenja
• Operatori pomeranja
• Operatori nadovezivanja
Operatori dodele:
Koriste se za dodelu vrednosti signalima, varijablama i konstantama. Postoje dva operatora dodele:

<= Koristi se za dodelu vrednosti SIGNAL-u

:= Koristi se za dodelu vrednosti varijabli (VARIABLE), konstanti (CONSTANT) ili GENERIC
konstrukciji. Takođe se koristi za dodelu inicijalnih vrednosti.

Pr. 2-12 Operatori dodele.

SIGNAL x: STD_LOGIC;
VARIABLE y: STD_LOGIC_VECTOR(3 DOWNTO 0); -- krajnji levi bit je MSB
SIGNAL w: STD_LOGIC_VECTOR(0 TO 7); -- krajnji desni bit je MSB
. . .
x <= ‘1΄; -- signalu x dodeljuje vrednost ‘1΄
y := “0000”; -- varijabli y dodeljuje vrednost “0000”
w <= “10000000”; -- bit najmanje težine (LSB) je ΄1΄, ostali bitovi su ΄0΄

31
w <= (0=>'1', 3=>'1', OTHERS => '0') -- w(0)=w(3)= ΄1΄, ostali bitovi su ΄0΄.
-- Ekvivalentno prethodnoj naredbi.
Obratimo pažnju na poslednja dva od gore navedenih primera naredbi dodele. Notacija “10000000” iz naredbe
w <= “10000000” predstavlja kompaktnu reprezentaciju 8-bitnog binarnog vektora, gde se podrazumeva da
krajnji levi bit ima indeks 0, sledeći 1, i td. U sledećoj naredbi, koja ima isti efekat kao i prethodna, sadržaj
vektora definisan je na drugačiji način. Pojedinačnim elementima vektora se direktno pridružuju vrednosti
notacijom i => v, gde je i indeks elementa, a v vrednost koja je dodeljuje tom elementu. (Na primer, 0=>'1'
znači da se bitu sa indeksom 0, dodeljuje vrednost '1'). Kod ovakvog načina predstavljanja vektora, ključna reč
OTHERS ima posebno značenje jer zamenjuje sve indekse kojima nije direktno dodeljena vrednost. Ova
mogućnost je posebno bitna u slučajevima kada dužina vektora unapred nije poznata. Dozvoljeno je i sledeća
konstrukcija:
w <= (OTHERS => '0');
koja inicijalizuje vektor w na sve nule.
Logički operatori:
Koriste se za obavljanje logičkih operacija. To su:
• NOT
• AND
• OR
• NAND
• NOR
• XOR
• XNOR
Logički operatori su definisani za sledeće predefinisane tipove podataka: BIT, BOOLEAN, STD_LOGIC,
STD_ULOGIC i odgovarajuća 1D polja (BIT_VECTOR, STD_LOGIC_VECTOR i
STD_ULOGIC_VECTOR). Operator NOT je unarni i ima viši prioritet od svih ostalih operatora.
Pr. 2-13 Logičke operacije nad skalarima
SIGNAL a, b, c, y: STD_LOGIC;
. . .
y <= NOT a AND b; -- (a΄b)
y <= NOT (a AND b); -- (ab)΄
y <= a NAND b; -- (ab)΄
Operatori NAND i NOR nisu asocijativni. Zbog toga, sledeća sintaksa nije ispravna:
y <= a NAND b NAND c;
neophodne su zagrade:
y <= (a NAND b) NAND c;

Pr. 2-14 Logičke operacije nad vektorima

Logičke operacije nad vektorima izvršavaju se nezavisno nad svakim parom odgovarajućih bitova dva vektora.
Pri tome, vektori moraju biti iste dužine.
SIGNAL a, b, c: STD_LOGIC_VECTOR(7 DOWNTO 0);
. . .
a <= ˝00111010˝;
b <= ˝10000011˝;
c <= NOT a; -- c dobija vrednost ˝11000101˝
c <= a OR b; -- c dobija vrednost ˝10111011˝
c <= a XOR b; -- c dobija vrednost ˝10111001˝

Aritmetički operatori:
Koriste se za obavljanje aritmetički operacija. Primenjivi su na podatke tipa INTEGER, SIGNED, UNSIGNED,
ili REAL. Ako je u projekat uključen paket std_logic_signed ili std_logic_unsigned iz biblioteke ieee, tada se

32
operatori sabiranja i oduzimanja mogu direktno primenjivati i nad podacima tipa STD_LOGIC_VECTOR.
Podržani su sledeći operatori:
+ Sabiranje
– Oduzimanje
* Množenje
/ Deljenje
** Stepenovanje
MOD Deljenje po modulu
REM Ostatak deljenja
ABS Apsolutna vrednost
U kôdu za sintezu ne postoje striktna ograničenja koja se odnose na korišćenje operacija sabiranja i oduzimanja.
U opštem slučaju to važi i za operaciju množenja. Kod deljenja, dozvoljeni su samo delioci koji imaju vrednost
stepena dvojke (svodi se na operaciju pomeranja). Stepenovanje je dozvoljeno samo prilikom definisanja
vrednosti konstante (osnova i eksponent mogu biti samo konkretne vrednosti). Alati za sintezu, po pravilu, ne
podržavaju poslednja tri operatora (MOD, REM i ABS). Rezultat operacije x REM y je ostatak celobrojnog
deljenja x/y (= x – (x/y)*y). Znak rezultata isti je kao znak levog operanda. Npr. 7 REM 4 = 3; (-7) REM 4 = -3;
7 REM (-4) = 3. Rezultat operacije x MOD y jednak je x – y*N, gde je N najveći ceo broj za koji važi x ≤ y*N.
Znak rezultata isti je kao znak desnog operanda. Npr. 7 MOD 4 = 3; 7 MOD (-4) = -1.
Operatori poređenja
Koriste se u relacionim izrazima za poređenje vrednosti podataka. Primenljivi su na sve prethodno pomenute
tipove podataka. Raspoloživi su sledeći operatori poređenja, tj. relacioni operatori:
= Jednako
/= Različito
< Manje
> Veće
<= Manje ili jednako
>= Veće ili jednako
Operatori pomeranja:
Koriste se za pomeranje/rotiranje podataka. Sintaksa je sledeća: <levi operand> <operator pomeranja> <desni
operand>. Levi operand (onaj koji se pomera) mora biti 1D vektor (BIT_VECTOR, STD_LOGIC_VECTOR,
...), a desni (iznos pomeranja) INTEGER. Ako je iznos pomeranja negativan broj, izvršava se ista operacija
pomeranja, ali u suprotnom smeru. Raspoložive su sledeće operacije pomeranja:
sll logičko pomeranje ulevo (pozicije sa desne strane popunjavaju se ΄0΄)
srl logičko pomeranje udesno (pozicije sa leve strane popunjavaju se ΄0΄)
sla aritmetičko pomeranje ulevo (pozicije sa desne strane popunjavaju se krajnjim desnim bitom)
sra aritmetičko pomeranje udesno (pozicije sa leve strane popunjavaju se krajnjim levim bitom)
rol rotacija na levo
ror rotacija na desno
Prva četiri operatora obavljaju pomeranje, a poslednja dva rotiranje vektora. Kod pomeranja, gubi se onoliko
elementi za koliko pozicija se vektor pomera. Kod rotiranja, elementi se ne gube, jer se oni koji bi ˝ispali˝ iz
vektora vraćaju na drugi kraj vektora. Postoje dve varijante pomeranja: logičko i aritmetičko. Razlika je u
načinu na koji se tretiraju pozicije koje bi nakon pomeranja ostale prazne. Kod logičkog pomeranja, takve
pozicije se popunjavaju krajnjom levom vrednošću odgovarajućeg tipa (npr. za tip BIT_VECTOR to je ´0´, a za
tip STD_LOGIC_VECTOR ´X´, videti definiciju ovih tipova u sekciji 2.2.2). Aritmetičko pomeranja ulevo (sla)
ispražnjenje pozicije popunjava vrednošću krajnjeg desnog, a aritmetičko pomeranja udesno (sra) vrednošću
krajnjeg levog elementa vektora koji se pomera. Napomenimo da je VHDL u kôdu namenjenom sintezi
operatore pomeranja dozvoljeno koristiti samo nad operandima tipa BIT_VECTOR.
Primeri: Ako je BIT_VECTOR x = ˝01001˝, tada važi:
y <= x sll 2; -- y <= ˝00100˝, logičko pomeranje na levo za dve pozicije
y <= x sla 2; -- y <= ˝00111˝, aritmetičko pomeranje na levo za 2 pozicije
y <= x srl 3; -- y <= ˝00001˝, logičko pomeranje na desno za 3 pozicije
y <= x sra 3; -- y <= ˝00001˝, aritmetičko pomeranje na desno za 3 pozicije
y <= x rol 2; -- y <= ˝00101˝, rotacija na levo za 2 pozicije
y <= x ror 2; -- y <= ˝01010˝, rotacija na desno za 2 pozicije
y <= x srl -2; -- isto što i srl 2

33
Operatori konkatenacije:
Koriste se za grupisanje vrednosti. Podržani su isti tipovi podatak kao kod logičkih operacija. Postoje dva
operatora konkatenacije (nadovezivanja): & i (, , ,). Na primer:
z <= x & “10000000”; -- ako je x = ΄1΄, tada z <= ˝11000000˝
z <= (΄1΄,΄1΄,΄0΄,΄0΄,΄0΄,΄0΄,΄0΄,΄0΄); -- isto što i z <= ˝11000000˝

Pr. 2-15 Grupisanje signala u magistralu

SIGNAL dbus: STD_LOGIC_VECTOR(0 TO 7);
SIGNAL ctrl: STD_LOGIC_VECTOR(1 DOWNTO 0);
SIGNAL en, rw: STD_LOGIC;
SIGNAL count: STD_LOGIC_VECTOR(0 TO 3);
-- namera je signale ctrl, count, en i rw objediniti u jedinstveni vektor dbus:
-- dbus(0 TO 1) <= ctrl;
-- dbus(2) <= en;
-- dbus(3) <= rw;
-- dbus(4 TO 7) <= count;
-- isti rezultat se dobija korišćenjem konkatenacije:
dbus <= ctrl & en & rw & count;

Pr. 2-16 Pomeranje pomoću konkatenacije

SIGNAL a, b: STD_LOGIC_VECTOR(0 TO 7);
. . .
a <= b(5 DOWNTO 0) & “00”;
Naizgled efekat je isto kao a <= b sll 2. To bi i bio slučaj da se radi o operandima tipa BIT. Međutim, za
operande tipa STD_LOGIC_VECTOR efekat operacije a <= b sll 2 je sledeći:
a <= b(5 DOWNTO 0) & “XX”;
Vrednost ´X´ (nepoznata vrednosti) se ne može sintetizovati. To je i razlog zašto se operator sll (kao i ostali
operatori pomeranja) ne može koristiti u sintezi tipa STD_LOGIC_VECTOR. Zbog toga se za pomeranje
vektora ovog tipa koristi konkatenacija.

2.3.2 Atributi
Atributi su dodatne informacije pridružene tipovima podataka, signalima i drugim objektima deklarisanim u
VHDL kôdu. Postoje brojni predefinisani atributi, kao i mogućnost da projektant definiše svoje, korisničke
atribute. Za referenciranje atributa koristi se apostrof (˝΄˝). Na primer, notacija x΄attr se odnosi na atribut attr
tipa ili objekta x. Razmotrićemo dve grupe atribute:
- atributi vektora: sadrže informacije (vrednosti) koje se odnose na vektor
- atributi signala: služe za nadgledanje signala
Atributi vektora:
Predefinisani atributi vektora, dozvoljeni u sintezi, su:
d΄LOW vraća najmanji indeks vektora d
d΄HIGH vraća naveći indeks vektora d
d΄LEFT vraća krajnji levi indeks vektora d
d΄RIGHT vraća krajnji desni indeks vektora d
d΄LENGTH vraća veličinu (dužinu) vektora d
d΄RANGE vraća opseg vektora d
Primer: Za signal:
SIGNAL d : STD_LOGIC_VECTOR(7 DOWNTO 0);
važi:
d΄LOW=0 d΄LENGTH=8
d΄HIGH=7 d΄RANGE=(7 downto 0)
d΄LEFT=7 d΄REVERSE_RANGE=(0 to 7)
d΄RIGHT=0

34
Primer: Razmotrimo signal:
SIGNAL d : STD_LOGIC_VECTOR(0 TO 7);
Sledeće četiri LOOP naredbe su ekvivalentne i mogu se sintetizovati (brojač i uzima redom sve vrednosti
definisane pridruženim opsegom):
FOR i IN RANGE (0 TO 7) LOOP . . .
FOR i IN x΄RANGE LOOP . . .
FOR i IN RANGE (x΄LOW TO x΄HIGH) LOOP . . .
FOR i IN RANGE (0 TO x΄LENGTH-1) LOOP . . .
Za signale nabrojivog tipa raspoloživi su sledeći atributi:
d΄VAL(pos) vraća vrednost sa navedene pozicije
d΄POS(vrednost) vraća poziciju navedene vrednosti
d΄LEFTOF(vrednost) vraća vrednost sa pozicije levo od navedene vrednosti
d΄VAL(vrsta, kolona) vraća vrednost sa navedene pozicije
Primer: za korisnički definisan nabrojivi tip:
TYPE boja IS (crvena, zelena, plava, bela);
važi:
boja΄VAL(1) = zelena boja΄POS(zelena) = 1 boja΄LEFTOF(plava) = zelena

Atributi signala:
Neka je s signal. Tada važi:
s΄EVENT vraća TRUE ako se na signalu desio događaj
s΄STABLE vraća TRUE ako se na signalu nije desio događaj
s΄ACTIVE vraća TRUE ako je s = ΄1΄
s΄QUIET<vreme> vraća TRUE ako se u navedenom vremenu na signalu nije desio događaj
s΄LAST_EVENT vraća vreme proteklo od poslednjeg događaja na signalu s
s΄LAST_ACTIVE vraća vreme proteklo od kada je signal poslednji put imao vrednost s = ΄1΄
s΄LAST_VALUE vraća vrednost signala s neposredno pre poslednjeg dogadjaja
Pojam ˝događaj na signalu˝ odnosi se na promenu vrednosti signala. Većina navedenih atributa koristi se samo u
simulaciji. Za sintezu, dozvoljena su samo prva dva (΄EVENT i ΄STABLE). Pri tome, najčešće se koristi atribut
΄EVENT.
Primer: Sledeće četiri naredbe su ekvivalentne i mogu se sintetizovati. Svaka od naredbi vraća TRUE ako se na
signalu clk desio događaj (tj. ako je došlo do promene vrednosti signal clk) i nova vrednost signala je clk=΄1΄
(drugim rečima ako se javila rastuća ivica signala clk).
IF (clk΄EVENT AND clk=΄1΄) ... -- atribut EVENT u IF naredbi
IF (NOT clk΄STABLE AND clk=΄1΄) ... -- atribut STABLE u IF naredbi
WAIT UNTIL (clk΄EVENT AND clk=΄1΄); -- atribut EVENT u WAIT naredbi
IF RISING_EDGE(clk) ... -- poziv funkcije

2.3.3 Korisnički-definisani atributi

Pored predefinisanih atributa, projektant ima mogućnost da uvede svoje sopstvene, tzv. korisnički-definisane
atribute. Pre korišćenja u kôdu, korisnički-definisani atribut mora biti deklarisani i specificirani.
Deklaracija atributa:
ATTRIBUTE ime_atributa : tip_atributa;
tip_atributa je bilo koji tip podataka (BIT, INTEGER, STD_LOGIC_VECTOR, i td.)
Specifikacija atributa:
ATTRIBUTE ime_atributa OF ime_objekta: klasa IS vrednost;
klasa može biti: TYPE, SIGNAL, FUNCTION i td.
vrednost je ΄0΄, 27, ˝00 11 10 01˝, i sl.
Uočimo da deklaracija uvodi novi atribut, dok specifikacija pridružuje atribut konkretnom objektu (signalu, tipu,
funkciji, …) i dodeljuje vrednost atributu.

35
Primer:
ATTRIBUTE broj_ulaza : INTEGER; -- deklaracija
ATTRIBUTE broj_ulaza OF nand3: SIGNAL IS 3; -- specifikacija
. . .
ulazi <= nand3΄broj_ulaza; -- poziv atributa, vraća 3
Primer: Nabrojivo kodiranje.
U mnogim alatima za sintezu dostupan je korisnički-definisani atribut enum_encoding, koji omogućava
promenu načina kodiranja vrednosti nabrojivih tipova podataka. Podrazumevano, nabrojivi tipovi podataka se
kodiraju sekvencijalno. Na primer, vrednosti tipa boja:
TYPE bolja IS (crvena, zelena, plava, bela)
kodirane su shodno poziciji u listi nabrajanja: crvena=˝00˝, zelena=˝01˝, plava=˝10˝ i bela=˝11˝. Atribut
enum_encoding omogućava da se podrazumevano kodiranje promeni. Na primer,
ATTRIBUTE enum_encoding OF boja: TYPE IS ˝11 00 10 01˝;
menja kodove u: crvena=˝11˝, zelena=˝00˝, plava=˝10˝ i bela=˝01˝.
Korisnički-definisani atributi mogu biti deklarisani bilo gde u kôdu, osim u telu paketa.

2.3.4 Preklapanje operatora

Preklapanje operatora (operator overloading) je tehnika koja omogućava promenu značenja predefinisanih
operatora, kao što su ˝+˝, ˝-˝, ˝*˝, and, or i td.. Potreba za ovakvom, naizgled neprirodnom, manipulacijom
proističe iz činjenice da su predefinisani operatori definisani samo za određene predefinisane tipove podataka.
Na primer, operator aritmetičkog sabiranja, ˝+˝, može se primeniti samo nad podacima određenog tipa, kao što
su INTEGER, SINGED ili UNSIGNED, ali ne i nad podacima tipa BIT_VECTOR, kao ni nad podacima bilo
kog korisničkog tipa. Preklapanje operatora nam omogućava da definišemo nove operacije korišćenjem
postojećih, predefinisanih simbola. Tako, na primer, možemo definisati novu vrstu sabiranja, koje će biti
primenljivo na podatke tipa BIT_VECTOR. Preklapanje operatora postiže se pisanjem jedne posebne funkcije
(FUNCTION) koja treba da definiše ponašanje nove operacije.
Primer: Sledeća funkcija definiše operaciju sabiranja za slučaj kada je levi operand tipa INTEGER, a desni tipa
BIT. (Više detalja o pisanju i korišćenju funkcija može se naći u poglavlju 2.10.).
-----------------------------------------
FUNCTION ˝+˝ (a: INTEGER, b: BIT) RETURN INTEGER IS
BEGIN
IF(b=΄1΄) THEN RETURN a+1;
ELSE RETURN a;
END IF
END ˝+˝;
-----------------------------------------
Uočimo da je ime funkcije simbol operatora koji se preklapa, a da su parametri funkcije njegovi operandi.
Takođe, uočimo da operandi preklopljenog operatora ne moraju biti istog tipa.
-----------------------------------------
SIGAL inp1, outp: INTEGER RANGE 0 TO 15;
SIGNAL inp2: BIT;
. . .
outp <= 3 + (inp1 + inp2);
. . .
-----------------------------------------
U izrazu ˝3 + (inp1 + inp2)˝, prvo ˝+˝ predstavlja predefinisani operator sabiranja (sabira dva INTEGER-
a), dok je drugo ˝+˝ preklopljeni, korisnički operator sabiranja (sabira INTEGER i BIT). Do konflikta između
dva značenja simbola ΄+΄ ne dolazi, jer se jedna od njegove dve funkcije određuje na osnovu tipova operanda
nad kojima se primenjuje.

2.3.5 GENERIC
GENERIC je mehanizam VHDL jezika koji omogućava definisanje generalizovanih, ili generičkih parametara,
tj. statičkih parametara koji se lako mogu modifikovati ili prilagoditi različitim primenama.

36
GENERIC naredba se deklariše unutar entiteta, a navedeni parametri vidljivi su u celom projektu. Sintaksa
GENERIC naredbe je sledeća:
GENERIC (ime_parametra : tip_parametra := vrednost_parametra);
Primer: GENERIC naredba, iz VHDL kôda koji sledi, definiše parametara n tipa INTEGER sa inicijalnom
vrednošću 8. Generički parametar vidljiv je u celom projektu, tj. u entitetu i pratećim arhitekturama. Svuda u
kôdu gde se javlja parametra n, podrazumeva se da je njegova vrednost 8. Generički parametri čine kôd
fleksibilnijim i lakšim za ponovno korišćenje. Na primer, ako se javi potreba da se n promeni, to se čini samo na
jednom mestu u kôdu, u GENERIC naredbi.
ENTITY nas_entitet IS
GENERIC(n : INTEGER := 8);
PORT( . . . );
END my_entity;
ARCHITECTURE nasa_arhitetkura OF nas_entitet IS
. . .
END nasa_arhitektura;
Entite može sadržati definicije više od jednog generičkog parametra. Na primer:
GENERIC(n: INTEGER := 8; vektor: BIT_VECTOR := ˝00011100˝);

2.3.6 Primeri
U cilju potpunije ilustracije primene operatora, atributa i GENERIC konstrukcije, u ovoj sekciji biće izloženo
više kompletnih primera VHDL kôda. U dosadašnjem toku izlaganja bavili smo se isključivo osnovama VHDL
jezika, ali ne i tehnikama kôdiranja, čemu su posvećena naredna dva poglavlja. Iz tog razloga, čitaocu koji po
prvi put čita ovaj deo teksta, pojedine konstrukcije u narednim primerima mogu biti nerazumljive. Cilj primera
je ilustracija primene operatora, atributa i GENERIC naredbe. Čitaocu se preporučuje da se ponovo vrati na ove
primere nakon što prouči naredna dva poglavlja.
Pr. 2-17: Generički dekoder
Na Sl. 2-10 prikazan je blok dijagram generičkog dekodera m-u-n. Kolo ima dva ulazna porta: m-bitni ulaz za
selekciju, sel, i jednobitni ulaz za dozvolu rada, ena, i jedan izlazni port: n-to bitni izlaz x. Pretpostavićemo da je
n stepen dvojke, tako da važi m=log2n. Ako je ena=΄0΄, tada ni jedan izlaz dekodera nije aktivan; ako je
ena=΄1΄, aktivan je samo izlazni bit x(i), gde je i ceo broj jednak binarnoj vrednosti prisutnoj na ulazu sel.
Tabela istinitosti dekodera 2-u-4 data je na Sl. 2-10(b).
ena sel x
0 00 0000
1 00 0001
01 0010
10 0100
11 1000
(a) (b)
Sl. 2-10 Generički dekoder: (a) blok dijagram; (b) tabela istinitosti.
Arhitektura iz VHDL kôda koji sledi u potpunosti je generička, jer ne zavisi od konkretnih vrednosti parametara
n i m. To je omogućeno time što se u kôdu arhitekture koriste atributi signala (x'HIGH, sel'RANGE), a ne
konkretne vrednosti za granice opsega ulaznih portova. Ako želimo da kreiramo opis dekodera za neke druge
vrednosti parametara n i m, dovoljno je u entitetu promeniti opsege signala sel i x (u linijama 7 i 8, respektivno).

1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY dekoder IS
6 PORT ( ena : IN STD_LOGIC;
7 sel : IN STD_LOGIC_VECTOR (2 DOWNTO 0);
8 x : OUT STD_LOGIC_VECTOR (7 DOWNTO 0));

37
9 END dekoder;
10 ---------------------------------------------
11 ARCHITECTURE generic_dekoder OF dekoder IS
12 BEGIN
13 PROCESS (ena, sel)
14 VARIABLE temp1: STD_LOGIC_VECTOR (x'HIGH DOWNTO 0);
15 VARIABLE temp2 : INTEGER RANGE 0 TO x'HIGH;
16 BEGIN
17 temp1 := (OTHERS => '0' );
18 temp2 := 0;
19 IF (ena='1') THEN
20 FOR i IN sel'RANGE LOOP --opseg signala sel je (2 downto 0)
21 IF (sel(i)='1') THEN --binarno-decimalna konverzija
22 temp2 := 2*temp2+1;
23 ELSE
24 temp2 := 2*temp2;
25 END IF;
26 END LOOP;
27 temp1 (temp2):='1';
28 END IF;
29 x <= temp1;
30 END PROCESS;
31 END generic_dekoder;
32 ---------------------------------------------
U kôdu arhitekture postoji samo jedna naredba, PROCESS u okviru koje se sekvencijalnim algoritmom opisuje
rad dekodera. U suštini, u procesu se binarna vrednost prisutna na ulazu za selekciju, sel, najpre konvertuje u
celobroju vrednost (linije 18-26), koja se potom koristi kao indeks bita u izlaznom vektoru koji će biti postavljen
na 1 (linija 27). Takođe uočimo da se za izračunavanja u procesu koriste dve pomoćne varijable, temp1 i temp2.
U datom kôdu korišćeni su sledeći operatori: ˝+˝ (linija 22), ˝*˝ (linije 22 i 24), ˝:=˝ (linije 17, 18, 22, 24 i 27),
˝<=˝ (linija 29) i ˝=>˝ (linija 17) i atributi: HIGH (linije 14, 15) i RANGE (linija 20).
Na Sl. 2-10 prikazani su rezultati simulacije, koji verifikuju funkcionalnost generičkog dekodera. Kao što se
može videti, kada je ena = ΄0΄, svi izlazi su na niskom nivou, tj. x = ˝00000000˝ (decimalno 0). Ako je signal
dozvole aktiviran (ena = ΄1΄), samo jedan izlazni bit, određen vrednošću signala sel, je na visokom nivou: kada
je sel = ˝000˝ (decimalno 0), izlaz je x = ˝00000001˝, kada je sel = ˝001˝ (decimalno 1), izlaz je x = ˝00000010˝
(decimalno 2), kada je sel = ˝011˝ (decimalno 3), izlaz je x = ˝00000100˝ (decimalno 4) i td.

Sl. 2-11 Rezultati simulacije VHDL kôda iz Pr. 2-17.

Sl. 2-12 Generički detektor parnosti.

Pr. 2-18: Generički detektor parnosti

Blok dijagram generičkog detektora parnosti prikazan je na Sl. 2-12. Ovo kolo na svom izlazu generiše output =
΄1΄, uvek kada je broj 1-ca na njegovom ulazu paran. U suprotnom, za neparan broj 1-ca na ulazu važi output =
΄0΄. Entitet priloženog VHDL kôda sadrži GENERIC naredbu koja definiše parametar n kao INTEGER
vrednosti 7. Kôd opisuje detektor parnosti za proizvoljan broj ulaza; dovoljno je promeniti vrednost parametra n
u liniji 3.
1 ---------------------------------------------
2 ENTITY detector_parnosti IS
3 GENERIC (n : INTEGER := 7);
4 PORT ( input: IN BIT_VECTOR (n DOWNTO 0);

38
5 output: OUT BIT);
6 END detector_parnosti;
7 ---------------------------------------------
8 ARCHITECTURE parnost OF detector_parnosti IS
9 BEGIN
10 PROCESS (input)
11 VARIABLE temp: BIT;
12 BEGIN
13 temp := '0';
14 FOR i IN input'RANGE LOOP
15 temp := temp XOR input(i);
16 END LOOP;
17 output <= temp;
18 END PROCESS;
19 END parnost;
20 --------------------------------------------
Jedan od načina kako se može odrediti parnost višebitne vrednosti jeste da se nad svim bitovima primeni
operacija isključivo ILI (XOR). Deo kôda u linijama 13-16 upravo ima tu namenu. Ponovo, za izračunavanja u
procesu se koristi varijabla, temp, čija se konačna vrednost prenosi na izlaz output. Rezultati simulacije
prikazani su na Sl. 2-13. Uočimo da za ulaz input=˝00000000˝ (paran broj jedinica), izlaz ima vrednost ΄0΄. Ulaz
input=˝00000001˝ sadrži neparan broj jedinica i izlaz je ΄1΄, i td.

Sl. 2-13 Rezultati simulacije VHDL kôda iz

Pr. 2-18.

Sl. 2-14 Generički generator parnosti.

Pr. 2-19 Generički generator parnosti
Generator parnosti (Sl. 2-14) dodaje jedan bit ulaznom vektoru. Dodatni bit ima vrednost ΄0΄, ako je broj jedinica
na ulazu paran, odnosno ΄1΄, ako je broj jedinica neparan. Na taj način, rezultujući izlazni vektor uvek sadrži
paran broj jedinica (parna parnost). Ispod je dat odgovarajući VHDL opis. Rezultati simulacije prikazani su na
Sl. 2-15. Kao što se može videti, za input=˝0000000˝ dobija se output=˝00000000˝; za input=˝0000001˝ dobija
se output=˝10000001˝ i td.
1 ----------------------------------------------
2 ENTITY generator_parnosti IS
3 GENERIC (n : INTEGER := 7);
4 PORT ( input: IN BIT_VECTOR (n-1 DOWNTO 0);
5 output: OUT BIT_VECTOR (n DOWNTO 0));
6 END generator_parnosti;
7 ----------------------------------------------
8 ARCHITECTURE parnost OF generator_parnosti IS
9 BEGIN
10 PROCESS (input)
11 VARIABLE temp1: BIT;
12 VARIABLE temp2: BIT_VECTOR (output'RANGE);
13 BEGIN
14 temp1 := '0';
15 FOR i IN input'RANGE LOOP
16 temp1 := temp1 XOR input(i);
17 temp2(i) := input(i);
18 END LOOP;
19 temp2(output'HIGH) := temp1;
20 output <= temp2;
21 END PROCESS;

39
22 END parnost;
23 ----------------------------------------------

Sl. 2-15 Rezultati simulacije VHDL kôda iz Pr. 2-19.

2.3.7 Pregled operatora i atributa

U tabelama T1 i T2 navedeni su operatori i atributi VHDL jezika, respektivno. Konstrukcije koje se ne mogu
koristiti u kodu za sintezu naznačene su simbolom ●.
T 2-1 Operatori.
Tip operacije Operatori Tip podataka
Dodela <=, := , => Svi
Logičke operacije NOT, AND, NAND, OR STD_LOGIC, STD_ULOGIC, STD_LOGIC_VECTOR,
NOR, XOR, XNOR STD_ULOGIC_VECTOR, INTEGER, SIGNED,
UNSIGNED
Aritmetičke +, -, *, /, ** Svi prethodni
operacije (mod, rem, abs)●
Poređenje =, /=, <, >, <=, >= Svi prethodni
Pomeranje sll, slr, sla, sra, rot, ror BIT_VECTOR
Nadovezivanje &, (,,,) Kao logičke, plus SIGNED i UNSIGNED

T 2-2 Atributi.
Primena Atributi Vrednost
Za regularne podatke d΄LOW najmanji indeks vektora
d΄HIGH najveći indeks vektora
d΄LEFT krajnji levi indeks vektora
d΄RIGHT krajnji desni indeks vektora
d΄LENGTH veličinu (dužinu) vektora
d΄RANGE opseg vektora
d΄REVERSE_RANGE opseg vektora u obrnutom redosledu
Za nabrojive podatke d΄VAL(pos) ● vrednost sa navedene pozicije
d΄POS(pos) ● pozicija navedene vrednosti
d΄LEFTOF(vrednost) ● vrednost sa pozicije levo od navedene vrednosti
d΄VAL(vrsta, kolona) ● vrednost sa navedene pozicije
Za signale s΄EVENT TRUE ako se na signalu desio događaj
s΄STABLE TRUE ako se na signalu nije desio događaj
s΄ACTIVE ● TRUE ako je s = ΄1΄

40
2.4 Konkurentni kôd
VHDL kôd može biti konkurentan (paralelan) ili sekvencijalan. Dobro razumevanje osobina i razlika između
ova dva tipa kôda predstavlja osnovu za razumevanje osnovnih koncepta VHDL jezika. U ovom poglavlju
bavićemo se konkurentnim kôdom, dok će sekvencijalnom biti posvećeno poglavlje 6.
Konkurentne naredbe VHDL-a su WHEN i GENERATE. Naredbe dodele koje sadrže isključivo operatore
(AND, NOT, +, *, sll i slične) takođe mogu biti korišćenje za pisanje konkurentnog kôda.

2.4.1 Konkurentni i sekvencijalni kôd

Većina programskih jezika su sekvencijalni, što znači da se programske naredbe izvršavaju jedna za drugom,
tako da sledeća naredba počinje tek kad se prethodna završi. Sekvencijalni programski jezici su pogodni za opis
algoritama koji definišu neko izračunavanje, funkciju ili proceduru. Međutim, sekvencijalni način opisa nije
pogodan za verno modeliranje digitalnih sistema. Tipično, digitalni sistem se sastoji od više podsistema, koji
rade nezavisno jedan od drugog, tj. istovremeno ili paralelno. Iako se funkcija svakog podsistema može opisati
sekvencijalnim algoritmom, izražavanje paralelizma na sistemskom nivou zahteva posebnu podršku u jeziku za
opis hardvera, kakav je VHDL. Takva podrška se nalazi u konkurentnim naredbama, koje se slično
podsistemima ili kolima, izvršavaju (rade) istovremeno. VHDL poseduje podršku kako za sekvencijalno, tako i
za konkurentno programiranje. U suštini, VHDL je konkurentan jezik, a da bi se nametnulo sekvencijalno
izvršenje koriste se posebne konstrukcije: PROCESS, FUNCTION i PROCEDURE. Iako se naredbe u okviru
ovih blokova izvršavaju sekvencijalno, svaki blok, kao celina, izvršava se konkurentno u odnosu na druge
blokove i eksterne naredbe.

2.4.2 Konkurentna naredba dodele

Konkurentna naredba dodele oblika je signal <= izraz. Izraz sadrži signale i konstante povezane operatorima,
kao što su: AND, NOT, +, *, sll i slični. Vrednost izraza se izračunava i dodeljuje signalu sa leve strane znaka
<= uvek kada se promeni vrednost barem jednog signala iz izraza. Ova naredba predstavljaju osnovni način za
kreiranje konkurentnog kôda. Na primer, funkcija bilo kog kombinacionog kolo može se predstaviti u vidu
logičkog izraza. Međutim, često, opis na ovako niskom nivou nije pogodan za modeliranje digitalnih kola
složenije funkcije. Sledeći primer ilustruje primenu konkurentne naredbe dodele.
s0

s1

a
b
b y
MUX y
c
c
d

s1 s0 d

Sl. 2-16 Multiplekser 4-u-1: (a) grafički simbol; (b) kombinaciona mreža.
Pr. 2-20 Multiplekser (varijanta 1)
Na Sl. 2-16(a) prikazan je grafički simbol multipleksera 4-u-1. Vrednost selekcionih ulaza (s1, s0) bira jedan od
ulaza, a, b, c ili d čija se vrednost prenosi na izlaz y. Realizacija multipleksera 4-u-1 pomoću logičkih kola
prikazana je na Sl. 2-16(b). Funkcija multipleksera se može opisati u VHDL-u u vidu logičkog izraza na sledeći
način:
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY mux IS
6 PORT ( a,b,c,d,s0,s1 : IN STD_LOGIC;
7 y : OUT STD_LOGIC);
8 END mux;
9 ---------------------------------------------
10 ARCHITECTURE logicka_realizacija OF mux IS
11 BEGIN
12 y <= (a AND NOT s1 AND NOT s0) OR

41
13 (b AND NOT s1 AND s0) OR
14 (c AND s1 AND NOT s0) OR
15 (d AND s1 AND s0);
16 END logicka_realizacija;
---------------------------------------------
Pored konkurentne naredbe dodele, signal <= izraz , često je u upotrebi i njena varijanta sa odloženim dodelom:
signal <= izraz after kašnjenje. Na primer:
a <= b AND c after 10 ns;
Kao i bez ubačenog kašnjenja, naredba se izvršava u trenutku kada se promeni neki od signala b ili c. Međutim,
vrednost izraza b AND c, koja se tom prilikom izračuna, ne dodeljuje se signalu a istog trenutka, već posle
(after) kašnjenja od 10 ns. Ovaj oblik naredbe dodele koristi se u simulaciji za modeliranje propagacionog
kašnjenja ili kreiranje pobudnih signala željenog talasnog oblika. Prethodni primer modelira I kolo sa
propagacionim kašnjenje od ulaza do izlaza od 10 ns. U kôdu za sintezu, nije dozvoljeno koristiti kašnjenja.

2.4.3 WHEN
Naredba WHEN, u suštini, predstavlja uopštenje konkurentne naredbe dodele. Za razliku od standardne naredba
dodele, kod koje se sa desne strane znaka <= može naći sam jedan izraz, naredba WHEN omogućava da se sa
desne strane znaka <= nađe više od jednog izraza. Svakom takvom izrazu pridružuje se uslov, a jedinstveni
signal sa leve strane znaka <= dobija vrednost onog izraza čiji uslov je ispunjen, tj. tačan. Postoje dva oblika
uslovne naredbe dodele: WHEN/ELSE (ili uslovna naredba dodele) i WITH/SELECT/WHEN (ili SELECT
naredba). Njihova sintaksa je sledeća:
WHEN/ELSE naredba:
signal <= izraz WHEN uslov ELSE
izraz WHEN uslov ELSE
...
izraz;
WITH/SELECT/WHEN naredba:
WITH selekcioni_izraz SELECT
signal <= izraz WHEN vrednost,
izraz WHEN vrednost,
...
izraz WHEN vrednost;
U prvoj varijanti (WHEN/ELSE), naredba se izvršava tako što se redom ispituju uslovi, sve dok se ne dođe do
WHEN grane sa tačnim uslovom. Onda se izračunava vrednost odgovarajućeg izraza i dodeljuje signalu sa leve
strane znaka <=. Ako ni jedan uslov nije tačan, bira se izraz iz poslednje grane. U drugoj varijanti
(WITH/SELECT/WHEN), najpre se izračuna vrednost izraza iz zaglavlja naredbe (selekcioni_izraz); zatim se
ova vrednost poredi sa vrednostima iz svih WHEN grana (istovremeno); i konačno, signalu se dodeljuje
vrednost izraz iz grane u kojoj se javilo slaganje. Ova varijanta zahteva da svaki mogući rezultat selekcionog
izraza bude pokriven tačno jednom WHEN vrednošću. Takođe, dozvoljeno je korišćenje ključne reči OTHERS
da bi se označio izraz koji će biti izvršen ako se rezultat selekcionog izraza ne poklapa ni sa jednom eksplicitno
navedenom vrednošću:
WITH selekcioni_izraz SELECT
signal <= izraz WHEN vrednost,
izraz WHEN vrednost,
...
izraz WHEN OTHERS;
˝WHEN vrednost˝ iz naredbe WITH/SELECT/WHEN može biti navedena na tri načina:
WHEN vrednost -- jedinstvena vrednost
WHEN vrednost_1 to vrednost_2 -- opseg vrednosti (samo kod
-- nabrojivih tipova)
WHEN vrednost_1 | vrednost_2 | vrednost_3 ... -- vrednost_1 ili vrednost_2
-- ili vrednost_3 ili ...
Primer:
--------- WHEN/ELSE ---------------------------
outp <= “000” WHEN (inp=΄0΄ OR reset=΄1΄) ELSE
“001” WHEN ctl=΄1΄ ELSE
“010”;

42
--------- WITH/SELECT/WHEN --------------------
WITH contol SELECT
outp <= “000” WHEN “00”
“111” WHEN “01” | “10”
“010” WHEN OTHERS;

Pr. 2-21 Multiplekser (varijanta 2)

U ovom primeru biće predstavljene dve realizacija multipleksera iz Pr. 2-20. Prvo rešenje koristi WHEN/ELSE,
a drugo WITH/SELECT/WHEN oblik WHEN naredbe.
1 ---- Resenje 1: koristi WHEN/ELSE naredbu -----
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -----------------------------------------------
5 ENTITY mux IS
6 PORT ( a,b,c,d : IN STD_LOGIC;
7 sel: IN STD_LOGIC_VECTOR(1 DOWNTO 0);
8 y : OUT STD_LOGIC);
9 END mux;
10 ----------------------------------------------
11 ARCHITECTURE mux1 OF mux IS
12 BEGIN
13 y <= a WHEN sel = "00" ELSE
14 b WHEN sel = "01" ELSE
15 c WHEN sel = "10" ELSE
16 d;
17 END mux1;
18 ----------------------------------------------
1 -- Resenje 2: koristi WITH/SELECT/WHEN naredbu
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY mux IS
6 PORT ( a,b,c,d : IN STD_LOGIC;
7 sel: IN STD_LOGIC_VECTOR(1 DOWNTO 0);
8 y : OUT STD_LOGIC);
9 END mux;
10 ---------------------------------------------
11 ARCHITECTURE mux2 OF mux IS
12 BEGIN
13 WITH sel SELECT
14 y <= a WHEN "00", -- "," umesto ";"
15 b WHEN "01",
16 c WHEN "10",
17 d WHEN OTHERS; -- ne moze d WHEN "11"
18 END mux2;
19 ---------------------------------------------
U prethodnom VHDL kôdu, tip selekcionog signala sel je STD_LOGIC_VECTOR. Podsetimo se da tip
STD_LOGIC definiše 8-nivovski logički sistem, kod koga osim logičke 0 i 1, postoji još 6 različitih nivoa
signala. To znači, da kombinacije ˝00˝, ˝01˝, ˝10˝ i ˝11˝ ne predstavljaju sve moguće vektore dužine dva ovog
tipa. Na primer, ˝0-˝, ˝LH˝, i td, su takođe validne vrednosti signali tipa STD_LOGIC_VECTOR. S obzirom da
u naredbi WITH/SELECT/WHEN sve opcije moraju biti navedene, rešenje kod koga bi grana d WHEN
OTHERS bila zamenjena granom d WHEN ˝11˝ ne bi bilo ispravno. Međutim, ako se signal sel deklariše kao
INTEGER opsega 0 do 3, OTHERS grana se može zameniti konkretnom, četvrtom vrednošću. U nastavku su
date varijante prethodnog VHDL kôda za slučaj kada je sel INTEGER.
1 ------------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ------------------------------------------------
5 ENTITY mux IS
6 PORT ( a,b,c,d : IN STD_LOGIC;
7 sel: IN INTEGER RANGE 0 TO 3;
8 y : OUT STD_LOGIC);
9 END mux;
10 ---- Resenje 1: koristi WHEN/ELSE naredbu -----

43
11 ARCHITECTURE mux1 OF mux IS
12 BEGIN
13 y <= a WHEN sel = 0 ELSE
14 b WHEN sel = 1 ELSE
15 c WHEN sel = 2 ELSE
16 d;
17 END mux1;
18 -- Resenje 2: koristi WITH/SELECT/WHEN naredbu -----
19 ARCHITECTURE mux2 OF mux IS
20 BEGIN
21 WITH sel SELECT
22 y <= a WHEN 0,
23 b WHEN 1,
24 c WHEN 2,
25 d WHEN 3; -- 3 ili OTHERS ima isti efekat
26 END mux2;
27 ----------------------------------------------------
Napomena: Prethodni kôd sadrži dve arhitekture za isti entitet. Međutim, moguće je sintetizovati ili simulirati
samo jedno rešenje. Da bi kôd bio korektan potrebno je na neki način izabrati jednu od raspoloživih alternativa.
Jedan način je da se sve osim jedne arhitekture komentarišu. Drugi načni koristi naredbu CONFIGURATION
koja saopštava simulatoru ili alatu za sintezu koju od postojećih arhitektura da izabere.
e d1 d0 y3 y2 y1 y0
d0 y0
d1 y1 1 0 0 0 0 0 1
Dekoder 1 0 1 0 0 1 0
2-u-4 y2
1 1 0 0 1 0 0
e y3 1 1 1 1 0 0 0
0 X X 0 0 0 0
(a) (b)
Sl. 2-17 Dekoder 2-u-4: (a) grafički simbol; (b) tabela istinitosti.
Pr. 2-22 Dekoder 2-u-4
Na Sl. 2-17 su prikazani grafički simbol i tabela istinitosti binarnog dekodera 2-u-4. Kolo ima 2 ulaza za binarno
kodirani podatak, d0 i d1, i 4 izlaza, yi, i=0, …, 3, pri čemu svakom izlazu odgovara jedna kombinacija binarnih
vrednosti na ulazu. Dodatni ulaz za dozvolu rada, e, upravlja izlazom dekodera na sledeći način: ako je e=0,
tada ni jedan izlaz dekodera nije aktivan; ako je e=1, aktivan je samo izlaz yi, gde je i ceo broj jednak binarnoj
vrednosti ulaza (d1, d0).
U tabeli istinitosti dekodera 2-u-4 sa Sl. 2-17, ulazi su navedeni u redosledu: e, d1, d0. Da bi se u VHDL kodu
predstavila ova tri signala, deklarisan je trobitni signal ed. U naredbi ed<=e&d, uz pomoć operatora
konkatenacije, signali e i d su spojeni u jedinstveni signal ed, tako da važi: ed(2)=e, ed(1)= d1, ed(0)=d0. Signal
ed se koristi kao kriterijum izbora u WITH/SELECT/WHEN naredbi. Za prve četiri WHEN grane važi da je
e=1, tako da izlazi dekodera imaju iste vrednosti kao prve četiri vrste u tabeli istinitosti sa Sl. 2-17. Poslednja
WHEN grana sadrži ključnu reč OTHERS, što odgovara slučaju kada je e=0, i postavlja izlaz dekodera na
y=˝0000˝.
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY dek2u4 IS
6 PORT (d : IN STD_LOGIC_VECTOR(1 DOWNTO 0);
7 e : IN STD_LOGIC;
8 y : OUT STD_LOGIC_VECTOR(0 TO 3));
9 END dek2u4;
10---------------------------------------------
11 ARCHITECTURE dekoder OF dek2u4 IS
12 SIGNAL ed : STD_LOGIC_VECTOR(2 DOWNTO 0);
13 BEGIN
14 ed <= e & d;
15 WITH ed SELECT
16 y <= "1000" WHEN "100",
17 "0100" WHEN "101",
18 "0010" WHEN "110",
19 "0001" WHEN "111",
20 "0000" WHEN OTHERS;
21 END dekoder;

44
 Sl. 2-18 8-bitni trostatički bafer.
Pr. 2-23 Trostatički bafer
Trostatički bafer je digitalno kolo koje prenosi signal sa ulaza na izlaz uz mogućnost postavljanja izlaza u stanje
visoke impedanse. Na Sl. 2-18 je prikazan 8-bitni trostatički bafer, kod koga važi output=input, za ena=´0´; u
suprotnom, za ena=´1´, važi output=˝ZZZZZZZZ˝ (visoka impedansa). Sledi VHDL opis 8-bitnog trostatičkog
bafera.
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY tri_state IS
6 PORT (ena : IN STD_LOGIC;
7 input : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
8 output : OUT STD_LOGIC_VECTOR(7 DOWNTO 0));
9 END tri_state;
10 ---------------------------------------------
11 ARCHITECTURE tri_state OF tri_state IS
12 BEGIN
13 output <= input WHEN (ena = '0') ELSE
14 (OTHERS => 'Z');
15 END tri_state;
16 ---------------------------------------------

Sl. 2-19 Rezultati simulacije VHDL kôda iz Pr. 2-23

Rezultati simulacije kola sintetizovanog na osnovu prethodnog VHDL kôda prikazani su na Sl. 2-19. Kao što se i
očekuje, izlaz output ostaje u stanju visoke impedanse za sve vreme dok je ena=1, a ima istu vrednost kao ulaz
kada je ena=0.
Pr. 2-24 Multiplekser (Varijanta 3)
Sl. 2-20 prikazuje kako se trostatički baferi se mogu iskoristiti za realizaciju multipleksera 4-u-1. Četiri
trostatička bafera su spojeni u jednu tačku koja je ujedno i izlaz multipleksera, y. U zavisnosti od vrednosti
selekcionog signala sel dekoder aktivira tačno jedan trostatički bafer koji na zajednički izlaz prenosi vrednost sa
svog ulaza. Izlazi neaktivnih trostatičkih bafera su u stanju visoke impedanse, i zato ne utiču na logički nivo
izlaza y. Odgovarajući VHDL kôd sadrži četiri WHEN / ELSE naredbe, od kojih svaka realizuje jedan
trostatički bafer. Rezultati simulacije, koji su prikazani na Sl. 2-21, potvrđuju da kolo funkcioniše kao
multiplekser.
sel(1:0)

Dekoder
3 2 1 0

11 10 01 00

Sl. 2-20 Realizacija multipleksera pomoću trostatičkih bafera.

45
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY mux IS
6 PORT ( a,b,c,d : IN STD_LOGIC;
7 sel: IN STD_LOGIC_VECTOR(1 DOWNTO 0);
8 y : OUT STD_LOGIC);
9 END mux;
10---------------------------------------------
11 ARCHITECTURE mux3 OF mux IS
12 BEGIN
13 y <= a WHEN sel = "00" ELSE 'Z';
14 y <= b WHEN sel = "01" ELSE 'Z';
15 y <= c WHEN sel = "10" ELSE 'Z';
16 y <= d WHEN sel = "11" ELSE 'Z';
17 END mux3;
---------------------------------------------

Sl. 2-21 Rezultati simulacije VHDL kôda iz Pr. 2-24

Pr. 2-25 Koder
Na Sl. 2-22 je prikazan blok dijagram kodera n-u-m. Pretpostavićemo da je n stepen dvojke, tako da važi
m=log2n. Sa ograničenjem da u bilo kom trenutku samo jedan od n ulaza može imati vrednost 1, na izlazu
binarnog kodera generiše se m-bitni binarni broj koji ukazuje na indeks ulaza čija je vrednost jednaka 1. U
nastavku su prezentovana dva VHDL kôda, prvo koristi WHEN/ELSE, a drugo WITH/SELECT/WHEN
naredbu.

Sl. 2-22 Koder n-u-m.

1 ---- Resenje 1: koristi WHEN/ELSE naredbu ---
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY encoder IS
6 PORT (x : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
7 y : OUT STD_LOGIC_VECTOR(2 DOWNTO 0));
8 END encoder;
9 ---------------------------------------------
10 ARCHITECTURE encoder1 OF encoder IS
11 BEGIN
12 y <= "000" WHEN x="00000001" ELSE
13 "001" WHEN x="00000010" ELSE
14 "010" WHEN x="00000100" ELSE
15 "011" WHEN x="00001000" ELSE
16 "100" WHEN x="00010000" ELSE
17 "101" WHEN x="00100000" ELSE
18 "110" WHEN x="01000000" ELSE
19 "111" WHEN x="10000000" ELSE
20 "ZZZ";
21 END encoder1;

46
1 -- Resenje 2: koristi WITH/SELECT/WHEN naredbu
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY encoder IS
6 PORT ( x : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
7 y : OUT STD_LOGIC_VECTOR(2 DOWNTO 0));
8 END encoder;
9 ---------------------------------------------
10 ARCHITECTURE encoder2 OF encoder IS
11 BEGIN
12 WITH x SELECT
13 y <= "000" WHEN "00000001",
14 "001" WHEN "00000010",
15 "010" WHEN "00000100",
16 "011" WHEN "00001000",
17 "100" WHEN "00010000",
18 "101" WHEN "00100000",
19 "110" WHEN "01000000",
20 "111" WHEN "10000000",
21 "ZZZ" WHEN OTHERS;
22 END encoder2;
23---------------------------------------------
Primetimo da WHEN naredba sadrži relativno veliki broj linija (linije 12-20 u rešenju 1, odnosno linije 13-21 u
rešenju 2). S obzirom da svaka linija definiše izlaznu vrednost za jednu konkretnu ulaznu kombinaciju, ovakav
način opisivanja kodera je nepraktičan za n veće od četiri. U takvim slučajevima kompaktniji opis se postiže
korišćenjem naredbe GENERATE (sekcija 2.4.4 ) ili LOOP (sekcija 2.5.6).
Rezultati simulacije prikazani su na Sl. 2-23. Uočimo da su vrednosti signala prikazane u heksadecimalnoj
notaciji. Signal x, čija je dužina 8 bita, predstavlja se sa dve, a signal y, dužine 3 bita, jednom heksadecimalnom
cifrom. Na primer, heksadecimalnoj vrednosti 80 odgovara binarna vrednost ˝10000000˝. Primetimo, takođe, da
je za x=˝00000000˝, izlaz u stanju visoke impedanse. To je iz razloga što sve nule na ulazu nisu dozvoljena
pobuda kodera. Rezultati simulacije su identični za obe varijante VHDL kôda kodera 8-u-3.

Sl. 2-23 Rezultati simulacije VHDL kôda iz Pr. 2-25

Pr. 2-26 Prioritetni koder
Kod binarnog kodera opisanog u prethodnom primeru postoji ograničenje da u bilo kom trenutku najviše jedan
ulaz sme biti aktivan. Ako se ovo ograničenje ne poštuje, u slučajevim kada je aktivno više od jednog ulaza,
izlaz kodera biće pogrešan. Kod prioritetnog kodera, svakom ulazu je dodeljen prioritet, a izlaz kodera,
interpretiran kao binarni broj, ukazuje na indeks aktivnog ulaza najvišeg prioriteta. Za sve vreme dok je aktivan
ulaz visokog prioriteta, svi ulazi nižeg prioriteta se ignorišu. Na Sl. 2-24(a) je prikazana tabela istinitosti, a na Sl.
2-24(b) grafički simbol prioritetnog kodera 8-u-3, pod pretpostavkom da ulaz x(7) ima najviši, a x(0) najniži
prioritet. Izlazi y(2 : 0) predstavljaju binarni broj koji identifikuje ulaz najvišeg prioriteta koji ima vrednost ´1´.
Pošto je moguće da ni jedan ulaz nema vrednost ´1´, predviđen je još jedan, dodatni izlaz, z koji treba da ukaže
na ovu situaciju. Naime, ako je barem jedan ulaz jednak ´1´, tada je z=1; inače, ako su svi ulazi jednak ´0´, važi
z=´0´.
x(7) x(6) x(5) x(4) x(3) x(2) x(1) x(0) y(2) y(1) y(0) z
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0 0 1
0 0 0 0 0 0 1 X 0 0 1 1
0 0 0 0 0 1 X X 0 1 0 1
0 0 0 0 1 X X X 0 1 1 1
0 0 0 1 X X X X 1 0 0 1
0 0 1 X X X X X 1 0 1 1
0 1 X X X X X X 1 1 0 1
1 X X X X X X X 1 1 1 1
(a) (b)
Sl. 2-24 Prioritetni koder 3-u-8: (a) tabela istinitosti; (b) blok dijagram.

47
U nastavku su date dve realizacije prioritetnog kodera u VHDL-u. Prva koristi WHEN/ELSE, a druga
WITH/SELECT/WHEN naredbu.
1 -------Resenje 1 ----------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY pencoder IS
6 PORT (x : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
7 y : OUT STD_LOGIC_VECTOR(2 DOWNTO 0);
8 z : OUT STD_LOGIC);
9 END pencoder;
10---------------------------------------------
11 ARCHITECTURE pencoder1 OF pencoder IS
12 BEGIN
13 y <= "111" WHEN x(7) = '1' ELSE
14 "110" WHEN x(6) = '1' ELSE
15 "101" WHEN x(5) = '1' ELSE
16 "100" WHEN x(4) = '1' ELSE
17 "011" WHEN x(3) = '1' ELSE
18 "010" WHEN x(2) = '1' ELSE
19 "001" WHEN x(1) = '1' ELSE
20 "000";
21 z <= '0' WHEN x = "00000000" ELSE '1';
22 END pencoder1;
23---------------------------------------------
Naredba WHEN/ELSE nalaže da se signalu y dodeli vrednost ˝111˝ kada je ulaz x(7)= ´1´. Ako je ovaj uslov
ispunjen, tada preostale WHEN grane nemaju uticaj na vrednost izlaznog signala y. Druga WHEN grana nalaže
da se signalu y dodeli vrednost ˝110˝ ako je x(6)=´1´. Ovo može da se desi samo ako je x(7)= ´0´. Svaka sledeća
WHEN grana može da utiče na y samo ako ni jedan od uslova iz prethodnih WHEN konstrukcija nije tačan.
Drugim rečima, najviši prioritet ima ulaz x(7), zatim x(6), sve do x(0), koji je najnižeg prioriteta. Na ovaj način,
ostvarena je funkcija prioritetnog kodera. Druga naredba WHEN/ELSE koja postoji u kôdu definiše vrednost
signala z. Ako su svi ulazi 0, tada z ima vrednost 1; inače, signalu z se dodeljuje vrednost 0. Rezultat simulacije
prikazan je na Sl. 2-25. Primetimo da je talasni oblik signala x prikazan na dva načina, najpre kao vektor
(magistrala), a potom u razvijenom obliku, svaki bit pojedinačno. Vrednost signala y, predstavljena u vidu
decimalnog broja ukazuje na indeks ulaza najvišeg prioriteta čija je vrednost jednaka 1.

Sl. 2-25 Rezultati simulacije VHDL kôda prioritetnog kodera iz Pr. 2-26
Nivoi prioriteta pridruženi WHEN granama predstavljaju ključnu razliku između naredbe WHEN/ELSE i
naredbe WITH/SELECT/WHEN, kod koje prioriteti ne postoje. Napomenimo da je prioritetni koder moguće
opisati i pomoću naredbe WITH/SELECT/WHEN, ali će u tom slučaju VHDL kôd biti opširniji i manje
razumljiv. Na primer, u nepotpunoj arhitektura datoj ispod, pokazano je kako se prioritetnog kôdera može
realizovati naredbom WITH/SELECT/WHEN. Prva WHEN grana postavlja y na ˝000˝ pod uslovom da je x(0)
jedini ulaz koji je jednak ´1´. Sledeće dve WHEN grane kazuju da y treba biti ˝001˝ kada je x(7) =x(6)= …
=x(2)= ´0´ i x(1) =´1´. Sledeće četiri WHEN grane definišu uslove pod kojima je vrednost izlaznog signala y

48
jednaka ˝010˝, tj. y=˝010˝ ako je x(7) =x(6)= … =x(3)=´ 0´ i x(2)=´ 1´, bez obzira na vrednost x(1) i x(0).
Konačno, poslednja WHEN grana kaže da u svim ostalim slučajevima, što uključuje i slučaj kada je x(7) =´1´, y
treba biti ˝111˝. Uočimo da WHEN OTHERS konstrukcija obuhvata i ulaznu kombinaciju “00000000”, što
znači da će u tom slučaju izlaz y biti postavljen na ˝111˝. Međutim, kako sve nule na ulazu postavljaju z=´0´, to
u ovom slučaju vrednost izlaza y nije bitna. Primetimo da je napisana u celosti, WITH/SELECT/WHEN naredba
bi sadržala ukupno 127 grana!
---------------------------------------------
ARCHITECTURE pencoder2 OF pencoder IS
BEGIN
WITH x SELECT
y <= "000" WHEN "00000001",
"001" WHEN "00000010",
"001" WHEN "00000011",
"010" WHEN "00000100",
"010" WHEN "00000101",
"010" WHEN "00000110",
"010" WHEN "00000111",
"011" WHEN "00001000",
. . .
"110" WHEN "01111111",
"111" WHEN OTHERS;
WITH x SELECT
z <= '0' WHEN "00000000",
'1' WHEN OTHERS;
END pencoder2;
---------------------------------------------
Pr. 2-27 ALU
Aritmetičko-logička jedinica (ili ALU prema engleskom nazivu Arithmetic and Logic Unit) je višefunkcijsko,
kombinaciono kolo koje može da obavi bilo koju od više različitih aritmetičkih i logičkih operacija nad parom
b-bitnih operanada. Na Sl. 2-26(a) je prikazan blok dijagram, a na Sl. 2-26(b) tabela istinitosti jedne jednostavne
8-bitne ALU koja podržava osam aritmetičkih i osam logičkih operacija. Izbor između aritmetičkih i logičkih
operacija vrši se bitom najveće težine 4-bitnog selekcionog signala sel. Preostala tri bita signala sel biraju jednu
od osam operacija iz svake grupe. Sledi VHDL kôd opisane ALU zasnovan na korišćenju
WITH/SELECT/WHEN naredbe.
sel Operacija Funkcija Jedinica
0000 y <= a Transfer a
0001 y <= a + 1 Inkrement a
0010 y <= a - 1 Dekrement a
0011 y <= b Transfer b
Aritmetička
0100 y <= b + 1 Inkrement b
0101 y <= b - 1 Dekrement b
0110 y <= a + b Sabiranje a i b
0111 y <= a+b + cin Sabiranje a i b sa ul. pren.
1000 y <= NOT a Komplement a
1001 y <= NOT b Komplement b
1010 y <= a AND b I
1011 y <= a OR b ILI
Logička
1100 y <= a NAND b NI
1101 y <= a NOR b NILI
1110 y <= a XOR b Iskljucivo ILI
1111 y <= a NXOR b Iskljucivo NILI
(a) (b)
Sl. 2-26 ALU: (a) Blok dijagram; (b) tabela istinitosti.
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE ieee.std_logic_unsigned.all;
5 ---------------------------------------------
6 ENTITY ALU IS
7 PORT (a,b : IN STD_LOGIC_VECTOR(7 DOWNTO 0);

49
8 sel : IN STD_LOGIC_VECTOR(3 DOWNTO 0);
9 cin : IN STD_LOGIC;
10 y : OUT STD_LOGIC_VECTOR(7 DOWNTO 0));
11 END ALU;
12---------------------------------------------
13 ARCHITECTURE dataflow OF ALU IS
13 SIGNAL arith, logic : STD_LOGIC_VECTOR(7 DOWNTO 0);
15 BEGIN
16 --- Aritmeticka jedinica -----------------
17 WITH sel(2 DOWNTO 0) SELECT
18 arith <= a WHEN "000",
19 a+1 WHEN "001",
20 a-1 WHEN "010",
21 b WHEN "011",
22 b+1 WHEN "100",
23 b-1 WHEN "101",
24 a+b WHEN "110",
25 a+b+cin WHEN OTHERS;
26--- Logicka jedinica -----------------
27 WITH sel(2 DOWNTO 0) SELECT
28 logic <= NOT a WHEN "000",
29 NOT b WHEN "001",
30 a AND b WHEN "010",
31 a OR b WHEN "011",
32 a NAND b WHEN "100",
33 a NOR b WHEN "101",
34 a XOR b WHEN "110",
35 NOT (a XOR b) WHEN OTHERS;
36--- Mux ------------------------------
37 WITH sel(3) SELECT
38 y <= arith WHEN '0',
39 logic WHEN OTHERS;
40 END dataflow;
41---------------------------------------------
Organizacija VHDL kôda usklađena je sa strukturom ALU (Sl. 2-26(a)). Svakom bloku sa Sl. 2-26(a) odgovara
jedna WITH/SELECT/WHEN naredba. Kao što tri bloka u realnoj ALU (Logicka jedinica, Aritmeticka jedinica
i Mux) rade paralelno, tako se i tri WHEN naredbe u odgovarajućem VHDL kôdu izvršavaju konkurentno. Za
spregu konkurentnih sekcija kôda koriste se dva interna signala, arith i logic, koji odgovaraju vezama između
blokova Logicka jedinica i Mux, odnosno Aritmeticka jedinica i Mux u strukturi sa Sl. 2-26(a).
Takođe, treba uočiti da se u prezentovanom kôdu koristi isti tip podataka (STD_LOGIC_VECTOR) za
obavljanje aritmetičkih i logičkih operacija. Ovo je omogućeno prisustvom paketa std_logic_unsigned iz
biblioteke ieee (linija 4).

2.4.4 GENERATE
GENERATE je još jedna konkurentna naredba. Postoje dva oblika ove naredbe: FOR/GENERATE i
IF/GENERATE. FOR/GENERATE konstrukcija je ekvivalentna sekvencijalnoj naredbi LOOP (sekcija 2.5.6) u
smislu da omogućava da se deo konkurentnog kôda ponovi više puta i na taj način kreira više instanci istog
skupa naredbi dodele. IF/GENERATE (ekvivalentna sekvencijalnoj IF naredbi (sekcija 2.5.3) omogućava
uslovno kreiranje obuhvaćenog konkurentnog kôda. Sintaksa dva oblika GENERATE naredbe je sledeća:
FOR/GENERATE:
labela: FOR brojac IN opseg GENERATE
(konkurentne naredbe dodele)
END GENERATE;

IF/GENERATE:
labela: IF uslov GENERATE
(konkurentne naredbe dodele)
END GENERATE;
Svaka GENERATE naredba, u obe varijante, mora biti označena jedinstvenom labelom. Opseg kod
FOR/GENERATE kao i uslov kod IF/GENERATE moraju biti statički (konstantni) izrazi. Dozvoljeno je

50
ugnježdavanje GENERATE naredbi. Na primer, IF/GENERATE konstrukcija se može naći unutar
FOR/GENERATE konstrukcije:
labela1: FOR brojac IN opseg GENERATE
...
labela2: IF uslov GENERATE
(konkurentne naredbe dodele)
END GENERATE;
...
END GENERATE;
Takođe, dozvoljeno je unutar IF/GENERATE umetnuti FOR/GENERATE konstrukciju.
Primer:
SIGNAL x: BIT_VECTOR(7 DOWNTO 0);
SIGNAL y: BIT_VECTOR(15 DOWNTO 0);
SIGNAL z: BIT_VECTOR(7 DOWNTO 0);
. . .
G1: FOR i IN x’RANGE GENERATE
z(i) <= x(i) AND y(i+8);
END GENERATE;
FOR/GENERATE konstrukcija, iz prethodnog VHDL kôdu, za svaku vrednost brojača i iz opsega 0 do 7 kreira
jednu instancu obuhvaćene naredbe dodele. Možemo smatrati da FOR/GENERATE predstavlja koncizan zapis
sledećeg kôda:
z(0) <= x(0) AND y(0+8);
z(1) <= x(1) AND y(1+8);
z(2) <= x(2) AND y(2+8);
z(3) <= x(3) AND y(3+8);
z(4) <= x(4) AND y(4+8);
z(5) <= x(5) AND y(5+8);
z(6) <= x(6) AND y(6+8);
z(7) <= x(7) AND y(7+8);
Prilikom korišćenja FOR/GENERATE naredbe treba voditi računa da ne dođe do višestrukog pobuđivanja
signala. Na primer, kôd:
OK: FOR i IN 0 TO 7 GENERATE
output(i) <= ‘1’ WHEN (a(i) AND b(i))=’1’ ELSE ‘0’;
END GENERATE
je korektan (svaka instanca naredbe dodele dodeljuje vrednost nekom drugom bitu višebitnog signala output).
Međutim, kôd:
NotOK: FOR i IN 0 TO 7 GENERATE
output <= ˝11111111˝ WHEN (a(i) AND b(i))=’1’ ELSE ˝00000000˝;
END GENERATE
ili kôd
NotOK: FOR i IN 0 TO 7 GENERATE
accum <= accum + 1 WHEN (x(i) =’1’);
END GENERATE
su neispravni zato što se istom signalu (output, odnosno accum) dodeljuje vrednost više puta u petlji.
Pr. 2-28 Pomerač
Projektujemo kombinaciono kolo na čijem se izlazu generiše pomerena verzija ulaznog vektora. Izlazni vektor,
outp, je duplo duži od ulaznog, inp, a iznos pomeraja se zadaje preko posebnog ulaza, sel. Za primer, ako je
ulazni vektor 4-bitni, i ima vrednost ˝1111˝, tada, u zavisnosti od vrednosti selekcionog ulaza sel, izlaz može biti
jedan o sledećih 5 8-bitnih vektora (pozicije ulaznog u izlaznom vektoru su podvučene):
out = row(0) = 00001111 -- sel = 0
out = row(1) = 00011110 -- sel = 1
out = row(2) = 00111100 -- sel = 2
out = row(3) = 01111000 -- sel = 3
out = row(4) = 11110000 -- sel = 4

51
Kao što možemo videti, pozicije u izlaznom vektoru, koje nisu zauzet ulaznim vektorom jednake su ´0´. Takođe,
uočimo da se, u prikazanoj šemi, prva mogućnost (sel=1) dobija nadovezivanjem ˝0000˝ i ulaznog vektora, a da
je svaka sledeća mogućnost pomerena za jedu poziciju na levo u odnosu na prethodnu.
Odgovarajući VHDL kôd data je ispod. Princip rešenja je sledeći: deklarisana je matrica row dimenzija 5x8 čije
se vrste, row(i), i=0, .., 4, pomoću GENERATE naredbe, popunjavaju shodno gornjoj šemi, a na izlaz out se
prosleđuje vrsta matrice indeksirana ulazom sel.
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY pomerac IS
6 PORT ( inp : IN STD_LOGIC_VECTOR(3 DOWNTO 0);
7 sel : IN INTEGER RANGE 0 TO 4;
8 outp: OUT STD_LOGIC_VECTOR(7 DOWNTO 0));
9 END pomerac;
10---------------------------------------------
11 ARCHITECTURE pomerac OF pomerac IS
12 SUBTYPE vector IS STD_LOGIC_VECTOR(7 DOWNTO 0);
13 TYPE matrix IS ARRAY(4 DOWNTO 0) OF vector;
14 SIGNAL row : matrix;
15 BEGIN
16 row(0) <= "0000" & inp;
17 G1: FOR i IN 1 TO 4 GENERATE
18 row(i) <= row(i-1)(6 DOWNTO 0) & '0';
19 END GENERATE;
20 outp <= row(sel);
21 END pomerac;
22---------------------------------------------

2.5 Sekvencijalni kôd

VHDL je u osnovi konkurentan jezik. Jedine sekcije kôda koje se izvršavaju sekvencijalno su one obuhvaćene
konstrukcijama PROCESS, FUNCTION i PROCEDURE. Međutim, kao celine, ove sekcije se izvršavaju
konkurentno u odnosu na druge delove kôda. U ovom odeljku razmatraćemo naredbe koje je dozvoljeno koristiti
unutar sekvencijalnih sekcija. To su: IF, WAIT, CASE i LOOP. Korišćenje promenljivih (VARIABLE) je
takođe ograničeno isključivo na sekvencijalni kôd. Za razliku od signala (SIGNAL), VARIABLE ne mogu biti
deklarisane kao globalne, tako da se njihova vrednost ne može direktno preneti iz sekvencijalne sekcije u neki
drugi deo kôda. U ovom odeljku, naša pažnja biće usmerena na konstrukciju PROCESS. Preostale dve
konstrukcije za kreiranje sekvencijalnog kôda (FUNCTION i PROCEDURE) bitne su za projektovanje na
sistemskom nivou i biće detaljno razmatrane u 2.10.

2.5.1 PROCESS
PROCESS predstavlja sekvencijalnu sekciju VHDL kôda. VHDL projekat može sadržati proizvoljan broj
procesa, ali svi oni moraju biti smešteni u arhitekturi u glavnom kôdu, tj. ne mogu biti deo paketa/biblioteke.
Konstrukcija PROCESS ima sledeću sintaksu (opcioni delovi sintakse obuhvaćeni su uglastim zagradama):
[labela:] PROCESS (lista senzitivnosti)
[VARIABLE ime tip [opseg] [:= inicijalna_vrednost]]
BEGIN
(sekvencijalni kôd)
END PROCESS [labela];
Konstrukcija PROCESS počinje ključnom rečju PROCESS, nakon koje sledi tzv. lista senzitivnosti. Lista
senzitivnosti sadrži spisak ulaznih signala na koje je proces senzitivan (osetljiv), tj. na koje proces reaguje.
Promena vrednosti bilo kog signala iz liste senzitivnosti aktivira proces. Nakon aktiviranja, naredbe iz dela
sekvencijalni kôd se izvršavaju jedna za drugom. Nakon što se izvrši i poslednja naredba, proces se deaktivira, i
ostaje neaktivan sve do ponovnog aktiviranja. Varijable su opcione. Ako se koriste, moraju biti deklarisane u
deklarativnom delu procesa (pre ključne reči BEGIN). Prilikom deklaracije, varijabli se može dodeliti inicijalna
vrednost. Međutim, inicijalne vrednosti varijabli su podržane samo u simulaciji, ali ne i u sintezi VHDL kôda.
Takođe opciono, proces može biti označen labelom, kojom započinje i kojom se završava PROCESS
konstrukcija.

52
Procesi se koriste za opis ponašanja kako sekvencijalnih tako i kombinacionih kola. Za kombinaciona kola, lista
senzitivnosti procesa sadrži sve ulazne signale kola. Za sekvencijalna kola, lista senzitivnosti sadrži signal takta
i asinhrone ulaze, ali ne i sinhrone ulaze kola. Sledeći primer ilustruje korišćenje konstrukcije PROCESS na
primeru D flip-flopa sa asinhronim resetovanjem.

Sl. 2-27 D flip-flop sa asinhronim resetovanjem.

Pr. 2-29 D flip-flop sa asinhronim resetovanjem
D flip-flop (DFF) je osnovni gradivni element sekvencijalnih kola. Varijanta DFF sa asinhronim resetom
prikazana je na Sl. 2-27. DFF predstavlja memorijsko kolo kapaciteta jednog bita. Vrednost koja je upisana
(memorisana) u flip-flopu dostupna je na izlazu q. Pod dejstvom rastuće ivice taktnog signala, clk, u DFF se
upisuje vrednost ulaznog signala d. Ulaz za asinhrono resetovanje, rst, služi za forsirano (nezavisno od clk)
postavljanje DFF u stanje q=0. Sledi VHDL kôd DFF-a sa asinhronim resetovanjem.
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY dff IS
6 PORT (d,clk,rst : IN STD_LOGIC;
7 q : OUT STD_LOGIC);
8 END dff;
9 ---------------------------------------------
10 ARCHITECTURE behavior OF dff IS
11 BEGIN
12 PROCESS(clk,rst)
13 BEGIN
14 IF(rst='1') THEN
15 q <= '0';
16 ELSIF(clk'EVENT AND clk='1') THEN
17 q <= d;
18 END IF;
19 END PROCESS;
20 END behavior;
21---------------------------------------------
U prezentovanom VHDL kôdu, funkcija DFF-a je realizovana pomoću procesa koji sadrži samo jednu
sekvencijalnu naredbu, IF. Ako je rst=´1´, izlaz mora biti q=´0´ (linije 14-15), bez obzira na taktni signal clk. U
suprotnom, za rst=´0´, a pod uslovom da se signal clk promenio sa 0 na 1, na izlaz flip-flopa se prenosi vrednost
ulaza d, tj. q=d (linije 16-17). U liniji 16, za detekciju promene signala clk koristi se atribut EVENT.
clk’EVENT vraća TRUE uvek kada se vrednost signala clk promeni (bilo sa 0 na 1 ili sa 1 na 0). Da bi se
izdvojila promena koja odgovara rastućoj ivici, uslov clk’EVENT je dopunjen uslovom clk=´1´). PROCESS
(linije 12-19) se izvrši jedanput, uvek kada se promeni bilo koji od signala clk ili rst. Uočimo da lista
senzitivnosti ne sadrži ulazni signal d. To znači da eventualne promene ovog signala, same po sebi, ne utiču na
rad flip-flopa, već je vrednost signala d od značaja jedino u trenucima promene takta sa 0 na 1 (što upravo
odgovara načinu rada realnog DFF-a).

2.5.2 Signali i varijable

Uopšteno govoreći, u VHDL-u, kao i kod programskih jezika, promenljive se koriste za čuvanje vrednosti
podataka kojima program, odnosno kôd, manipuliše. Za razliku od programskih jezika, VHDL poseduje dve
vrste promenljivih: signali (SIGNAL) i varijable (VARIABLE). Signali i varijable biće podrobnije razmatrani u
poglavlju 2.6. Međutim, radi potpunijeg razumevanja sekvencijalnog kôda, u ovom odeljku, biće izložene
njihove osnovne osobine.
Za razliku od signala koji mogu biti deklarisani u paketu, entitetu ili arhitekturi, varijable mogu biti deklarisane
isključivo u sekvencijalnim sekcijama kôda (kao što je proces). Iz tog razloga, signali mogu biti korišćeni kao
globalne promenljive, (vidljiv u celom projektu), dok su varijable uvek lokalne promenljive. Vrednost varijable
ne može biti direktno preneta iz procesa u neki drugi deo kôda. Ako je to neophodno, vrednost varijable mora

53
najpre biti dodeljena nekom globalnom signalu. Sa druge strane, ažuriranje varijable je trenutno: kao i kod
programskih jezika, nakon izvršene naredbe dodele, varijabla trenutno dobija novu vrednost, koja se može
koristiti već u sledećoj liniji kôda. To nije slučaj sa signalima (kada se koriste u procesu). Dodela vrednosti
signalu, obavljena unutar procesa, odlaže se do trenutka završetka tekućeg izvršenja procesa. To znači da u toku
izvršenja procesa, signali zadržavaju vrednosti koje su imali u trenutku aktiviranja procesa, a novu vrednost
dobijaju tek nakon deaktiviranja procesa. Ako se unutar procesa signalu više puta dodeljuje vrednost, samo
poslednja dodela ima vidljiv efekat. Konačno, podsetimo se da za signale koristi operator dodele ˝<=˝ , a za
varijable ˝:=˝.

2.5.3 IF
Kao što je ranije pomenuto, za kreiranje sekvencijalnog kôda koriste se naredbe: IF, WAIT, CASE i LOOP.
Sintaksa IF naredbe je sledećeg oblika:
IF uslov THEN dodela;
ELSIF uslov THEN (sekvencijane naredbe);
. . .
ELSE (sekvencijane naredbe);
END IF;
IF naredba počine ključnom rečju IF, završava se rečima END IF i sadrži dve opcione klauzule, ELSIF i ELSE.
ELSIF se može ponoviti proizvoljan broj puta, a ELSE samo jedanput. IF i ELSIF grane sadrže uslove koji
predstavljaju logičke izraze (tj. izraze čiji rezultat može biti samo tačno ili netačno). Naredba radi tako što se
redom ispituju uslovi sve dok se ne naiđe na granu čiji je uslov tačan, a onda se redom izvršavaju sve
sekvencijalne naredbe obuhvaćene tom granom. Ako ni jedan uslov nije tačan, izvršiće se ELSE grana (ako
postoji); ako ni jedan uslov nije tačan i ELSE grana ne postoji, IF naredba neće imati nikakav efekat. U svakoj
grani IF naredbe može se naći proizvoljan broj sekvencijalnih naredbi, uključujući i druge IF naredbe.
Primer:
IF(x<y) THEN
v := “11111111”;
w := ‘1’;
ELSIF(x=y) THEN
v:=”11110000”;
w := ‘0’;
ELSE
v:=(OTHERS => ‘0’);
w := ‘1’;
END IF;

Sl. 2-28 BCD brojač iz Pr. 2-30.

Pr. 2-30 BCD brojač
VHDL kôd iz ovog primera realizuje BCD brojač (sekvenca brojanja: 0→1→ ... →9→0). Kolo ima jednobitni
ulaz (clk) i 4-bitni izlaz (count) (Sl. 2-28). Varijabla var se koristi za kreiranje četiri flip-flopa koji pamte tekuće
stanje brojača. IF naredba se koristi za detekciju rastuće ivice takta clk (linija 16) i ispitivanje da li brojač treba
vratiti na 0 (linije 18 i 19).
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE ieee.std_logic_unsigned.all;
5 ----------------------------------------------
6 ENTITY BCD IS
7 PORT (clk : IN STD_LOGIC;
8 count : OUT INTEGER RANGE 0 TO 9);
9 END BCD;
10----------------------------------------------
11 ARCHITECTURE counter OF BCD IS
12 BEGIN

54
13 PROCESS(clk)
14 VARIABLE var : INTEGER RANGE 0 TO 10;
15 BEGIN
16 IF(clk'EVENT AND clk='1') THEN
17 var := var + 1;
18 IF(var=10) THEN var := 0;
19 END IF;
20 END IF;
21 count <= var;
22 END PROCESS;
23 END counter;
24---------------------------------------------
Napomenimo da, u smislu sinteze, gornji opis nije u potpunosti korektan, jer ne poseduje reset ulaz ili neki drugi
način za postavljanje početne vrednosti brojača. Po uključenju napajanja, stanje fizičkog flip-flopa je
proizvoljno (može biti 0 ili 1, ali unapred ne znamo koje). Zbog toga, može se desiti da na početku rada
sintetizovani brojač ne krene od 0, već od stanja koje može biti i jedno od nedozvoljenih (11, 12, .., 15). U
nekim primenama to ne mora biti problem, jer će se brojač posle konačnog boja taktova svakako vratiti na
početak, tj. 0. Ipak, uobičajena je praksa da sekvencijalna kola poseduju ulaz za resetovanje, koji omogućava da
se na početku rada kolo postavi u poznato početno stanje i na taj način pripremiti za normalni rad. Napomenimo
još i to da se problem nepredvidljivog početnog ponašanja ne može otkriti simulacijom kôda, s obzirom da se u
simulaciji sve INTEGER varijable inicijalno postavljaju na vrednost 0. Problemi ovog tipa se lakše uočavaju u
simulaciji ako se umesto signala tipa INTEGER koriste signali tipa STD_LOGIC, kod kojih je podrazumevana
inicijalna vrednost ´X´ (nepoznata vrednost). Operacija kao što je var := var + 1 za var=’X’ daje takođe ´X´, što
se u vremenskom dijagramu manifestuje kao neprekidna prava linija što jasno ukazuje na problem izostanka
pravilne inicijalizacije.

d q
D FF D FF D FF D FF

clk
rst
Sl. 2-29 4-bitni pomerački registar
Pr. 2-31 Pomerački registar
Na Sl. 2-29 je prikazana struktura 4-bitnog pomeračkog registra sa asinhronim resetovanjem. Informacija se
unosi u registar serijski (tj. bit-po-bit) preko ulaza d. Na svaku rastuću ivicu takta, clk, sadržaj svakog D flip-
flopa se prenosi u sledeći flip-flop. To znači da se informacija sa ulaza d pojavljuje na izlazu prvog flip-flopa
jedan taktni period kasnije, na izlazu drugog flip-flopa dva taktna perioda kasnije i td. Sledi VHDL opis
pomeračkog registra sa Sl. 2-29.
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------
5 ENTITY pomreg IS
6 GENERIC (n : INTEGER := 4); -- broj razreda
7 PORT ( d,clk,rst: IN STD_LOGIC;
8 q: OUT STD_LOGIC);
9 END pomreg;
10----------------------------------------------
11 ARCHITECTURE RTL OF pomreg IS
12 SIGNAL reg : STD_LOGIC_VECTOR(n-1 DOWNTO 0);
13 BEGIN
14 PROCESS (clk, rst)
15 BEGIN
16 IF(rst='1') THEN
17 reg <= (OTHERS => '0');
18 ELSIF(clk'EVENT AND clk='1') THEN
19 reg <= d & reg(reg'LEFT DOWNTO 1);
20 END IF;
21 END PROCESS;
22 q <= reg(0);
23 END RTL;
24----------------------------------------------

55
Za memorisanje sadržaja registra koristi se signal reg. Ispravno rešenje bilo bi i ono kod koga bi se umesto
signala, za memorisanje sadržaja registra koristila varijabla deklarisana u procesu, slično kao u prethodnom
primeru. Obratimo pažnju kako je u procesu realizovana funkcija pomeranja (linija 19). Novi sadržaj registra se
formira nadovezivanjem (operacija &) vrednosti ulaza d i tekućeg sadržaja registra, počev od krajnjeg levog bita
do pretposlednjeg bita. Takođe, primetimo da se prenos stanja krajnjeg desnog flip-flopa (reg(0)) ne izlazni port
q obavlja naredbom dodele (linija 22) koja je izvan procesa. U suštini, proces (linije 14-21) i naredba dodele
(linija 22) rade konkurentno. Proces se aktivira na svaku promenu ulaznih signala clk i rst da bi odredio novi
sadržaj signala reg. Naredba dodele ˝neprekidno˝ i nezavisno od procesa, prenosi vrednost reg(0) na izlaz q.

2.5.4 WAIT
Kao što već znamo, proces koji ima listu senzitivnosti se uvek suspenduje nakon izvršenja svoje poslednje
sekvencijalne naredbe. Naredba WAIT predstavlja alternativni način za suspenziju izvršenja procesa. Postoje tri
osnovna oblika WAIT naredbe:
WAIT UNTIL uslov;
WAIT ON signal1 [, signal2, …];
WAIT FOR vreme;
Šta više, ako se u procesu koristi WAIT naredba, lista senzitivnosti mora biti izostavljena.
WAIT naredba vodi proces u suspendovano stanje. Uslov pod kojim proces nastavlja izvršenje, određen je
oblikom WAIT naredbe. Kod WAIT UNTIL varijante, proces ostaje suspendovan sve dok uslov sadržan u
naredbi ne postane tačan.
Pr. 2-32 8-bitni registar sa sinhronim resetovanjem
PROCESS
BEGIN
WAIT UNTIL(clk’EVENT AND clk=’1’);
IF(rst = ‘1’) THEN
out <= “00000000”;
ELSIF (clk’EVENT AND clk=’1’) THEN
out <= input;
END IF;
END PROCESS;
Nailaskom na naredbu WAIT UNTIL, proces se suspenduje i čeka na ispunjenje uslova, koji odgovara rastućoj
ivici signala clk.
Uslov za nastavak izvršenja WAIT ON naredbe je pojava događaja na bilo kom signalu navedenom u naredbi. U
sledećem primeru, svaka promenu signala clk ili rst aktivira proces, koji se nakon izvršenja IF naredbe vraća na
početak i ponovo suspenduje WAIT ON naredbom.
Pr. 2-33 8-bitni registar sa asinhronim resetovanjem
PROCESS
BEGIN
WAIT ON clk, rst;
IF(rst = ‘1’) THEN
out <= “00000000”;
ELSIF (clk’EVENT AND clk=’1’) THEN
out <= input;
END IF;
END PROCESS;
Komentar: jedina suštinska razlika između dva prethodna primera je u tome što kod prvog reset signal ne
aktivira, a kod drugog aktivira proces. Kod registra sa sinhronim resetovanjem, proces reaguje jedino na taktni
signal, tačnije na rastuću ivicu takta. To znači da eventualno aktiviranje signala rst, nema uticaja na rad registra
sve do pojave rastuće ivice takta. Kod registra sa asinhronim resetovanjem, proces aktivira ne samo taktni signal
već i reset signal. Na taj način, dejstvo signala rst je trenutno i nezavisno od takta.
WAIT FOR suspenduje izvršenje procesa na zadato vreme. Na primer, WAIT FOR 5ns, suspenduje izvršenje
procesa na 5ns. WAIT FOR je namenjena simulaciji (za generisanje talasnih oblika pobudnih signala) i ne može
se koristiti u kôdu za sintezu.

56
Pr. 2-34 DFF sa asinhronim resetovanjem (varijanta 2)
VHDL kôd koji sledi opisuje isti DFF iz Pr. 2-34. U odnosu na kôd iz Pr. 2-34, lista senzitivnosti zamenjena je
WAIT ON naredbom.
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY dff IS
6 PORT (d,clk,rst : IN STD_LOGIC;
7 q : OUT STD_LOGIC);
8 END dff;
9 ---------------------------------------------
10 ARCHITECTURE dff OF dff IS
11 BEGIN
12 PROCESS
13 BEGIN
14 WAIT ON rst,clk;
15 IF(rst='1') THEN
16 q <= '0';
17 ELSIF(clk'EVENT AND clk='1') THEN
18 q <= d;
19 END IF;
20 END PROCESS;
21 END dff;
22---------------------------------------------
Pr. 2-35 BCD brojač (varijanta 2)
U ovom primeru realizovan je BCD brojač iz Pr. 2-30, a jedina razlika je u tome što se umesto liste senzitivnosti
i IF naredbe koristi WAIT UNTIL naredba.
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY brojac IS
6 PORT (clk : IN STD_LOGIC;
7 cifra : OUT INTEGER RANGE 0 TO 9);
8 END brojac;
9 ---------------------------------------------
10 ARCHITECTURE brojac OF brojac IS
11 BEGIN
12 PROCESS -- nema liste senzitivnosti
13 VARIABLE v : INTEGER RANGE 0 TO 10;
14 BEGIN
15 WAIT UNTIL (clk'EVENT AND clk='1');
16 v := v + 1;
17 IF(v = 10) THEN v := 0; END IF;
18 cifra <= v;
19 END PROCESS;
20 END brojac;
21---------------------------------------------

2.5.5 CASE
CASE je još jedna naredba namenjena isključivo za primenu u sekvencijalnom kôdu. CASE naredbe ima
sledeću sintaksu:
CASE selekcioni_izraz IS
WHEN vrednost => sekvencijalne_naredbe;
WHEN vrednost => sekvencijalne_naredbe;
. . .
END CASE;
Primer:
CASE ctrl IS
WHEN "00" => x<=a; y<=b;

57
 WHEN "01" => x<=b; y<=c;
WHEN OTHERS => x<="0000"; y<="ZZZZ";
END CASE;
Naredba CASE je slična konkurentnoj naredbi WHEN. Zavisno od vrednosti selekcionog izraza, za izvršenje se
bira jedna od WHEN grana. Kao i kod konkurentne WHEN naredbe, sve moguće vrednosti izraza moraju biti
pokrivene WHEN granama. Grana OTHERS pokriva sve vrednosti selekcionog izraza koje nisu obuhvaćene
prethodnim granama. Za razliku od konkurentne WHEN naredbe, CASE naredba dozvoljava da svaka grana, u
delu sekvencijalne_naredbe, sadrži više od jedne naredbe (slično IF naredbi). U granama gde ne postoji potreba
za bilo kakvom akcijom, dozvoljeno je koristiti ključnu reč NULL. Na raspolaganju su tri oblika selekcionog
izraza:
WHEN vrednost -- testiranje jedinstvene vrednosti
WHEN vrednost_1 to vrednost_2 -- testiranje opsega vrednosti (samo za nabrojive
-- tipove podataka)
WHEN vrednost_1 | vrednost_2 | … -- vrednost_1 ili vrednost_2 ili …

Pr. 2-36 D flip-flop sa asinhronim resetovanjem (varijanta 3)

U ovom primeru realizovan je D flip-flop iz Pr. 2-29, s tom razlikom što se umesto IF koristi CASE naredba.
Takođe, umesto tipa STD_LOGIC, koristi se ugrađeni tip BIT. Komentari u kôdu ukazuju na konsekvence
promene tipa. (Napomenimo da OTHERS grana u CASE naredbi nije neophodna zato što su vrednostima ´0´ i
´1´ iscrpljene sve moguće vrednosti bita rst.)
1 ---------------------------------------------
2 LIBRARY ieee; -- nepotrebna deklaracija:
3 USE ieee.std_logic_1164.all; -- koristi se tip BIT umesto std_logic
4 ---------------------------------------------
5 ENTITY dff IS
6 PORT (d,clk,rst : IN BIT;
7 q : OUT BIT);
8 END dff;
9 ---------------------------------------------
10 ARCHITECTURE dff3 OF dff IS
11 BEGIN
12 PROCESS(clk,rst)
13 BEGIN
14 CASE rst IS
15 WHEN '1' => q<='0';
16 WHEN '0' =>
17 IF(clk'EVENT AND clk='1') THEN
18 q<=d;
19 END IF;
20 WHEN OTHERS => NULL; --nepotrebno, rst je tipa BIT
21 END CASE;
22 END PROCESS;
23 END dff3;
24---------------------------------------------
Pr. 2-37 Dvocifarski brojač sa SSD izlazom
U ovom primeru biće realizovan dvocifarski decimalni brojač (0→99→0) sa asinhronim resetovanjem i izlazom
prilagođenim za pobudu 7-segmentnog displeja (SSD izlaz). Sprega brojača i displeja prikazana je na Sl. 2-30.
Brojač je realizovan u vidu procesa (linije 12-57) koji sadrži tri sekvencijalne naredbe: jedne IF naredbe koja
realizuje funkciju brojanja i resetovanja, i dve CASE naredbe (linije 31-56) koje vrše konverziju binarno
kodiranih decimalnih cifra u 7-bitni kôd za pobudu 7-segmentnog displeja. Prva CASE naredba (linije 31-43)
konvertuje cifru jedinica, a druga (linije 44-57) cifru desetica.
7-seg. displej
a
cifra2
BROJAC

f g b
clk e c
cifra1
d
abcdefg
rst
Sl. 2-30 Sprega 2-cifarskog BCD brojača i 7-segmentnog displeja.

58
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY brojac IS
6 PORT (clk,rst : IN STD_LOGIC;
7 cifra1, cifra2 : OUT STD_LOGIC_VECTOR(6 DOWNTO 0));
8 END brojac;
9 ---------------------------------------------
10 ARCHITECTURE brojac OF brojac IS
11 BEGIN
12 PROCESS(clk, rst)
13 VARIABLE v1 : INTEGER RANGE 0 TO 10;
14 VARIABLE v2 : INTEGER RANGE 0 TO 10;
15 BEGIN
16 ------- brojac --------------------------
17 IF(rst='1') THEN
18 v1 := 0;
19 v2 := 0;
20 ELSIF(clk'EVENT AND clk='1') THEN
21 v1 := v1 + 1;
22 IF(v1=10) THEN
23 v1 := 0;
24 v2 := v2 + 1;
25 IF(v2=10) THEN
26 v2 := 0;
27 END IF;
28 END IF;
29 END IF;
30 ------- BCD u SSD konverzija-------------
31 CASE v1 IS
32 WHEN 0 => cifra1 <= "1111110"; --7E
33 WHEN 1 => cifra1 <= "0110000"; --30
34 WHEN 2 => cifra1 <= "1101101"; --6D
35 WHEN 3 => cifra1 <= "1111001"; --79
36 WHEN 4 => cifra1 <= "0110011"; --33
37 WHEN 5 => cifra1 <= "1011011"; --5B
38 WHEN 6 => cifra1 <= "1011111"; --5F
39 WHEN 7 => cifra1 <= "1110000"; --70
40 WHEN 8 => cifra1 <= "1111111"; --7F
41 WHEN 9 => cifra1 <= "1111011"; --7B
42 WHEN OTHERS => NULL;
43 END CASE;
44 CASE v2 IS
45 WHEN 0 => cifra1 <= "1111110"; --7E
46 WHEN 1 => cifra1 <= "0110000"; --30
47 WHEN 2 => cifra1 <= "1101101"; --6D
48 WHEN 3 => cifra1 <= "1111001"; --79
49 WHEN 4 => cifra1 <= "0110011"; --33
50 WHEN 5 => cifra1 <= "1011011"; --5B
51 WHEN 6 => cifra1 <= "1011111"; --5F
52 WHEN 7 => cifra1 <= "1110000"; --70
53 WHEN 8 => cifra1 <= "1111111"; --7F
54 WHEN 9 => cifra1 <= "1111011"; --7B
55 WHEN OTHERS => NULL;
56 END CASE;
57 END PROCESS;
58 END brojac;
59---------------------------------------------
Komentar: Uočimo da su u gornjem kôdu CASE naredbe, praktično, ponovljene, jer se razlikuju samo u
selekcionom izrazu. U poglavlju 2.9 biće pokazano kako se često korišćeni delovi kôda mogu kompajlirati u
korisnički-definisane biblioteke i tako izbeći ponavljanje kôda.

2.5.6 LOOP
LOOP naredba se koristi za kreiranje petlji u sekvencijalnom kôdu. Postoje tri oblika LOOP naredbe:

59
1) LOOP / FOR: petlja se ponavlja zadati broj puta.
[labela: ] FOR identifikator IN opseg LOOP
(sekvencijalne naredbe)
END LOOP [labela];

Primer:
faktorijel := 1;
FOR broj IN 2 TO 10 LOOP
faktorijel := faktorijel * broj;
END LOOP;
U ovom primeru, telo petlje se izvršava 9 puta (za broj = 2, 3, ..., 10). Na kraju svake iteracije, identifikator (ili
brojač) petlje, broj, uvećava se za 1. Identifikator petlje nije potrebno deklarisati izvan petlje. U telu petlje, nije
dozvoljeno dodeljivati vrednosti identifikatoru (npr. naredba broj := 3 u telu petlje nije dozvoljena). U kôdu
namenjenom sintezi obe granice opsega FOR / LOOP naredbe moraju biti statičke (slično kao kod GENERATE
naredbe). Na primer, deklaracija tipa FOR i IN 0 TO n, gde je n varijabla, se ne može sintetizovati.
2) WHILE / LOOP: Petlja se ponavlja sve dok se ne ispuni zadati uslov.
[labela: ] WHILE uslov LOOP
(sekvencijalne naredbe)
END LOOP [labela];
Primer:
i:= 0; sum:= 10;
WHILE (i < 20) LOOP
sum:= sum * 2;
i:= i + 3;
END LOOP;
Telo petlje se ponavlja sve dok je varijabla i manja od 20.
U okviru tela petlje dozvoljeno je koristiti dve specijalne naredbe: EXIT i NEXT.
EXIT: se koristi za prevremeni izlazak iz petlje.
[labela: ] EXIT [labela] [WHEN uslov];
Na primer, sledeći kôd:
SIGNAL data : STD_LOGIC_VECTOR(7 DOWNTO 0);
. . .
count:=0;
FOR i IN data’RANGE LOOP
CASE data(i) IS
WHEN ‘0’ => count:=count+1;
WHEN OTHERS => EXIT;
END CASE;
END LOOP;
određuje koliko ˝vodećih˝ nula ima u vektoru data. EXIT ne znači završetak tekuće iteracije petlje, već
definitivno napuštanje petlje. Brojač petlje, i, kreće od i=7 i u svakoj iteraciji se smanjuje za 1. Petlja se
završava kada se u vektoru data naiđe na bit ‘0’, ili ako brojač petlje dostigne krajnju graničnu vrednost, i=0
(što će da se desi ako važi data=˝11111111˝).
NEXT: koristi se u telu petlje za ˝preskakanje˝ jedne iteracije petlje.
[labela: ] NEXT [labela] [WHEN uslov];
Za razliku od naredbe EXIT, koja završava petlju, naredba NEXT završava tekuću iteraciju. Na primer, petlja:
FOR i IN 0 TO 15
NEXT WHEN i=5;
(. . .)
END LOOP;
biće izvršena za svako i iz opsega 0 do 15, osim za i=5.
3) LOOP: ˝beskonačna˝ petlja.
[labela: ] LOOP
(sekvencijalne naredbe)
END LOOP [labela];

60
Uslov za izlazak iz petlje definisan je u telu petlju, npr. naredbom EXIT:
sum:=1;
LOOP
sum:=sum*3;
EXIT WHEN sum>100;
END LOOP;
Petlja:
LOOP
WAIT on a,b;
EXIT WHEN a=b;
END LOOP;
ima isti efekat kao naredba:
WAIT UNTIL a=b;

Pr. 2-38 Sabirač sa rednim prenosom.

Sl. 2-31 prikazuje blok dijagram i unutrašnju strukturu 8-bitnog sabirača sa rednim prenosom. Kolo poseduje dva
8-bitna ulaza, a i b, za sabirke, jednobitni ulaz za ulazni prenos, cin, 8-bitni izlaz za sumu, s, i jednobitni izlaz za
izlazni prenos, cout. Sabirač čini osam redno povezani potpunih sabirača (FA). Funkcija potpunog sabirača na i-
toj poziciji može se izraziti jednačinama:
si = ai XOR bi XOR ci
ci+1 = (ai AND bi) OR (ai AND ci) OR (bi AND ci)
a7 b7 a1 b1 a0 b0
a
s
c8 c7 c2 c1 c0
b ...
+

FA FA FA
(cout) (cin)
cin cout

s7 s1 s0
Sl. 2-31. Sabirač sa rednim prenosom.
U nastavku su izložena dva rešenja. Prvo rešenje je generičko (realizuje sabirač za proizvoljan broj bita), dok je
drugo ograničeno na 8-bitne brojeve. Uz to, prvo rešenje ilustruje upotrebu vektora i FOR/LOOP naredbe, a
drugo upotrebu INTEGER-a i IF naredbe.
1 ---Resenje 1: GENERIC i vektori--------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY sabirac IS
6 GENERIC(duzina : INTEGER := 8);
7 PORT (a,b : IN STD_LOGIC_VECTOR(duzina-1 DOWNTO 0);
8 cin : IN STD_LOGIC;
9 s : OUT STD_LOGIC_VECTOR(duzina-1 DOWNTO 0);
10 cout : OUT STD_LOGIC);
11 END sabirac;
12---------------------------------------------
13 ARCHITECTURE sabirac1 OF sabirac IS
14 BEGIN
15 PROCESS(a,b,cin)
16 VARIABLE c : STD_LOGIC_VECTOR(duzina DOWNTO 0);
17 BEGIN
18 c(0):=cin;
19 FOR i IN 0 TO duzina-1 LOOP
20 s(i) <= a(i) XOR b(i) XOR c(i);
21 c(i+1):=(a(i) AND b(i)) OR (a(i) AND c(i)) OR (b(i) AND c(i));
22 END LOOP;
23 cout <= c(duzina);
24 END PROCESS;
25 END sabirac1;
26---------------------------------------------

61
1 ---Resenje 2: ne-genericko i INTEGER-i ------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY sabirac IS
6 PORT (a,b : IN INTEGER RANGE 0 TO 255; --odgovara opsegu 8-bitnih brojeva
7 cin : IN STD_LOGIC;
8 s : OUT INTEGER RANGE 0 TO 255;
9 cout : OUT STD_LOGIC);
10 END sabirac;
11---------------------------------------------
12 ARCHITECTURE sabirac2 OF sabirac IS
13 BEGIN
14 PROCESS(a,b,cin)
15 VARIABLE sum : INTEGER RANGE 0 TO 511; --odgovara opsegu 9-bitnih brojeva
16 BEGIN
17 IF(cin='1') THEN sum := 1;
18 ELSE sum := 0;
19 END IF;
20 sum := a + b + sum;
21 IF(sum > 255) THEN
22 cout <= '1';
23 sum:=sum-256;
24 ELSE cout<='0';
25 END IF;
26 s <= sum;
27 END PROCESS;
28 END sabirac2;
29---------------------------------------------
Prvo rešenje usklađeno je sa strukturom sabirača (Sl. 2-31). Unutar procesa uvedena je varijabla c za čuvanje
izlaznih prenosa. Dužina vektora c je za jedan veća od dužine sabiraka (zbog izlaznog prenosa iz sabirača, cout).
Pre ulaska u petlju, bitu najmanje težine vektor c dodeljuje se vrednost ulaznog prenosa, c(0):=cin. U petlji, za
svaku bitsku poziciju izračunavaju se: bit sume s(i) i bit prenosa c(i+1). Nakon izlaska iz petlje, bit najveće
težine vektora c prenosi se na izlazni port cout. Drugo rešenje realizuje funkciju sabiranja na višem nivou
apstrakcije. Celobrojna varijabla, sum, opsega 0 do 511 se koristi za prihvatanje rezultata sabiranja ulaznih
operanada, a, b i ulaznog prenosa, cin. Na osnovu dobijenog zbira, određuje se vrednost izlaznog prenosa. Ako
zbir prevazilazi opseg 8-bitnih brojeva (> 255), izlazni prenos dobija vrednost cout=´1´, a suma se koriguje
oduzimanjem vrednosti 28. Konačno, vrednost sum se prosleđuje na izlazni port s. Obe varijante se mogu
sintetizovati. U prvom slučaju, alat za sintezu, razlaže VHDL kôd na logičke jednačine koje potom realizuje
pomoću logičkih kola. U drugom slučaju, alat za sintezu detektuje prisustvo operatora ˝+˝ u VHDL kôdu i
direktno ga zamenjuje sabiračem koji je raspoloživ u pratećoj biblioteci unapred sintetizovanih modula. Treba
napomenuti da je struktura sa Sl. 2-31 samo jedna od mogući realizacija binarnog sabirača. Tipično, projektant
može da bira koji će od raspoloživih tipova sabirača biti iskorišćen od strane alata za sintezu.
Pr. 2-39 Jednostavni barrel pomerač
Barrel pomerač je kombinaciona mreža koja realizuje funkciju pomeranja ili rotiranja ulazne informacije za
zadati broj bitskih pozicija. Na Sl. 2-32 je prikazana struktura jednog jednostavnog 8-bitnog barrel pomerača. Za
shift=0, ulazni 8-bitni podatak se prenosi na izlaz bez ikakve promene (outp(0)=inp(0), …, outp(7)=inp(7)). Za
shift=1, na izlazu se javlja ulazni podatak pomeren za jednu bitsku poziciju ulevo (oupt(0)=0, oupt(1)=inp(0)
…, oupt(7)=inp(6)). Primetimo da se prilikom pomeranja ulazni bit inp(7) gubi, a da se na izlaznu poziciju
outp(0), koja ostaje upražnjena, postavlja ´0´.
inp(7) inp(6) inp(5) inp(4) inp(3) inp(2) inp(1) inp(0) ‘0’

shift mux mux mux mux mux mux mux mux

outp(7) outp(6) outp(5) outp(4) outp(3) outp(2) outp(1) outp(0)

Sl. 2-32 8-bitni barrel pomerač.
Generički VHDL kôd jednostavnog barrel pomerača, dat ispod, ilustruje upotrebu FOR / LOOP naredbe. Za
slučaj kada je shift=1, najpre se na izlaz outp(0) postavi ´0´ (linija 20) , a zatim se u FOR / LOOP petlji za svaki
sledeći izlaz prenosi vrednost sa prethodnog ulaza (linije 21-23).

62
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY barrel IS
6 GENERIC(n : INTEGER := 8);
7 PORT (inp : IN STD_LOGIC_VECTOR(n-1 DOWNTO 0);
8 shift : IN INTEGER RANGE 0 TO 1;
9 outp : OUT STD_LOGIC_VECTOR(n-1 DOWNTO 0);
10 cout : OUT STD_LOGIC);
11 END barrel;
12 ---------------------------------------------
13 ARCHITECTURE RTL OF barrel IS
14 BEGIN
15 PROCESS(inp,shift)
16 BEGIN
17 IF(shift=0) THEN
18 outp <= inp;
19 ELSE
20 outp(0)<='0';
21 FOR i IN 1 TO inp'HIGH LOOP
22 outp(i)<=inp(i-1);
23 END LOOP;
24 END IF;
25 END PROCESS;
26 END RTL;
27 ---------------------------------------------
Pr. 2-40 Brojanje vodećih nula
VHDL kôd iz ovog primera određuje broj vodećih nula u binarnom vektoru (počev od krajnje leve bitske
pozicije). Na primer za ulaz ˝00010101˝, kolo na izlazu generiše 3. Kôd ilustruje upotrebu LOOP / EXIT
naredbe. FOR petlja se napušta kada se u ulaznom vektoru data naiđe na prvu 1-cu. Za brojanje nula koristi se
interna varijabla count, čija se konačna vrednost prenosi na izlazni port zeros (linija 22).
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------
5 ENTITY VodeceNule IS
6 PORT (data : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
7 zeros : OUT INTEGER RANGE 0 TO 8);
8 END VodeceNule;
9 ----------------------------------------------
10 ARCHITECTURE behavior OF VodeceNule IS
11 BEGIN
12 PROCESS(data)
13 VARIABLE count : INTEGER RANGE 0 TO 8;
14 BEGIN
15 count := 0;
16 FOR i IN data'RANGE LOOP
17 CASE data(i) IS
18 WHEN '0' => count := count + 1;
19 WHEN OTHERS => EXIT;
20 END CASE;
21 END LOOP;
22 zeros <= count;
23 END PROCESS;
24 END behavior;
25---------------------------------------------

2.5.7 Sekvencijalni kôd za kombinaciona kola

Sekvencijalni kôd se može koristiti kako za realizaciju sekvencijalnih, tako i kombinacionih kola. Razlika
između ova dva tipa kola je u tome što su kod prvih neophodni registri (flip-flopovi), dok se kod drugih registri
ne koriste. Da bi kompajler prepoznao kôd kao kôd za kombinaciono kolo, neophodno je da su ispunjena
sledeća dva uslova:

63
 - Svi ulazni signali koji se koriste (˝čitaju˝) u procesu moraju biti navedeni u listi senzitivnosti.
- U kôdu su sadržane sve kombinacije ulaznih/izlaznih signala, tako da kompajler analizom kôda može
da rekonstruiše potpunu tabelu istinitosti.
Prvi uslov nije obavezan za sintezu. Tipično, ako je lista senzitivnosti nepotpuna, kompajler će izdati
odgovarajuće upozorenje, ali će sintetizovano kolo biti korektno. Problem će se javiti u simulaciji takvog kôda,
jer proces neće reagovati na ulazne signale kojih nema u listi senzitivnosti. Drugi uslov čini suštinsku razliku
između kombinacionih i sekvencijalnih kola i mora biti ispunjen da se generisalo korektno rešenje. Nedefinisan
odziv procesa na neku ulaznu kombinaciju znači da proces pri takvoj pobudi zadržava (memoriše) prethodni
izlaz. Da bi se omogućilo memorisanje, u sintetizovano kolo biće uključena leč kola.
Pr. 2-41 Primer pogrešnog kombinacionog opisa
Razmotrimo kolo sa Sl. 2-33(a) čija je funkcija definisana na sledeći način: izlaz x se ponaša kao multiplekser sa
dvobitnim selekcionim ulazom sel i četiri jednobitna ulaza za podatke: a, b, c i d. Sa druge strane, izlaz y jednak
je ´0´ za sel=˝00˝, odnosno ´1´ za sel=˝01˝ (tabela istinitosti sa Sl. 2-33(b)). Primetimo da se radi o
kombinacionom kolu. Međutim, specifikacija kola je nekompletna, jer ne definiše y za sel=˝10˝ i sel=˝11˝.
a sel x y sel x y sel(1) sel x y
x 00 a 0 00 a 0 sel(0) 00 a 0
b
01 b 1 01 b 1 y
01 b 1
c 10 c 10 c y 10 c X
y 11 d 11 d y 11 d X
d

sel(1:0)
(a) (b) (c) (d) (e)
Sl. 2-33 Kolo iz Pr. 2-41: (a) blok dijagram; (b) polazna specifikacija; (c) tabela istinitosti realizovanog kola; (d)
logička mreža realizovanog kola; (d) ispravan pristup.
Oslanjajući se na nekompletnu specifikaciju (Sl. 2-33(b)), možemo kreirati sledeći VHDL kôd:
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY primer IS
6 PORT (a,b,c,d : IN STD_LOGIC;
7 sel : IN INTEGER RANGE 0 TO 3;
8 x,y : OUT STD_LOGIC);
9 END primer;
10 ---------------------------------------------
11 ARCHITECTURE primer OF primer IS
12 BEGIN
13 PROCESS(a,b,c,d,sel)
14 BEGIN
15 IF(sel=0) THEN
16 x<=a;
17 y<='0';
18 ELSIF(sel=1) THEN
19 x<=b;
20 y<='1';
21 ELSIF(sel=2) THEN
22 x<=c;
23 ELSE
24 x<=d;
25 END IF;
26 END PROCESS;
27 END primer;
28 ---------------------------------------------
Izveštaj koji bi se dobio nakon kompajliranja kôda, pokazao bi da flip-flopovi nisu uključeni u sintetizovano
kolo. Međutim, ako pogledamo rezultate simulacije (Sl. 2-34) uočićemo ˝čudno˝ ponašanje izlaza y. Na primer,
za neke vrednosti ulaza sel (konkretno sel=˝11˝, decimalno 3) dobijaju se dva različite vrednosti izlaza. Ako
vrednosti ulaza sel=˝11˝, prethodni sel=˝00˝, vrednost izlaza biće y=´0´; međutim ako istoj vrednosti ulaza sel
prethodi sel=˝01˝, izlaz će biti y=´1´. Ovakvo ponašanje ukazuje na postojanje memorije u sintetizovanom kolu.
Kompajler prevodi IF naredbu u sledeću logičku jednačinu: y = (sel(0) AND sel(1)) OR (sel(0) AND y) OR

64
(sel(1) AND y), kojoj odgovara kolo sa Sl. 2-33(d), odnosno tabela istinitosti sa Sl. 2-33(c). S obzirom da u mreži
postoje povratne veze, tj. da izlaz y zavisi ne samo od ulaza sel već i od svoje tekuće vrednosti, reč je
sekvencijalnom kolu.

Sl. 2-34 Rezultati simulacije VHDL kôda iz Pr. 2-41

Da bi se izbeglo kreiranje povratnih veza, treba koristiti specifikaciju sa Sl. 2-33(e) gde je nedefinisano
ponašanje izlaza y označeno simbolom za proizvoljnu vrednost, ´X´. Simbol ´X´ u vrstama za sel=˝10˝ i
sel=˝11˝ znači da u tim slučajevima vrednost y može biti bilo koja, tj. ´1´ ili ´0´. Odgovarajuća modifikacija
VHDL kôda sastoji se u umetanju linije y=´x´; ispod linija 22 i 24 u datom kôdu. Sa ovakvom modifikacijom,
jednačina za y se svodi na y=sel(0).
Nepostojanje definisanog ponašanja izlaza za pojedine kombinacije ulaza, koje kod kombinacionih opisa dovodi
do pogrešnog tumačenja njihove funkcije, predstavlja osnovni način za opis asinhronih memorijskih kola, kao
što će biti pokazano u sledećem odeljku.

2.5.8 Leč kola i flip-flopovi

Kao što znamo, leč kola i flip-flopovi su dva osnovna tipa elementarnih memorijskih kola. Razmotrićemo D leč
i D flip-flop. Grafički simboli D flip-flopa i D leča prikazani su na Sl. 2-35(a) i (b). (uočimo različito
označavanje ulaza za takt.) Ključna osobina flip-flopova je reakcija na ivicu, a ne na nivo taktnog signala, što je
naznačeno trouglom na ulazu za takt. Promena stanja (tj. memorisane vrednosti) flip-flopa inicirana je ivicom
taktnog signala. Na taj način flip-flop nikada nije transparentan: bez obzira na nivo taktnog signala, ulazi flip-
flopa nikada direktno ne utiču na izlaz flip-flopa, već samo definišu stanje u koje će flip-flop biti postavljen pod
dejstvom naredne aktivne ivice taktnog impulsa. Sa druge strane, D leč reaguje na nivo taktnog signala. Za sve
vreme dok je taktni signal aktivan (clk=1), D leč je transparentan jer se svaka promena vrednosti ulaza D
direktno prenosi na izlaz Q (Q = D). U trenutku deaktiviranja takta (prelaz sa 1 na 0), leč se ˝zaključava˝ i pamti
svoje tekuće stanje. Za vreme dok je clk=0, eventualne promene ulaza D ne utiču na stanje leča. Opisana razlika
u ponašanju D leča i D flip-flopa ilustrovana je vremenskim dijagramom sa Sl. 2-35(c).

(a) (b) (c)

Sl. 2-35 Razlike između flip-flopova i leč kola: (a) D flip-flop; (b) D leč; (c) vremenski dijagram.
U nastavku su dati VHDL opisi D flip-flopa i D leča. Kôd za D flip-flop sličan je kôdu iz Pr. 2-29, s tom
razlikom što je sada izostavljen signal za asinhrono resetovanje. Iako kôd ne zahteva neko posebno objašnjenje,
obratimo pažnju da lista senzitivnosti procesa sadrži samo signal takta. U kôd za D leč, za definisanje vrednosti
izlaza q koristi se naredba IF. Kada je clk=1, izlazu q se dodeljuje vrednost ulaza d. Međutim, kôd ne navodi
koju bi vrednost trebalo da dobije q za slučaj kada clk nije 1. Zbog toga, u tom slučaju, q će zadržati svoju
tekuću vrednost. Na taj način, proces opisuje ponašanje D leča sa dozvolom. Lista senzitivnosti procesa sadrži
oba ulazna signala, d i clk, pošto oba ova signala mogu direktno da uzrokuju promenu vrednosti izlaza q.

65
1 ----D flip-flop ------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY dff IS
6 PORT (d,clk : IN STD_LOGIC;
7 q : OUT STD_LOGIC);
8 END dff;
9 ---------------------------------------------
10 ARCHITECTURE flip_flop OF dff IS
11 BEGIN
12 PROCESS(clk)
13 BEGIN
14 IF(clk'EVENT AND clk='1') THEN
15 q <= d;
16 END IF;
17 END PROCESS;
18 END flip_flop;
19 ---------------------------------------------

1 ----D lec -----------------------------------

2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY dlec IS
6 PORT (d,clk : IN STD_LOGIC;
7 q : OUT STD_LOGIC);
8 END dlec;
9 ---------------------------------------------
10 ARCHITECTURE lec OF dlec IS
11 BEGIN
12 PROCESS(d,clk)
13 BEGIN
14 IF clk = '1' THEN
15 q <= d;
16 END IF;
17 END PROCESS;
18 END lec;
19 ---------------------------------------------

2.6 Signali i varijable

VHDL poseduje dva objekta za manipulaciju nestatičkim (tj. promenljivim) vrednostima: SIGNAL i
VARIABLE. Takođe, za definisanje statičkih (konstantnih) vrednosti na raspolaganju su dve konstrukcije:
CONSTANT i GENERIC. Konstrukcija GENERIC razmatrana je u sekciji 2.3.5. U ovom poglavlju, podrobnije
će biti razmatrani signali, varijable i konstante.
Konstante i signali mogu biti globalni (vidljivi u celokupnom projektu) i mogu se koristiti kako u
sekvencijalnom tako i u konkurentnom kôdu. Sa druge strane, varijable su uvek lokalne i mogu se koristiti samo
u sekvencijalnom kôdu (tj. u procesu, funkciji ili proceduri). Takođe, vrednost varijable se ne može direktno
preneti izvan modula u kome je deklarisana. Izbor između signala i varijable nije uvek lak. Zbog toga je jedno
celo poglavlje posvećeno ovoj materiji.

2.6.1 CONSTANT
Sintaksa konstrukcije CONSTANT definiše ime, tip i vrednost konstante:
CONSTANT ime : tip := vrednost;
Konstanta može da ima samo jednu vrednost datog tipa, koja joj se dodeljuje prilikom deklaracije i ne može se
menjati u ostalom delu kôda. Dugim rečima, nije dozvoljeno dodeljivati novu vrednost konstanti.
Primeri:
CONSTANT b : BIT :=´1´; -- jednobitna konstanta vrednosti ´1´
CONSTANT mem : memory := ((´0´,´0´,´0´,´0´), -- matrica konstantnih vrednosti
(´0´,´0´,´0´,´1´),
(´0´,´0´,´1´,´1´));

66
Konstanta može biti deklarisana u paketu, entitetu ili arhitekturi. Kada je deklarisana u paketu, konstanta je
globalna za sve entitete koji koriste paket. Deklarisana u entitetu, konstanta je globalna za sve arhitekture tog
entiteta. Konačno, konstanta deklarisana u arhitekturi vidljiva je jedino u kôdu te arhitekture. Konstante se
najčešće deklarišu u arhitekturi ili paketu.

2.6.2 SIGNAL
Signali se koriste za prenos vrednosti u ili iz kola, kao i između različitih internih jedinica kola. Drugim rečima,
signal predstavlja vezu (žicu) u kolu. Na primer, portovi entiteta su signali. Signal se deklariše shodno sledećoj
sintaksi:
SIGNAL ime : tip [opseg] [: inicijalna_vrednost];
Primeri:
SIGNAL ctrl : BIT := ‘0’;
SIGNAL count : INTEGER RANGE 0 TO 100;
SIGNAL y : STD_LOGIC_VECTOR(7 DOWNTO 0);
Signali mogu biti deklarisani na istim mestima u kôdu gde i konstante. Slično konstantama, signalima se
prilikom deklaracije može dodeliti inicijalna vrednost. Inicijalna vrednost signala ima efekta samo u simulaciji,
dok se prilikom sinteze ne uzima u obzir. Za razliku od konstanti, signalima mogu da se dodeljuju nove
vrednosti (slično promenljivama u programskim jezicima). Operacija dodele nove vrednosti signalu označava se
(kao što već znamo) simbolom “<=” (npr. x<=5) Međutim, kada se koristi u sekvencijalnom kôdu, vrednost
signala se ne menja u trenutku izvršenja naredbe dodele, već u trenutku završetka odgovarajućeg procesa,
funkcije ili procedure. Kažemo da za signale važi odložena dodela. Istom signalu nova vrednost može biti
dodeljivana više puta u okviru istog procesa. Međutim, efekat će imati samo poslednja naredba dodele.
Pr. 2-42 Brojač jedinica (pogrešno rešenje)
Naš zadatak je da projektujemo kolo koje određuje broj 1-ca u binarnom vektoru. Razmotrimo priloženo
rešenje. Za brojanje jedinica u procesu se koristi signal brojac tipa INTEGER, koji se na početku procesa
postavlja na vrednost 0, a zatim u FOR/LOOP petlji uvećava za 1 za svaku jedinicu iz ulaznog vektora d. Kôd,
iako naizgled korektan (jer ispravno prati logiku algoritma brojanja jedinica), predstavlja pogrešno rešenje.
Problem je u višestrukoj dodeli vrednosti istom signalu (u liniji 15, jedanput i liniji 18, osam puta). Sve dodele
vrednosti signalu učinjene u procesu odlažu se do trenutka završetka procesa. To znači da početna vrednost
signala brojac u liniji 18 nije 0, već vrednost koju je taj signal imao u trenutku aktiviranja procesa. U ovakvim i
sličnim situacijama treba umesto signala koristiti varijable.
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY brojac_jedinica IS
6 PORT (din : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
7 br_jedinica : OUT INTEGER RANGE 0 TO 8);
8 END brojac_jedinica;
9 ---------------------------------------------
10 ARCHITECTURE neispravna OF brojac_jedinica IS
11 SIGNAL brojac : INTEGER RANGE 0 TO 8;
12 BEGIN
13 PROCESS(din)
14 BEGIN
15 brojac <= 0;
16 FOR i IN 0 TO 7 LOOP
17 IF(din(i)='1') THEN
18 brojac <= brojac + 1;
19 END IF;
20 END LOOP;
21 br_jedinica <= brojac;
22 END PROCESS;
23 END neispravna;
24---------------------------------------------
Takođe, čini se da je datom VHDL kôdu interni signal brojac (linija 11) nepotreban, jer bi za izračunavanje u
procesu mogao direktno da se koristi signal (port) br_jedinica. Međutim, br_jedinica, iako signal, deklarisan je
kao izlazni (OUT) port. Zbog toga je zabranjeno čitati njegovu vrednost, što bi dovelo do greške u liniji 18.
Korišćenje pomoćnih signala (kao što je brojac) za izračunavanje konačne vrednosti koja se prenosi na izlazni
port predstavlja uobičajenu praksu.

67
2.6.3 VARIABLE
Za razliku od signala i konstanti, varijable se mogu koristiti samo u okviru sekvencijalnih delova kôda (procesi,
procedure i funkcije). Takođe, za razliku od signala, naredba dodele trenutno deluje na varijablu, a njena nova
vrednost se može koristiti već u sledećoj naredbi. Za deklaraciju varijable koristi se sintaksa:
VARIABLE ime : tip [opseg] [:= inicijalna_vrednost];
Primeri:
VARIABLE ctrl : BIT := ‘0’; -- jednobitna varijabla inicijalizovana na vrednost 0
VARIABLE count : INTEGER RANGE 0 TO 100; -- integer varijabla
VARIABLE y : STD_LOGIC_VECTOR(7 DOWNTO 0) := “11001010”; -- vektor sa inicijalizac.
Pošto se može koristiti samo u sekvencijalnom kôdu, deklaracija varijable se može naći isključivo u
deklarativnim sekcijama procesa, procedura i funkcija. Operator dodele za varijable je ˝:=˝ (npr. x:=5;).
Takođe, slično kao u slučaju signala, inicijalna vrednost varijable ima efekta samo u simulaciji, dok se tokom
sinteze ignoriše.
Pr. 2-43. Brojač jedinica (ispravno rešenje)
Razmotrimo još jednom problem iz Pr. 2-42. U novom rešenju, promenljiva brojac više nije signal već varijabla
definisana u procesu. S obzirom da je promena vrednosti varijable trenutna, problem višestruke dodele,
karakterističan za signale, više ne postoji.
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY brojac_jedinica IS
6 PORT (din : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
7 br_jedinica : OUT INTEGER RANGE 0 TO 8);
8 END brojac_jedinica;
9 ---------------------------------------------
10 ARCHITECTURE ispravna OF brojac_jedinica IS
11 BEGIN
12 PROCESS(din)
13 VARIABLE brojac : INTEGER RANGE 0 TO 8;
14 BEGIN
15 brojac := 0;
16 FOR i IN 0 TO 7 LOOP
17 IF(din(i)='1') THEN
18 brojac := brojac + 1;
19 END IF;
20 END LOOP;
21 br_jedinica <= brojac;
22 END PROCESS;
23 END ispravna;
24 ---------------------------------------------

2.6.4 Poređenje signala i varijabli

Glavne razlike između signala i varijabli, navedene su u tabeli T. 2-1.
T. 2-1 Signali i varijable.
SIGNAL VARIABLE
Operator dodele <= :=
Upotreba Povezivanje entiteta i komponenti Predstavlja lokalne promenljive
Opseg važenja Može biti globalan Isključivo lokalna (vidljiva samo unutar
procesa, procedure ili funkcije)
Ponašanje Promena vrednosti nije trenutna (nova vrednost nije Promena vrednosti je trenutna (nova vrednost
raspoloživa sve do završetka procesa, funkcije ili se može koristiti sledećoj naredbi)
procedure)
Koristi se u Paketu, entitetu i arhitekturi. U entitetu, svi portovi su Isključivo u sekvencijalnom kôdu.
signali.

68
Pr. 2-44 D flip-flop sa komplementarnim izlazima
Razmotrimo D flip-flop sa Sl. 2-36, koji za razliku od ranije razmatranih flip-flopova poseduje dodatni izlaz
not_q, na koji se javlja komplement tekućeg stanja flip-flopa. U nastavku su data dva rešenja, od kojih je prvo
neispravno, a drugo ispravno.
d q
D FF
clk not_q

Sl. 2-36 D flip-flop sa komplementarnim izlazima.

1 -----Resenje 1: neispravno ------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY dff IS
6 PORT (d,clk : IN STD_LOGIC;
7 q : BUFFER STD_LOGIC;
8 not_q : OUT STD_LOGIC);
9 END dff;
10---------------------------------------------
11 ARCHITECTURE neispravna OF dff IS
12 BEGIN
13 PROCESS(clk)
14 BEGIN
15 IF(clk'EVENT AND clk='1') THEN
16 q <= d;
17 not_q <= NOT q;
18 END IF;
19 END PROCESS;
20 END neispravna;
21---------------------------------------------

1 -----Resenje 2: ispravno --------------------

2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY dff IS
6 PORT (d,clk : IN STD_LOGIC;
7 q : BUFFER STD_LOGIC;
8 not_q : OUT STD_LOGIC);
9 END dff;
10---------------------------------------------
11 ARCHITECTURE ispravna OF dff IS
12 BEGIN
13 PROCESS(clk)
14 BEGIN
15 IF(clk'EVENT AND clk='1') THEN
16 q <= d;
17 END IF;
18 END PROCESS;
19 not_q <= NOT q;
20 END ispravna;
21---------------------------------------------

Dva rešenja se razlikuju po mestu gde se u kôdu nalazi naredba dodele not_q <= NOT q. U prvom rešenju,
ova naredba je u procesu i izvršava se neposredno posle naredbe q <= d (linije 16 i 17). Međutim, s obzirom na
odloženu dodelu, vrednost signala q koja se u liniji 17 komplementira i dodeljuje signalu not_q, nije ona koja je
dodeljena ovom signalu u naredbi 16, već stara, tj. ona koju je signal q imao u trenutku aktiviranja procesa. Na
taj način, izlaz not_q dobija pogrešnu vrednost koja u odnosu na ispravnu kasni za jedan taktni ciklus, kao što se
može uočiti na vremenskom dijagramu sa Sl. 2-37. Takođe, primetimo da talasni oblici signala q i not_q počinju
isprekidanim linijama. Na ovaj način je označena nepoznata vrednost (˝X˝). To je iz razloga što ovi signali nisu
inicijalizovani prilikom deklaracije, a definisanu vrednost dobijaju upisom koji je sinhronizovan sa rastućom
ivicom signala clk.

69
 Sl. 2-37 Rezultati simulacije neispravnog rešenja iz Pr. 2-44.
U drugom rešenju, naredba not_q <= NOT q se nalazi u liniji 19 izvan procesa. S obzirom da naredba dodele
signalu not_q i proces rade konkurentno, svaka promena vrednosti signala q učinjena u procesu se trenutno
manifestuje na promenu signala not_q. Rezultati simulacije (Sl. 2-38) pokazuju očekivano, ispravno ponašanje
flip-flopa. Uočimo još jednu pojedinost: port q deklarisan je kao BUFFER, ne kao OUT. Deklaracija BUFFER
označava bidirekcioni (dvosmerni) port, tj. port na koji može da se upisuje i koji može da se čita. Da je port q
deklarisan kao OUT, naredba not_q <= NOT q ne bi bila moguća, s obzirom da čita vrednost porta q.

Sl. 2-38 Rezultati simulacije ispravnog rešenja iz Pr. 2-44.

2.6.5 Sinteza registara

U ovom odeljku biće razmatrano kada i pod kojim uslovima se signali i varijable sintetišu u registre (flip-
flopove). Signal se sintetiše u flip-flop ako je dodela vrednosti tom signalu uslovljena tranzicijom nekog drugog
signala. Takve naredbe dodele se nazivaju sinhronim naredbama dodele i mogu se javiti samo u sekvencijalnom
kôdu, obično nakon konstrukcija tipa: ˝IF signal´EVENT …˝ ili ˝WAIT UNTIL …˝. Na primer, na Sl. 2-39 je
prikazano kolo koga čine dva flip-flopa i odgovarajući VHDL kôd koji sadrži dve sinhrone naredbe dodele.
Dodele vrednosti signalima out1 i out2 su sinhronizovane sa rastućom ivicom signala clk. Zbog toga u
sintetizovanom kolu postoje dva flip-flopa: jedan pamti vrednost signala out1, a drugi signala out2. Sa druge
strane, dodela vrednosti signalu out3 nije sinhronizovana sa signalom clk i zato se ovaj signal sintetiše u prostu
vezu.
b out1
PROCESS(clk,a)
D FF
BEGIN
IF(clk’EVENT AND clk=’1’)THEN
out1 <= v;
a out2 out2 <= a;
D FF END IF;
clk out3 <= a;
END PROCESS;
out3
(a) (b)
Sl. 2-39 Primer sinteze registara: (a) sintetizovano kolo; (b) VHDL kôd.
Uslovi pod kojima se varijabla sintetiše u flip-flop nešto su složeniji. Prvo, kao i kod signala, potrebno je da
dodela vrednosti varijabli bude uslovljena tranzicijom nekog drugog signala. Dugo, potrebno je da se vrednost
varijable, putem dodele nekom signalu, prenosi izvan procesa (procedure ili funkcije). Na primer, varijabla v iz
sledećeg VHDL kôda, se sintetiše u flip-flop (x je signal):
PROCESS(clk)
VARIABLE v : BIT;
BEGIN
IF(clk’EVENT AND clk=’1’)THEN
v := a;
END IF;
x <= v;
END PROCESS;

70
Oba navedena uslova su ispunjena: dodela vrednosti varijabli v je sinhronizovana sa rastućom ivicom signala clk
i njena vrednost se dodeljuje signalu x.
Drugi slučaj kada se varijabla sintetiše u flip-flop odgovara situaciji kada se varijabla koristi u kôdu pre nego što
joj je dodeljena vrednost (vidi Pr. 2-47).
Pr. 2-45 D flip-flop sa komplementarnim izlazima (rešenje 2)
Razmotrimo još jedanput D flip-flop sa Sl. 2-36. Iako su oba rešenja, data u ovom primeru, funkcionalno
ispravna, kola dobijena njihovom sintezom se razlikuju, i to po broju flip-flopova. Rešenje 1 sadrži dve sinhrone
naredbe dodele (linije 16 i 17) i zbog toga generiše dva flip-flopa ( Sl. 2-40(a)). U rešenju 2, naredba dodele
signalu not_q (linija 19) više nije sinhronizovana sa taktnim signalom clk i zato se ne sintetiše u flip-flop (Sl.
2-40(b)). Napomenimo da ovaj primer ilustruje bitnu situaciju kada zbog propusta u organizaciji VHDL kôda
dolazi do sinteze dodatnog hardvera.
d q
D FF

not_q d q
D FF D FF not_q
clk clk

(a) (b)
Sl. 2-40 Kola sintetizovana na osnovu VHDL kôda iz Pr. 2-45.
1 ----Resenje 1: dva flip-flopa ---------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY dff IS
6 PORT (d,clk : IN STD_LOGIC;
7 q : BUFFER STD_LOGIC;
8 not_q : OUT STD_LOGIC);
9 END dff;
10---------------------------------------------
11 ARCHITECTURE dva_FF OF dff IS
12 BEGIN
13 PROCESS(clk)
14 BEGIN
15 IF(clk'EVENT AND clk='1') THEN
16 q <= d; -- generise flip-flop
17 not_q <= NOT d; -- generise flip-flop
18 END IF;
19 END PROCESS;
20 END dva_FF;
21---------------------------------------------

1 ----Resenje 2: jedan flip-flop --------------

2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY dff IS
6 PORT (d,clk : IN STD_LOGIC;
7 q : BUFFER STD_LOGIC;
8 not_q : OUT STD_LOGIC);
9 END dff;
10---------------------------------------------
11 ARCHITECTURE jedan_FF OF dff IS
12 BEGIN
13 PROCESS(clk)
14 BEGIN
15 IF(clk'EVENT AND clk='1') THEN
16 q <= d; -- generise flip-flop
17 END IF;
18 END PROCESS;
19 not_q <= NOT d; -- generiše logičko kolo, a ne flip-flop
20 END jedan_FF;

71
Pr. 2-46 Brojač
Razmotrimo 3-bitni binarni brojač sa Sl. 2-41. Stanja brojača su: 0, 1, ..., 7. Sa svakim taktnim impulsom, brojač
prelazi u sledeće stanje, a nakon stanja 7 vraća se u stanje 0. Signal rst služi za asinhrono resetovanje brojača.

Sl. 2-41 3-bitni binarni brojač

Ispod su data dva VHDL opisa brojača sa Sl. 2-41. U prvom rešenju koristi se vrijabla var za realizaciju funkcije
brojanja. Drugo rešenje sadrži samo signale. Sintezom oba kôda dobija se kolo koje sadrži 3 flip-flopa, za
čuvanje vrednosti 3-bitnog signala count. Rešenje 1 predstavlja primer kako se varijabla sintetiše u flip-flop.
Razlog za to su linije 15 i 17: u liniji 15 varijabli var se dodeljuje vrednost sinhronizovano sa rastućom ivicom
signala clk; a u liniji 17 vrednost varijable var se prenosi signalu count i na taj način iznosi iz procesa.
Rešenje 2 koristi samo signale. Pošto nije uveden pomoćni signal, već se u procesu direktno koristi port (signal)
count, u liniji 14, ovaj port je deklarisan kao BUFFER. Uočimo da data rešenja ne sadrže deklaraciju paketa
std_logic_1164. Ovaj paket nije potreban s obzirom da se kôdu ne koristi tip std_logic.
1 -----Resenje 1: sa varijablama ---------------
2 ENTITY brojac IS
3 PORT (clk,rst : IN BIT;
4 count : OUT INTEGER RANGE 0 TO 7);
5 END brojac;
6 ---------------------------------------------
7 ARCHITECTURE brojac OF brojac IS
8 BEGIN
9 PROCESS(clk, rst)
10 VARIABLE var : INTEGER RANGE 0 TO 7;
11 BEGIN
12 IF(rst='1') THEN
13 var := 0;
14 ELSIF(clk'EVENT AND clk='1') THEN
15 var := var + 1;
16 END IF;
17 count <= var;
18 END PROCESS;
19 END brojac;
20---------------------------------------------
1 -----Resenje 2: sa signalima ---------------
2 ENTITY brojac IS
3 PORT (clk,rst : IN BIT;
4 count : BUFFER INTEGER RANGE 0 TO 7);
5 END brojac;
6 ---------------------------------------------
7 ARCHITECTURE brojac OF brojac IS
8 BEGIN
9 PROCESS(clk, rst)
10 BEGIN
11 IF(rst='1') THEN
12 count <= 0;
13 ELSIF(clk'EVENT AND clk='1') THEN
14 count <= count + 1;
15 END IF;
16 END PROCESS;
17 END brojac;
18 ---------------------------------------------
Pr. 2-47 Pomerački registar (varijanta 1)
U ovom primeru razmotrićemo tri VHDL opisa napisana s namerom da modeliraju pomerački registar sa Sl.
2-42. Rešenja 1 i 2 se ispravno sintetišu u strukturu sa Sl. 2-42. Rešenje 3 se sintetiše u kolo koje umesto četiri
sadrži samo jedan flip-flop.

72
 Sl. 2-42 Pomerački registar iz Pr. 2-47
1 ------- Resenje 1 ----------------------------
2 ENTITY pomreg IS
3 PORT (din,clk : IN BIT;
4 dout: OUT BIT);
5 END pomreg;
6 ----------------------------------------------
7 ARCHITECTURE pomreg OF pomreg IS
8 BEGIN
9 PROCESS (clk)
10 VARIABLE a,b,c : BIT;
11 BEGIN
12 IF(clk'EVENT AND clk='1') THEN
13 dout <= c;
14 c := b;
15 b := a;
16 a := din;
17 END IF;
18 END PROCESS;
19 END pomreg;
20 ---------------------------------------------
1 ------- Resenje 2 ----------------------------
2 ENTITY pomreg IS
3 PORT (din,clk : IN BIT;
4 dout: OUT BIT);
5 END pomreg;
6 ----------------------------------------------
7 ARCHITECTURE pomreg OF pomreg IS
8 SIGNAL a,b,c : BIT;
9 BEGIN
10 PROCESS (clk)
11 BEGIN
12 IF(clk'EVENT AND clk='1') THEN
13 a <= din;
14 b <= a;
15 c <= b;
16 dout <= c;
17 END IF;
18 END PROCESS;
19 END pomreg;
20---------------------------------------------
1 ------- Resenje 3 ----------------------------
2 ENTITY pomreg IS
3 PORT (din,clk : IN BIT;
4 dout: OUT BIT);
5 END pomreg;
6 ----------------------------------------------
7 ARCHITECTURE pomreg OF pomreg IS
8 BEGIN
9 PROCESS (clk)
10 VARIABLE a,b,c : BIT;
11 BEGIN
12 IF(clk'EVENT AND clk='1') THEN
13 a := din;
14 b := a;
15 c := b;
16 dout <= c;
17 END IF;
18 END PROCESS;
19 END pomreg;
20---------------------------------------------

73
VHDL kôd iz rešenja 1 sadrži tri varijable (a, b i c, linija 10). Međutim, u procesu, varijable se koriste pre nego
što su im dodeljene vrednosti (tj. u obrnutom redosledu, počev dout, linija 13, do din, linija 16). Na primer, u
liniji 13 na izlaz dout prosleđuje se vrednost varijable c. Međutim, to nije vrednost koja će ovoj varijabli biti
dodeljena u narednoj liniji, već vrednost koja joj je bila dodeljena prilikom prethodnog izvršenja procesa. Zbog
toga se u sintetizovano kolo uključuju flip-flopovi koji pamte vrednosti varijabli kako bi one mogle biti
korišćene prilikom narednog izvršenja procesa.
U rešenju 2 varijable su zamenjene signalima (linija 8), a dodela vrednosti signalima obavlja se u normalnom
redosledu (do din do dout). Pošto je dodela vrednosti signalima sinhronizovana sa tranzicijom nekog drugog
signala (konkretno clk), svaki od njih se sintetiše u flip-flop. S obzirom da za signale važi odložena dodela, u
linijama 14, 15 i 16 se koriste njihove stare vrednosti (one koje su im bile dodeljene prilikom prethodnog
izvršenja procesa). Još jedna posledica odložene dodele je i ta da redosled naredbi dodele u linijama 13, 14, 15 i
16, nije od značaja i da bi bilo koji drugi redosled, uključujući i onaj iz rešenja 1, bio korektan.
Konačno, u rešenju 3 ponovo se koriste varijable, kao u rešenju 1, ali je redosled naredbi dodele normalan, kao u
rešenju 2. S obzirom da za varijable važi trenutna dodela, naredbe dodele iz linija 13, 14 i 15 mogu da se sažmu
u jednu liniju ekvivalentnu naredbi c:=din. U sledećoj liniji (linija 16) vrednost varijable c napušta proces, jer
se dodeljuje signalu dout. Pošto se ova dodela obavlja sinhronizovano sa tranzicijom signala clk, uslovi za
sintezu flip-flopa su ispunjeni, ali samo jednog, a ne četiri koliko je potrebno da bi se dobilo ispravno rešenje.

Sl. 2-43 Pomerački registar iz Pr. 2-48.

Pr. 2-48 Pomerački registar (varijanta 2)
U ovom primeru biće predstavljena dva standardna načina za opis pomeračkog registra. Razmotrićemo registar
sa Sl. 2-43, koji u odnosu na onaj iz Pr. 2-47 dodatno poseduje mogućnost asinhronog resetovanja (ulaz rst).
Prvo rešenje koristi signale, a drugo varijable. Sintetizovana kola su ista u oba slučaja i odgovaraju strukturi sa
Sl. 2-43. U rešenju 1, registri se kreiraju zato što se dodela vrednosti signalu reg obavlja sinhronizovano sa
tranzicijom drugog signala (linije 17-18). U rešenju 2, tranzicija signala clk inicira upis u varijablu reg (linije 17
i 18), ali pošto vrednost ove varijable napušta proces (tj. prenosi se na port q) (linija 20) ona se takođe sintetiše u
registar. Za realizaciju funkcije pomeranja, u oba rešenja, koristi se naredba konkatenacije (vidi Pr. 2-16).
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------
5 ENTITY pomreg IS
6 PORT ( d,clk,rst: IN STD_LOGIC;
7 q: OUT STD_LOGIC);
8 END pomreg;
9 ----------------------------------------------
10 ARCHITECTURE RTL OF pomreg IS
11 SIGNAL reg : STD_LOGIC_VECTOR(3 DOWNTO 0);
12 BEGIN
13 PROCESS (clk, rst)
14 BEGIN
15 IF(rst='1') THEN
16 reg <= (OTHERS => '0');
17 ELSIF(clk'EVENT AND clk='1') THEN
18 reg <= d & reg(3 DOWNTO 1);
19 END IF;
20 END PROCESS;
21 q <= reg(0);
22 END RTL;
23---------------------------------------------

1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;

74
4 ----------------------------------------------
5 ENTITY pomreg IS
6 PORT ( d,clk,rst: IN STD_LOGIC;
7 q: OUT STD_LOGIC);
8 END pomreg;
9 ----------------------------------------------
10 ARCHITECTURE RTL OF pomreg IS
11 BEGIN
12 PROCESS (clk, rst)
13 VARIABLE reg : STD_LOGIC_VECTOR(3 DOWNTO 0);
14 BEGIN
15 IF(rst='1') THEN
16 reg := (OTHERS => '0');
17 ELSIF(clk'EVENT AND clk='1') THEN
18 reg := d & reg(3 DOWNTO 1);
19 END IF;
20 q <= reg(0);
21 END PROCESS;
22 END RTL;
23 ---------------------------------------------

2.7 Konačni automati

Konačni automati (prema eng. Finite State Machine – FSM) predstavljaju najznačajniju tehniku za modeliranje
sekvencijalnih kola, koja je naročito pogodna za projektovanje pojedinih tipova digitalnih sistema čije se
ponašanje može opisti precizno definisanom sekvencom aktivnosti. Tipičan primer su upravljačke jedinice.
Model konačnog automata zasnovan je na konceptu stanja i prelaza između stanja. U svakom trenutku, automat
je u jednom od konačnog broja svojih stanja. Pod dejstvom taktnog signala, a u zavisnosti od tekućeg stanja i
trenutne vrednosti ulaza, automat prelazi u novo stanje i generiše odgovarajuće izlaze. Konačni automat se može
predstaviti dijagramom (grafom) stanja (Sl. 2-44(a)). U ovom dijagramu, krugovima su predstavljena stanja, a
strelicama (granama) prelazi između stanja. Svaka grana je označena parom ulaz/izlaz i ukazuje na novo stanje u
koje će automat preći, kao i na vrednost koja će biti generisana na izlazu, pod uslovom da je na ulazu prisutna
navedena vrednost.
U cilju hardverske realizacije, stanja konačnog automata se kodiraju, tj. svakom stanju se dodeljuje jedinstveni
n-bitni kôd. Za čuvanje kôda tekućeg stanja koriste se flip-flopovi, a za generisane kôda novog stanja i izlaza
koristi se kombinaciona mreža. Uopšteni blok dijagram konačnog automata prikazan je na Sl. 2-44(b). U donjem
delu slike prikazana je sekvencijalna logika (flip-flopovi), a u gornjem kombinaciona logika. Kombinaciona
logika ima dva ulaza: pr_state (tekuće stanje) i ulaz (pravi ulazi konačnog automata) i dva izlaza: ns_state
(sledeće stanje) i izlaz (pravi izlazi konačnog automata). Sekvencijlani deo ima tri ulaza: clk (taktni signal), rst
(reset ulaz), ns_state (sledeće stanje) i jedan izlaz: pr_state (tekuće stanje). Sekvencijalni deo sadrži n flip-
flopova sa zajedničkim taktnim i reset signalom. Pod dejstvom reset signala, automat se postavlja u početno
(inicijalno) stanje. Svaka aktivna ivica taktnog signala inicira prelazak u novo stanje, tako što u flip-flopove
sekvencijalnog dela upisuje kôd sledećeg stanja (nx_state) koji tako postoje novo tekuće stanje (pr_state).

0/1 ulaz izlaz

Kombinaciona
stanje logika
S0 ulaz
1/1 izlaz
pr_state nx_state
1/0
1/0
1/0 Sekvencijalna
0/1 logika
S1 S2 (flip-flopovi) rst
0/1 clk
FSM
(a) (b)
Sl. 2-44 Model konačnog automata: (a) dijagram stanja; (b) hardverska struktura.
Podela kola na dva dela (Sl. 2-44(b)) omogućava da i VHDL opis konačnog automata takođe bude razložen na
dve sekcije. Iz perspektive VHDL-a, jasno je da će donji deo, s obzirom da je sekvencijalan, zahtevati proces,
dok gornji, kombinacioni, neće. Međutim, kako procesom može biti opisana ne samo sekvencijalna već i
kombinaciona logika, po pravilu, oba dela automata se opisuju pomoću zasebnih procesa.

75
2.7.1 Kôdni šablon #1
Za projektovanje konačnih automata u VHDL-u razvijeno više standardnih pristupa ili kôdnih šablona. U ovom
odeljku opisaćemo jedan od njih, koji se odlikuje jednostavnom strukturom. Kod opisnog kôdnog šablona,
sekvencijalni i kombinacioni deo automata su u potpunosti razdvojeni i predstavljaju se zasebnim procesima, a
stanja se eksplicitno deklarišu korišćenjem nabrojivog tipa podataka.
Sekvencijalni deo
Sekvencijalni deo konačnog automata u suštini predstavlja prihvatni registar sa ulazom nx_state i izlazom
pr_state i kao takav može se opisati u vidu sledećeg procesa:
PROCESS(rst,clk)
BEGIN
IF(rst=´1´)THEN
pr_state <= state_0;
ELSIF(clk’EVENT AND clk=’1’)THEN
pr_state <= nx_state;
END IF;
END PROCESS;
Kôd je veoma jednostavan. Sastoji se od asinhronog resetovanja, koje postavlja automat u početno stanje
(state_0), i sinhrone naredbe dodele koja se sintetiše u n flip-flopova za čuvanje kôda tekućeg stanja, pr_state.
Broj sintetizovanih flip-flopova određen je dužinom signala pr_state, tj. brojem bitova potrebnih za kôdiranje
svih stanja automata. Za automat sa N stanja, broj flip-flopova iznosi n = log 2 N  .

Kombinacioni deo
Kombinacioni deo konačnog automata predstavlja kombinacionu mrežu sa ulazima input i pr_state i izlazima
output i nx_state i može se opisati u vidu sledećeg procesa:
PROCESS(ulaz, pr_state)
BEGIN
CASE pr_state IS
WHEN state_0 =>
IF(ulaz = ...) THEN
izlaz <= <vrednost>
nx_state <= state_1;
ELSE ...
END IF;
WHEN state_1 =>
IF(ulaz = ...) THEN
izlaz <= <vrednost>
nx_state <= state_2;
ELSE ...
END IF;
WHEN state_2 =>
IF(ulaz = ...) THEN
izlaz <= <vrednost>
nx_state <= state_3;
ELSE ...
END IF;
. . .
END CASE;
END PROCESS;
Proces ima dve funkcije: (a) generiše izlazne vrednosti i (b) generiše kôd sledećeg stanja automata. Centralno
mesto kôda predstavlja CASE naredba u kojoj svaka WHEN grana odgovara jednom stanju automata (tekuće
stanje - pr_state). Za svako stanje, ispituje se vrednost ulaza, ulaz, i postavlja odgovarajuća vrednost izlaza, izlaz
i sledećeg stanja, nx_state. U suštini, CASE naredba predstavlja formalni opis dijagrama stanja: svakom stanju
(krugu) dijagrama stanja odgovara jedna WHEN grana, a svakoj strelici koja izvire iz datog stanja jedna IF
grana u odgovarajućoj WHEN grani. Proces se sintetiše u kombinacionu logiku, s obzirom da zadovoljava
uslove 1 i 2 iz odeljka: svi ulazni signali su navedeni u listi senzitivnosti i sve ulazno-izlazne kombinacije su
pokrivene kôdom.
Sledi kompletan kôdni šablon za opis konačnog automata. Pored dva procesa, šablon takođe sadrži korisnički
definisani tip podataka (state) koji sadrži simbolička imena svih stanja konačnog automata.

76
---------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
---------------------------------------------
ENTITY <ime_entiteta> IS
PORT (ulaz : IN <tip_podataka>;
rst,clk : IN STD_LOGIC;
izlaz : OUT <tip_podataka>);
END <ime_entiteta>;
---------------------------------------------
ARCHITECTURE <ime_arhitekture> OF <ime_entiteta> IS
TYPE state IS (state_0,state_1,state_2 ...);
SIGNAL pr_state,nx_state : state;
BEGIN
---------- Sekvencijalni deo -------------
PROCESS(rst,clk)
BEGIN
IF(rst='1') THEN
pr_state <= state_0;
ELSIF(clk'EVENT AND clk='1') THEN
pr_state <= nx_state;
END IF;
END PROCESS;
---------- Kombinacioni deo -------------
PROCESS(ulaz, pr_state)
BEGIN
CASE pr_state IS
WHEN state_0 =>
IF(ulaz = ...) THEN
izlaz <= <vrednost>
nx_state <= state_1;
ELSE ...
END IF;
WHEN state_1 =>
IF(ulaz = ...) THEN
izlaz <= <vrednost>
nx_state <= state_2;
ELSE ...
END IF;
WHEN state_2 =>
IF(ulaz = ...) THEN
izlaz <= <vrednost>
nx_state <= state_3;
ELSE ...
END IF;
. . .
END CASE;
END PROCESS;
END <ime_arhitekture>;

2.7.2 Konačni automati Murovog tipa

Ako izlaz automata zavisi jedino od tekućeg stanja, takav automat se naziva konačnim automatom Murovog
tipa. Ako izlaz zavisi i od tekućeg stanja i od trenutnog ulaza, govorimo o automatu Milijevog tipa. U suštini,
Murov FSM je specijalni slučaj Milijevog FSM-a i obično se predstavlja nešto drugačijim dijagramom stanja u
odnosu na onaj sa Sl. 2-44(a). Primer dijagram stanja automata Murovog tipa prikazan je Sl. 2-45. Izlazne
vrednosti su sada pridružene stanjima i navedene u zagradama ispod imena stanja. Na strelicama su naznačeni
jedino uslovi (ulazi) koji iniciraju prelaz u odgovarajuće sledeće stanje.

Sl. 2-45 FSM iz primera Pr. 2-49.

Pr. 2-49 Jednostavna FSM (varijanta 1)
Na Sl. 2-45 su prikazani blok dijagram i dijagram stanja jednog jednostavnog konačnog automata Murovog tipa.
FSM ima tri ulaza (a, b i d), jedan izlaz (x) i dva stanja (stateA i stateB). Do promene stanja dolazi uvek kada je

77
d=1. Ako je d=0, FSM ostaje u tekućem stanju. U stanju stateA na izlaz se prenosi vrednost ulaza a (x=a), a u
stanju stateB vrednost ulaza b (x=b). Početno stanje konačnog automata je stanje stateA. Sledi VHDL opis
FSM-a sa Sl. 2-45 napisan u skladu sa kôdnim šablonom #1.
1 ----------------------------------------------
2 ENTITY fsm_1 IS
3 PORT (a,b,c,d,clk,rst : IN BIT;
4 x: OUT BIT);
5 END fsm_1;
6 ----------------------------------------------
7 ARCHITECTURE fsm_1 OF fsm_1 IS
8 TYPE state IS (stateA, stateB);
9 SIGNAL pr_state, nx_state : state;
10 BEGIN
11 ---- sekvencijalni deo --------------------
12 PROCESS (clk,rst)
13 BEGIN
14 IF(rst='1')THEN
15 pr_state <=stateA;
16 ELSIF(clk'EVENT AND clk='1') THEN
17 pr_state <= nx_state;
18 END IF;
19 END PROCESS;
20 ---- kombinacioni deo --------------------
21 PROCESS(a,b,d,pr_state)
22 BEGIN
23 CASE pr_state IS
24 WHEN stateA =>
25 x<=a;
26 IF(d='1')THEN
27 nx_state <= stateB;
28 ELSE
29 nx_state <= stateA;
30 END IF;
31 WHEN stateB =>
32 x<=b;
33 IF(d='1')THEN
34 nx_state <= stateA;
35 ELSE
36 nx_state <= stateB;
37 END IF;
38 END CASE;
39 END PROCESS;
40 END fsm_1;
41 ---------------------------------------------
Izveštaj koji se dobija nakon sinteze VHDL opisa FSM-a sa Sl. 2-45, pokazuje da kolo sadrži samo jedan flip-
flop. To je očekivan podatak, s obzirom da FSM ima dva stanja, za čije kôdiranje je dovoljan samo jedan bit.
Pr. 2-50 BCD brojač
Ponašanje bilo kog sekvencijalog kola može se opisati u vidu konačnog automata. Međutim, konačni automat ne
mora uvek biti i najbolji (najjednostavniji) način za modeliranje sekvencijalnih kola. To je obično slučaj sa
jednostavnim registarskim komponentama, kao što su brojači. U ovom primeru biće data dva VHDL opisa BCD
brojača. Prvo rešenje na brojač gleda kao na konačni automat Murovog tipa, dok drugo koristi osobinu brojača
da je sledeće stanje uvek za 1 veće od prethodnog.

Sl. 2-46 Dijagram stanja BCD brojača

78
Na Sl. 2-46 je prikazan dijagram stanja BCD brojača. Konačni automat poseduje 10 stanja povezanih u cikličnu
sekvencu. Svakom stanju je pridružena vrednost izlaza (Murov tip) koja odgovara jednoj BCD cifri. Početno
stanje brojača je stanje nula. VHDL kôd napisan u skladu sa kôdnim šablonom dat je ispod. Deklaracija
nabrojivog tipa podataka state nalazi se u linijama 11 i 12. Sekvencijalni deo konačnog automata opisan je
prvim procesom (linije 16-23), a kombinacioni drugim procesom (linije 25-59). Obimnost procesa za
kombinacioni deo potiče od zahteva da se svako stanje eksplicitno navede u CASE naredbi. Očigledno, ovakav
način opisa brojača biće složeniji što je broj stanja brojača veći.
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------
5 ENTITY BCD IS
6 PORT (clk,rst : IN STD_LOGIC;
7 count : OUT STD_LOGIC_VECTOR(3 DOWNTO 0));
8 END BCD;
9 ----------------------------------------------
10 ARCHITECTURE FSM OF BCD IS
11 TYPE state IS (nula, jedan, dva, tri, cetiri,
12 pet, sest, sedam, osam, devet);
13 SIGNAL pr_state, nx_state : state;
14 BEGIN
15 ---- sekvencijalni deo --------------------
16 PROCESS (clk,rst)
17 BEGIN
18 IF(rst='1')THEN
19 pr_state <=nula;
20 ELSIF(clk'EVENT AND clk='1') THEN
21 pr_state <= nx_state;
22 END IF;
23 END PROCESS;
24 ---- kombinacioni deo --------------------
25 PROCESS(pr_state)
26 BEGIN
27 CASE pr_state IS
28 WHEN nula =>
29 count <= "0000";
30 nx_state <= jedan;
31 WHEN jedan =>
32 count <= "0001";
33 nx_state <= dva;
34 WHEN dva =>
35 count <= "0010";
36 nx_state <= tri;
37 WHEN tri =>
38 count <= "0011";
39 nx_state <= cetiri;
40 WHEN cetiri =>
41 count <= "0100";
42 nx_state <= pet;
43 WHEN pet =>
44 count <= "0101";
45 nx_state <= sest;
46 WHEN sest =>
47 count <= "0110";
48 nx_state <= sedam;
49 WHEN sedam =>
50 count <= "0111";
51 nx_state <= osam;
52 WHEN osam =>
53 count <= "1000";
54 nx_state <= devet;
55 WHEN devet =>
56 count <= "1001";
57 nx_state <= nula;
58 END CASE;
59 END PROCESS;
60 END FSM;

79
Jednostavniji, i prirodniji, opisa brojača u VHDL-u je ilustrovan kôdom koji sledi. Kôd je sličan onome iz
primera koji opisuje 4-bitni binarni brojač jer za opis funkcije brojanja koristi naredbu aritmetičkog sabiranja.
Dodatno, u procesu je izdvojen slučaj kada je brojač u stanju 9 (reg=˝1001˝), da bi se brojanje vratilo na
početak. S obzirom da se koriste signali tipa STD_LOGIC, uključen je paket std_logic_unsigned, koji
omogućava izvođenje aritmetičkih operacija nad ovim tipom.
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE ieee.std_logic_unsigned.all;
5 ----------------------------------------------
6 ENTITY BCD IS
7 PORT (clk,rst : IN STD_LOGIC;
8 count : OUT STD_LOGIC_VECTOR(3 DOWNTO 0));
9 END BCD;
10----------------------------------------------
11 ARCHITECTURE counter OF BCD IS
12 SIGNAL reg : STD_LOGIC_VECTOR(3 downto 0);
13 BEGIN
14 PROCESS(clk,rst)
15 BEGIN
16 IF(rst='1') THEN
17 reg <= (OTHERS => '0');
18 ELSIF(clk'EVENT AND clk='1') THEN
19 IF(reg = "1001") THEN
20 reg <= "0000";
21 ELSE
22 reg <= reg + 1;
23 END IF;
24 END IF;
25 END PROCESS;
26 count <= reg;
27 END counter;
28 --------------------------------------------
Pr. 2-51 Detektor bit-oblika
Detektor bit-oblika je sekvencijalno kolo koje u ulaznoj binarnoj sekvenci prepoznaje neku konkretnu
podsekvencu (tj. bit-oblik). Neka je naš zadatak da projektujemo detektor bit-oblika ˝111˝, tj. kolo koje će na
svom izlazu generisati 1 uvek kada na ulazu dobije tri uzastopne jedinice. Preklapanje bit-oblika treba uzeti u
obzir; na primer, ako se na ulazu javi sekvenca ˝…0111110…˝ na izlazu detektora treba biti postavljena 1-ca u
tri uzastopna taktna ciklusa.

Sl. 2-47 Detektor bit-oblika ˝111˝.

Blok dijagram i dijagram stanja detektora bit-oblika prikazani su na Sl. 2-47. U svakom taktnom ciklusu na ulaz
d dovodi se novi bit ulazne sekvence. Kolo poseduje četiri stanja nazvana tako da ime stanja ukazuje na trenutni
broj detektovanih uzastopnih 1-ca. Radi se o konačnom automatu Murovog tipa kod koga izlaz q ima vrednost 1
u stanju tri (primljene su tri uzastopne 1-ce), a vrednost 0 u svim ostalim stanjima. Svaka nova 1-ca na ulazu d
vodi automat u sledeće stanje, sve do stanja tri, u koje kolo ostaje sve dok su na ulazu prisutne 1-ce. Pojava nule
na ulazu u bilo kom stanju, vraća automat u početno stanje nula.
U nastavku su data dva VHDL opisa detektora bit-oblika. Oba rešenja su napisana u skladu sa kôdnim
šablonom, a razlikuju se po načinu pisanja kôda kombinacionog procesa. U prvom rešenju, za svako stanje u
odgovarajućoj WHEN grani najpre se izlazu q dodeljuje vrednost, a zatim se u zavisnosti od ulaza d, određuje
sledeće stanje. Drugo rešenje je kompaktnije, jer koristi podrazumevane vrednosti za izlaz q i sledeće stanje,
nx_state. Na početku kombinacionog procesa, pre CASE naredbe, signalima q i nx_state dodeljene su

80
podrazumevane vrednosti ´0´ za q i nula za nx_state. U CASE naredbi signala q i nx_state se dodeljuje vrednost
samo ako se nova vrednost razlikuje od podrazumevane. Kao podrazumevane vrednosti izabrane su one koje se
najčešće dodeljuju signalima q i nx_state.
1 -----Resenje 1 -------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------
5 ENTITY detektor_bit_oblika IS
6 PORT (d,clk,rst : IN STD_LOGIC;
7 q: OUT STD_LOGIC);
8 END detektor_bit_oblika;
9 ----------------------------------------------
10 ARCHITECTURE FSM OF detektor_bit_oblika IS
11 TYPE state IS (nula, jedan, dva, tri);
12 SIGNAL pr_state, nx_state : state;
13 BEGIN
14 ---- sekvencijalni deo --------------------
15 PROCESS (clk,rst)
16 BEGIN
17 IF(rst='1')THEN
18 pr_state <=nula;
19 ELSIF(clk'EVENT AND clk='1') THEN
20 pr_state <= nx_state;
21 END IF;
22 END PROCESS;
23 ---- kombinacioni deo --------------------
24 PROCESS(d,pr_state)
25 BEGIN
26 CASE pr_state IS
27 WHEN nula =>
28 q<='0';
29 IF(d='1')THEN nx_state <= jedan;
30 ELSE nx_state <= nula;
31 END IF;
32 WHEN jedan =>
33 q<='0';
34 IF(d='1')THEN nx_state <= dva;
35 ELSE nx_state <= nula;
36 END IF;
37 WHEN dva =>
38 q<='0';
39 IF(d='1')THEN nx_state <= tri;
40 ELSE nx_state <= nula;
41 END IF;
42 WHEN tri =>
43 q<='1';
44 IF(d='0')THEN nx_state <= nula;
45 ELSE nx_state <= tri;
46 END IF;
47 END CASE;
48 END PROCESS;
49 END FSM;
50----------------------------------------------

1 -----Resenje 2 -------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------
5 ENTITY detektor_bit_oblika IS
6 PORT (d,clk,rst : IN STD_LOGIC;
7 q: OUT STD_LOGIC);
8 END detektor_bit_oblika;
9 ----------------------------------------------
10 ARCHITECTURE FSM OF detektor_bit_oblika IS
11 TYPE state IS (nula, jedan, dva, tri);
12 SIGNAL pr_state, nx_state : state;
13 BEGIN

81
14 ---- sekvencijalni deo --------------------
15 PROCESS (clk,rst)
16 BEGIN
17 IF(rst='1')THEN
18 pr_state <=nula;
19 ELSIF(clk'EVENT AND clk='1') THEN
20 pr_state <= nx_state;
21 END IF;
22 END PROCESS;
23 ---- kombinacioni deo --------------------
24 PROCESS(d,pr_state)
25 BEGIN
26 q<='0'; -- podrazumevane
27 nx_state <= nula; -- vrednosti
28 CASE pr_state IS
29 WHEN nula =>
30 IF(d='1')THEN nx_state <= jedan;
31 END IF;
32 WHEN jedan =>
33 IF(d='1')THEN nx_state <= dva;
34 END IF;
35 WHEN dva =>
36 IF(d='1')THEN nx_state <= tri;
37 END IF;
38 WHEN tri =>
39 q<='1';
40 IF(d='0')THEN nx_state <= nula;
41 END IF;
42 END CASE;
43 END PROCESS;
44 END FSM;
45----------------------------------------------

2.7.3 Konačni automati Milijevog tipa

Za razliku od konačnog automata Murovog tipa, kod koga izlaz zavisi isključivo od tekućeg stanja, kod
automata Milijeg tipa izlaz je u funkciji kako tekućeg stanja tako i trenutnog ulaza. Automati Milijevog tipa
predstavljaju se dijagramom stanja kod koga su izlazne vrednosti pridružene granama, kao u dijagramu sa Sl.
2-44.
Pr. 2-52 Automat za prodaju karata
Projektujemo upravljačku jedinicu automata za prodaju karata u gradskom autobusu. Cena karte je 15 din., a u
automat se ubacuju kovanice od 5 i 10 din. Kada iznos ubačenog novca postanje jednak ili veći od cene karte,
automat izdaje kartu i ako je potrebno vraća kusur. Na Sl. 2-48(a) je prikazan blok dijagram konačnog automata
koji se koristi kao upravljačka jedinica u jednom ovakvom uređaju. Osim upravljačke jedinice, uređaj poseduje i
elektromehanički sklop koji prihvata ubačene kovanice, izdaje kartu i vraća kusur. Pretpostavka je da ovaj sklop
generiše impulse trajanja jednog taktnog ciklusa za svaku ubačenu kovanicu od 5 din. (signal D5) i 10 din.
(signal D10). Takođe, elektromehanički sklop reaguje na impulse trajanja jednog taktnog ciklusa K i V tako što
izdaje kartu (signal K) ili vraća kusur od 5 din. (signal V).
D5D10 / K=0, V=0
rst
, V =1

S0
,V

D
=0

10
=1

/K
/K

=0

D5 K
=1

=1
,V

D
10

/K

,V
=0
D

/K

FSM
5

=0
/K
D

=0

D10 V
5

,V
D

=0

D5 / K=0, V=0 S5
S10

clk rst

D5D10 / K=0, V=0 D5D10 / K=0, V=0

(a) (b)
Sl. 2-48 Upravljačka jedinica automata za prodaju karata: (a) blok dijagram; (b) dijagram stanja.

82
Dijagram stanja konačnog automata prikazan je na Sl. 2-48(b). Svako stanje odgovara ukupnom iznosu ubačenog
novca: S0 je početno stanje, koje važi sve do ubacivanja prve kovanice (ubačeno 0 din.); S5 - ubačeno je 5 din. i
S10 - ubačeno je ukupno 10 din. Automat ostaje u zatečenom stanju sve dok su oba ulaza, D5 i D10, jednaki 0.
Ovaj uslov je označen logičkim izrazom D5D10 na petljama koje postoje u svakom stanju. Iz stanja S0 automat
prelazi u stanje S5 (S10), ako je kao prva ubačena kovanica od 5 din. (10 din.). Iz stanja S5, automat prelazi u
stanje S10, ako je kao druga ubačena kovanica od 5 din (uslov D5). Međutim, ako je u stanju S5 ubačena
kovanica od 10 din. (D10), ukupan iznos ubačenog novca postaje jednak ceni karte, automat se vraća u početno
stanje i aktivira signal K. Pošto nema potrebe za vraćanjem kusura, signal V ostaje neaktivan. U stanju S10
takođe su moguća dva ishoda, pri čemu oba rezultuju u izdavanju karte (K=1). Pri tome, ako je ubačena
kovanica od 5 din., kusur se ne vraća (V=0), a ako je ubačeno 10 din. kusur se vraća (V=1) jer je vrednost
ubačenog novca (20 din.) veća od cene karte (15 din.). Uočimo da se radi o konačnom automatu Milijevog tipa,
jer izlazi, K i V, zavise ne samo od tekućeg stanja, već i od trenutne vrednosti ulaza. U nastavku je dat
odgovarajući VHDL opis.
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------
5 ENTITY controller IS
6 PORT (D5,D10,clk,rst : IN STD_LOGIC;
7 K,V: OUT STD_LOGIC);
8 END controller;
9 ----------------------------------------------
10 ARCHITECTURE FSM OF controller IS
11 TYPE state IS (S0, S5, S10);
12 SIGNAL pr_state, nx_state : state;
13 BEGIN
14 ---- sekvencijalni deo --------------------
15 PROCESS (clk,rst)
16 BEGIN
17 IF(rst='1')THEN
18 pr_state <=S0;
19 ELSIF(clk'EVENT AND clk='1') THEN
20 pr_state <= nx_state;
21 END IF;
22 END PROCESS;
23 ---- kombinacioni deo --------------------
24 PROCESS(D5,D10,pr_state)
25 BEGIN
26 CASE pr_state IS
27 WHEN S0 =>
28 K<='0';V<='0';
29 IF(D5='1')THEN
30 nx_state <= S5;
31 ELSIF(D10='1') THEN
32 nx_state <= S10;
33 ELSE
34 nx_state<=S0;
35 END IF;
36 WHEN S5 =>
37 IF(D5='1')THEN
38 K<='0';V<='0';
39 nx_state <= S10;
40 ELSIF(D10='1') THEN
41 K<='1';V<='0';
42 nx_state <= S0;
43 ELSE
44 K<='0';V<='0';
45 nx_state<=S5;
46 END IF;
47 WHEN S10 =>
48 IF(D5='1')THEN
49 K<='1';V<='0';
50 nx_state <= S0;
51 ELSIF(D10='1') THEN
52 K<='1';V<='1';
53 nx_state <= S0;

83
54 ELSE
55 K<='0';V<='0';
56 nx_state <= S10;
57 END IF;
58 END CASE;
59 END PROCESS;
60 END FSM;
61----------------------------------------------

Sl. 2-49 Rezulati simulacije VHDL kôda iz Pr. 2-52

Kôd je usklađen sa kôdnim šablonom #1, a razlika u odnosu na opis konačnog automata Murovog tipa ogleda se
u tome što naredbe dodele vrednosti izlaznim signalima unutar WHEN grana nisu bezuslovne, već su deo IF
naredbe koja ispituje ulaze. Na Sl. 2-49 su prikazani rezultati simulacije datog VHDL kôda za slučaj kada se u
automat ubacuju redom: 5 din., 5 din. i 10 din. S obzirom da je ubačeno ukupno 20 din., automat vraća kusur.
Uočimo da impuls koji se javlja na signalu D10 trenutno postavlja izlazi V i K, dok se stanje automata menja tek
sa prvom narednom aktivnom ivicom takta (odlika konačnih automata Milijevog tipa).
Kompaktniji kôd za kombinacioni proces može se dobiti ako se uvedu podrazumevane vrednosti za sledeće
stanje, nx_state, i izlaze K i V:
1 - 22 identično kao u prethodnom kôdu
23 ---- kombinacioni deo --------------------
24 PROCESS(D5,D10,pr_state)
25 BEGIN
26 nx_state <= pr_state;
27 K<='0';V<='0';
28 CASE pr_state IS
29 WHEN S0 =>
30 IF(D5='1')THEN
31 nx_state <= S5;
32 ELSIF(D10='1') THEN
33 nx_state <= S10;
34 END IF;
35 WHEN S5 =>
36 IF(D5='1')THEN
37 nx_state <= S10;
38 ELSIF(D10='1') THEN
39 K<='1';
40 nx_state <= S0;
41 END IF;
42 WHEN S10 =>
43 IF(D5='1')THEN
44 K<='1';
45 nx_state <= S0;
46 ELSIF(D10='1') THEN
47 K<='1';V<='1';
48 nx_state <= S0;
49 END IF;
50 END CASE;
51 END PROCESS;
52 END FSM;
53----------------------------------------------

84
2.7.4 Kôdni šablon #2
Kod konačnih automata Murovog tipa, izlazi zavise isključivo od tekućeg stanja i formiraju se na osnovu
sadržaju flip-flopova. Zato se za izlaze ovog tipa kaže da su registarski ili sinhroni jer se mogu menjati samo u
trenucima promene sadržaja flip-flopova, tj. sinhronizovano sa aktivnom ivicom taktnog signala. Sa druge
strane, kod konačnih automata Milijevog tipa, izlazi zavise i od ulaza. To znači da se promene vrednosti ulaza
mogu direktno preneti na izlaz. Za izlaze ovog tipa kaže se da su asinhroni, jer se mogu promeniti u bilo kom
trenutku, nezavisno od taktnog signala. Međutim, često se nameće potreba da izlazni signali pojedinih modula u
nekom složenijem sistemu budu sinhroni, tj. da se mogu menjati isključivo u trenucima delovanja aktivne ivice
taktnog signala. Da bi se ovaj zahtev ispunio kod Milijeve FSM, potrebno je i na izlaze ugraditi flip-flopove ( Sl.
2-50).

Sl. 2-50 Milijeva FSM sa sinhronim izlazom.

Sledi modifikovani kôdni šablon #2 koji je usklađen sa strukturom sa Sl. 2-50:
---------------------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
---------------------------------------------
ENTITY <ime_entiteta> IS
PORT (ulaz : IN <tip_podataka>;
rst,clk : IN STD_LOGIC;
izlaz : OUT <tip_podataka>);
END <ime_entiteta>;
---------------------------------------------
ARCHITECTURE <ime_arhitekture> OF <ime_entiteta> IS
TYPE state IS (state_0,state_1,state_2 ...);
SIGNAL pr_state,nx_state : state;
SIGNAL temp : <tip_podataka>;
BEGIN
---------- Sekvencijalni deo -------------
PROCESS(rst,clk)
BEGIN
IF(rst='1') THEN
pr_state <= state_0;
ELSIF(clk'EVENT AND clk='1') THEN
izlaz <= temp;
pr_state <= nx_state;
END IF;
END PROCESS;
---------- Kombinacioni deo -------------
PROCESS(ulaz, pr_state)
BEGIN
CASE pr_state IS
WHEN state_0 =>
IF(ulaz = ...) THEN
temp <= <vrednost>
nx_state <= state_1;
ELSE ...
END IF;
WHEN state_1 =>
IF(ulaz = ...) THEN
temp <= <vrednost>
nx_state <= state_2;
ELSE ...
END IF;
WHEN state_2 =>
IF(ulaz = ...) THEN
temp <= <vrednost>
nx_state <= state_3;
ELSE ...
END IF;
. . .

85
 END CASE;
END PROCESS;
END <ime_arhitekture>;

Modifikacija se sastoji u uvođenju dodatnog signala (temp). U kombinacionom procesu signal temp se koristi za
izračunavanje vrednosti izlaza, dok se u registarskom procesu prenosi na izlaz. Naredba koja obavlja prenos
vrednosti signala temp na izlazni port je sinhronizovana sa taktnim signalom i zbog toga se sintetiše u registar.
Pr. 2-53 Automat za prodaju karata (varijanta 2)
U ovom primeru realizovana je sinhrona varijanta kontrolera automata za prodaju karata iz Pr. 2-52. Uvedena su
dva pomoćna signala temp_K i temp_V koji se u kombinacionom procesu koriste za izračunavanje vrednosti
izlaza. Na Sl. 2-51 su prikazani rezultati simulacije obavljene pod istim uslovima kao u Pr. 2-52. Uočimo da
zbog postojanja izlaznog registra, postavljanje izlaza kasni za jedan taktni ciklus u odnosu na prvobitnu,
asihinhronu varijantu kontrolera. U konkretnoj primeni, ovo kašnjenje nije od značaja, jer ne remeti funkciju
uređaja (za taktnu frekvenciju od 1MHz, unosi dodatno kašnjenje u izdavanju karte od 1us). Sa druge strane,
sinhroni kontroler je otporniji na eventualne sporadične, lažne impulse na ulazima D5 i D10, koji zbog izlaznog
registra, sada ne mogu direktno da se prenesu na izlaz.
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------
5 ENTITY controller IS
6 PORT (D5,D10,clk,rst : IN STD_LOGIC;
7 K,V: OUT STD_LOGIC);
8 END controller;
9 ----------------------------------------------
10 ARCHITECTURE FSM OF controller IS
11 TYPE state IS (S0, S5, S10);
12 SIGNAL pr_state, nx_state : state;
13 SIGNAL temp_K, temp_V : STD_LOGIC;
14 BEGIN
15 ---- sekvencijalni deo --------------------
16 PROCESS (clk,rst)
17 BEGIN
18 IF(rst='1')THEN
19 pr_state <=S0;
20 ELSIF(clk'EVENT AND clk='1') THEN
21 pr_state <= nx_state;
22 K <= temp_K; V <= temp_V;
23 END IF;
24 END PROCESS;
25 ---- kombinacioni deo --------------------
26 PROCESS(D5,D10,pr_state)
27 BEGIN
28 nx_state <= pr_state;
29 temp_K<='0';temp_V<='0';
30 CASE pr_state IS
31 WHEN S0 =>
32 IF(D5='1')THEN
33 nx_state <= S5;
34 ELSIF(D10='1') THEN
35 nx_state <= S10;
36 END IF;
37 WHEN S5 =>
38 IF(D5='1')THEN
39 nx_state <= S10;
40 ELSIF(D10='1') THEN
41 temp_K<='1';
42 nx_state <= S0;
43 END IF;
44 WHEN S10 =>
45 IF(D5='1')THEN
46 temp_K<='1';
47 nx_state <= S0;
48 ELSIF(D10='1') THEN
49 temp_K<='1';temp_V<='1';

86
50 nx_state <= S0;
51 END IF;
52 END CASE;
53 END PROCESS;
54 END FSM;
55 ----------------------------------------------

Sl. 2-51 Rezultati simulacije VHDL kôda iz Pr. 2-53

2.7.5 Kodiranje stanja

Kodiranje stanja predstavlja obavezan korak u procesu projektovanja konačnih automata. Cilj kodiranja je
pridruživanje binarnih kombinacija simboličkim stanjima (sadržanim u dijagramu stanja). Pri tome, osim
zahteva da svako stanje bude kodirano jedinstvenom binarnom kombinacijom, ne postoji neko drugo
ograničenje. Zbog toga, broj različitih mogućih kodiranja može biti veoma veliki. Na primer, konačni automat
sa četiri stanja S0, S1, S2 i S3 može se realizovati sa dva flip-flopa, koji bi sadržali vrednosti 00, 01, 10 ili 11. U
ovom slučaju, postoji 4!=24 mogućih kodiranja stanja, kao što je prikazano u sledećoj tabeli:
# S0 S1 S2 S3 # S0 S1 S2 S3 # S0 S1 S2 S3
1 00 01 10 11 9 01 10 00 11 17 10 11 00 01
2 00 01 11 10 10 01 10 11 00 18 10 11 01 00
3 00 10 01 11 11 01 11 00 10 19 11 00 01 10
4 00 10 11 01 12 01 11 10 00 20 11 00 10 01
5 00 11 00 10 13 10 00 01 11 21 11 01 00 10
6 00 11 10 01 14 10 00 11 01 22 11 01 10 00
7 01 00 10 11 15 10 01 00 11 23 11 10 00 01
8 01 00 11 10 16 10 01 11 00 24 11 10 01 00

Različita kodiranja nisu ravnopravna, jer promenom kodiranja dolazi i do promene funkcije kombinacione
logike, koja za jedno kodiranje može biti složenija, a za neko drugo jednostavnija. Nalaženje optimalnog koda,
pri kome je složenost kombinacione logike najmanja, predstavlja veoma težak problem.
Kodiranje stanja konačnog automata može se razložiti na dva potproblema. Prvi je izbor broja bita, n, koji će biti
korišćeni za kodiranje, a drugi pridruživanje n-bitnih kombinacija stanjima. Binarne šeme kodiranja koriste
minimalni broja bita za kodiranje, koji za konačni automat sa N stanja iznosi n = log 2 N  . (Na primer, za 4 stanja
potrebna su najmanje 2, a za 5 stanja 3 bita). Ovaj pristup garantuje da će broj flip-flopova biti najmanji mogući,
ali je zato kombinaciona logika nešto složenija. Druga strategija je onehot kodiranje gde je broj bita za kodiranje
jednak broju stanja (n=N). Svakom stanju se dodeljuje jedan bit iz N bitne binarne kombinacije koji kada je 1
ukazuje da je konačni automat u tom stanju. Onehot kodiranje zahteva veliki broj flip-flopova i zbog toga nije
praktično kod konačnih automata sa velikim brojem stanja, ali je zato, sa druge strane, kombinaciona logika
obično značajno jednostavnija i brža nego kod binarnog kodiranja. Onehot kodiranje se preporučuje u
slučajevima kada je broj stanja relativno mali, a za implementaciju se koristi tehnologija koja je ˝bogata˝ flip-
flopovima, kao što je FPGA. Naravno, moguća su i rešenja gde je broj bita između ova dve krajnje vrednosti.
Nakon što je izabran broj bita za kodiranje, potrebno je svakom stanju pridružiti jedinstvenu n-bitnu
kombinacije. Umesto eksplicitnog ispitivanja velikog broja alternativnih pridruživanja, obično se koriste neka
od standardnih strategija ili heuristika kodiranja, koje ne garantuju dobijanje optimalnog rešenja, ali u najvećem
broju slučajeva daju rešenje koje je blisko optimalnom. Na primer, heuristika minimalne promene bitova
dodeljuje binarne kombinacije stanjima na takav način da je broj bita koji se menja prilikom promene stanja
minimalan. Na primer, ako u dijagramu stanja postoji prelaz iz stanja S0 u S1, tada je kodiranja koje stanju S0
dodeljuje kombinaciju 000, a stanju S1 001, bolje od onoga koje stanju S0 dodeljuje 000, a stanju S1 111. U
prvom slučaju zadatak kombinacione logike je jednostavniji jer treba da promeni samo jedan, a ne sva tri bita
kao u drugom slučaju. Uočimo da je kod onehot kodiranja, uslov minimalne promene bita uvek ispunjen.

87
Napomenimo da CAD sistemi za sintezu, po pravilu, poseduju mogućnost automatskog kodiranja stanja
konačnog automata. Sa takvim alatom na raspolaganju, projektant ima mogućnost da isključi ovu opciju i
kodiranje obavi ručno, ili da zadatak kodiranja stanja prepusti alatu, pri čemu bira jednu od raspoloživih
heuristika kodiranja.
U svim prethodnim primerima VHDL opisa konačnih automata, stanja su kodirana na simbolički način pomoću
nabrojivog tipa podataka koji definiše imena stanja, ali ne i njihove kodove. Ovakav stil kodiranja se oslanja na
podršku alata za sintezu koji će prilikom kompajliranja VHDL kôda, simbolička imena stanja zameniti binarnim
kombinacijama u skladu sa izabranom heuristikom kodiranja. Način na koji se u VHDL-u specificira heuristika
kodiranja zavisi od CAD alata koji se koristi za sintezu. Na primer u CAD sistemu ISE koji se koristi za
projektovanje za Xilinx FPGA, heuristika kodiranja stanja se specificira pomoću atributa koji se pridružuje
nabrojivom tipu podataka za stanja, a čija vrednost definiše heuristiku kodiranja. Atribut se definiše u
deklarativnom delu arhitekture nakon deklaracije nabrojivog tipa:
. . .
ARCHITECTURE <ime_arhitekture> OF <ime_entiteta> IS
TYPE state IS (state_0,state_1,state_2 ...);
attribute fsm_encoding : string;
attribute fsm_encoding of state is “gray”
SIGNAL pr_state,nx_state : state;
BEGIN
. . .

Prva od dve linije kôda posvećenih specifikaciji heuristike kodiranja stanja deklariše atribut imena
fsm_enciding, a druga pridružuje atribut tipu podataka state i dodeljuje mu vrednost ˝gray˝, koja odgovara
huristici minimalne promene bitova. Ako se heuristika eksplicitno ne navede u VHDL kôdu, alat će koristi
podrazumevanu opciju (kod Xilinx ISE to je ˝one-hot˝). Za neki drugi CAD sistem, način specifikacije
heuristike kodiranja može biti drugačiji.
Ako projektant želi da samostalno kodira stanja konačnog automata, tada pridruživanje binarnih kombinacija
stanjima vršiti, takođe, pomoću atributa koji vezuje za nabrojivi tip podataka state, na sledeći način:
. . .
ARCHITECTURE FSM OF detektor_bit_oblika IS
TYPE state IS (S0, S1, S2, S3);
attribute enum_encoding of state: type is "00 10 11 01";
SIGNAL pr_state, nx_state : state;
BEGIN
. . .
String dodeljen atributu enum_encoding sadrži niz od četiri binarne kombinacije koje se redom dodeljuju
stanjima S0, S1, S2 i S3 definisana tipom state. Napomenimo da ovakav način ručnog kodiranja važi za Xilinx
ISE sistem.

2.7.6 Algoritamske mašine stanja

Dijagrami stanja su pogodno sredstvo za predstavljanje konačnih automata sa malim brojem ulaza i izlaza.
Međutim, za opis složenijih automata (tj. algoritama koji se realizuju u hardveru), projektanti obično koriste tzv.
algoritamske mašine stanja, ili ASM dijagrame (prema eng. Algorithmic State Machine). U suštini, ASM
dijagrami su vrsta dijagrama toka prilagođenih za predstavljanje stanja, prelaza između stanja i generisanje
izlaza konačnog automata. Na Sl. 2-52 su predstavljena tri osnovna grafička simbola koji se koriste za crtanja
ASM dijagrama: blok stanja, blok grananja i blok uslovnog izlaza.

(a) (b) (c)

Sl. 2-52 Grafički simboli za crtanje ASM dijagrama: (a) blok stanja; (b) blok grananja; (c) blok uslovnog izlaza.
Blok stanja se crta u vidu pravougaonika i služi za predstavljanje jednog stanja konačnog automata.
Ekvivalentan je krugu u dijagramu stanja. Ime stanja piše se izvan bloka, obično uz njegov gornji levi ugao.
Unutar bloka navedeni su Murovi izlazi. To su izlazi koji zavise isključivo od tekućeg stanja. Uobičajeno je da

88
se u bloku navode samo imena signala koji su aktivni u konkretnom stanju. Za preostale signale se podrazumeva
da su neaktivni. Na primer, da bi se naglasilo da u datom stanju izlaz z ima vrednost 1, dovoljno je napisati z
umesto z=1. Pored signala, u bloku stanja se mogu naći i tzv. naredbe registarskog prenosa koje specificiraju
akciju koju treba preduzeti nad nekom promenljivom (tj. registarskom komponentom). Za naredbe registarskog
prenosa se koristi simbol ←. Na primer, count ←count + 1 znači da sadržaj promenljive count treba uvećati za
1. Efekat ove naredbe je da će u datom stanju upravljačkih signala brojača biti postavljeni na način koji će
omogućiti inkrementiranje njegovog sadržaj, ali samo inkrementiranje desiće se u trenutku naredne aktivne ivice
taktnog signala.
Blok grananja se crta kao romb koji sadrži uslov koji određuje koja će od dve izlazne grane biti izabrana. Uslov
kombinuje jedan ili više ulaza konačnog automata u logički izraz čija vrednost može biti tačno (1) ili netačno
(0). Na primer, w napisano u bloku grananja znači da je odluka zasnovana na vrednosti signala w (ako je w=0,
nastavljamo putem tačno, a ako je w=1, putem netačno). Slično, uslov w1w2 znači da će biti grana tačno biti
izabrana ako su oba signala jednaka 1, tj. w1=w2=1, a da će u svim ostalim slučajevima automat slediti granu
netačno.
Blok uslovnog izlaza se crta u vidu zaobljenog pravougaonika i sadrži izlaze Milijevog tipa, odnosno izlaze koji
zavise kako od tekućeg stanja tako i od trenutnog ulaza automata. Blok uslovnog izlaza uvek sledi nakon jednog
ili više bloka grananja, a nikada direktno nakon bloka stanja.
Na Sl. 2-53(a) je prikazan ASM dijagram koji reprezentuje konačni automat iz Pr. 2-51 (detektor bit-oblika).
Prelazi između blokova stanja zavise od uslova koji testira ulazni signal d. U svim slučajevima kada je d=0,
izlazna grana vodi u stanje nula. Ako je w=1, desiće se prelaz iz nula u jedan, iz jedan u dva ili iz dva u tri.
Međutim, ako je w=1 u stanju tri, konačni automat će ostati u istom stanju. Jedini izlaz automata, q, je Murovog
tipa i aktiva je samo u stanju tri. U ostalim stanjima važi q=0 što predstavlja i razlog zbog koga su blokovi ovih
stanja prazni.
ASM dijagram automata za prodaju karata (Pr. 2-52) prikazan je na Sl. 2-53(b). Pošto se radi o konačnom
automatu Milijevog tipa, u ASM dijagramu uočavamo blokove uslovnog izlaza koji sadrže izlazne signale
automata, K i V. Na primer, izlaz K (signal za izdavanje karte) biće aktivan ako je automat u stanju S5 i ubačena
je kovanica od 10 din., ili ako je u stanju S10, pod uslovom da je ubačena bilo koja kovanica. Slično, izlaz V
(povraćaj kusura) je aktivan u stanju S10 pod uslovom da je ubačena kovanica od 10 din. Kao što primećujemo,
za aktiviranje uslovnog izlaza (tj. izlaza Milijevog) nije dovoljno da automat bude u nekom konkretnom stanju,
već je potreban i neki dodatni uslov, određen blokovima grananja koji iz bloka stanja vode do odgovarajućeg
bloka uslovnog izlaza.

(a) (b)
Sl. 2-53 ASM dijagrami: (a) odgovara dijagramu stanja iz Pr. 2-51; (b) odgovara dijagramu stanja iz Pr. 2-52.

89
Pr. 2-54 Brojač jedinica (sekvecijalna varijanta)
Brojač jedinica (BJ) je kolo koje određuje broj 1-ca u ulaznom binarnom vektoru. U Pr. 2-43 realizovali smo
kombinacionu varijantu ovog kola. U ovom primeru, realizovaćemo sekvencijalni brojač jedinica (BJ) čiji je
blok dijagram prikazan na Sl. 2-54(a). Ulazni podatak dovodi se na ulaz a, a rad BJ-a se startuje aktiviranjem
signala start u trajanju jednog taktnog perioda. Nakon završenog izračunavanja, BJ postavlja rezultat na izlaz b i
aktivira izlazni signal kraj (u trajanju od jednog taktnog perioda).
Za brojanje jedinica možemo koristiti sledeći postupak (algoritam) opisan u vidu pseudo koda:
B = 0;
while(A≠0) do
if(A0 = 1) then
B = B + 1;
end if;
A = A >> 1;
end while;
U algoritmu se koriste dve promenljive: A (sadrži podatak koje se obrađuje) i B (koristi se za brojanje 1-ca).
Algoritam radi tako što pomera sadržaj promenljive A udesno, i broji koliko puta je na poziciji najmanje težine
(A0) bila prisutna 1-ca. Algoritam se završava kada u promenljivoj A više nema 1-ca.
S0
regB <- 0
regA <- a

0
start

S1 S2
regA <- regA >> 1 Kraj

da
regA=0

ne

a b 0
regA(0)
start
BJ 1
rst kraj regB <- regB + 1
clk

(a) (b)
Sl. 2-54 Brojač jedinica: (a) blok dijagram; (b) ASM dijagram
Na Sl. 2-54(b) je prikazan ASM dijagram BJ-a zasnovan na opisanom algoritmu. Promenljivama u hardveru
odgovaraju registri. Zato su imena promenljivih A i B iz algoritma u ASM dijagramu promenjena na regA i
regB. Osenčeni deo ASM dijagram ogovara opisanom algoritmu, dok preostali deo predstavlja proširenje koje
reguliše rad interfejsa kola (signali start i kraj). S0 je inicijalno stanje u koje ASM ostaje sve dok se ulaz start
ne postavi na start=1. Blok stanja S0 sadrži dve naredbe registarskog prenosa koje inicijalizuju registre regA i
regB (u regA se upisuje vrednost sa ulaza a, a regB se postavlja na 0). Kada start postane aktivan, ASM prelazi
u stanje S1 koje predstavlja radno stanje BJ-a. Lako uočavamo sličnost ovog dela ASM dijagrama sa prethodno
opisnim algoritmom. U stanju S1, sadržaj promenljive regA se bezuslovno pomera udesno (zato se operacija
nalazi u bloku stanja), dok je uvećanje promenljive B za 1 uslovljeno vrednošću bita regA(0) (zato je ova
operacija navedena u bloku uslovnog izlaza). U ciklusu kada regA postane jednako nuli, brojanje jedinica je
završeno i ASM prelazi u stanje S2. U ovom stanju se aktivira signal kraj što za korisnika ovog kola znači da je
izračunavanje završeno i rezultat prisutan na izlazu b.
Pre nego što pređemo na opis ASM dijagrama u VHDL-u, važno je istaći izvesne pojedinosti vezane za način
rada i interpretacije ASM dijagrama. Mada, ASM dijagram nalikuje konvencionalnom, softverskom dijagramu
toka, oblasti primene ova dva tipa dijagrama se razlikuju. Oba služe za opis algoritama. Softverske dijagrame
toka koriste programeri, kao početni korak u procesu razvoja programa čija je namena da omogući izvršenje

90
datog algoritam na računarskoj mašini. ASM dijagrame koriste projektanti digitalnog hardvera, kao početni
korak u procesu realizacije datog algoritma direktno u hardveru. U pogledu interpretacije, razlika između
softverskog dijagrama toka i ASM dijagrama ogleda se pre svega u odnosu na to kako protok vremena utiče na
rad algoritma. Računarska mašina izvršava algoritam instrukciju-po-instrukciju; svaka instrukcija se obavlja u
toku jednog instrukcijskog ciklusa, a instrukcijski ciklusi mogu imati različito trajanje. Iz tog razloga, softverski
dijagram ne navodi tačan iznos vremena koji je potreban da bi se izvršio jedan algoritamski korak, već samo
jednoznačno određuje tok (sekvencu) algoritamskih koraka. Programer je svestan činjenice da izvršenje
algoritma na računskoj mašini zahteva neko konačno vreme, koje zavisi od broja i složenosti operacija koje
treba izvršiti, ali sam tok algoritma i konačni rezultat ne zavise od vremena izvršenja pojedinačnih operacija. Sa
druge strane, rad digitalnog sistema je iniciran taktnim signalom, a u toku jednog taktnog perioda digitalni
sistem može da obavi jednu ili više operacija. Naime, u radu digitalnog sistema ispoljava se paralelizam. S
toga, osnovna pretpostavka kod ASM dijagram se sastoji u sledećem: svaki algoritamski korak traje isto, fiksno
vreme (jednako taktnom periodu), a sve operacije obuhvaćene jednim algoritamskim korakom se izvršavaju
istovremeno (u paraleli). Paralelni alogritamski korak čini jedan blok stanja i svi blokovi grananja i uslovnog
izlaza pridruženi tom bloku. Na primer, sve operacije sadržane u osenčenom delu ASM dijagrama sa izvršavaju
se u paraleli, tj u okviru istog taktnog perioda, u kome je ASM u stanju S1. Slično, blok stanja S0 i grananje u
odnosu na signal start zajedno čine jedan paralelni algoritamski korak.
Druga napomena se odnosi na naredbe registarskog prenosa. Registri su memorijske komponente koje
zadržavaju upisani sadržaj sve do novog upisa. To znači da ako u bloku stanja ne postoji naredba registarskog
prenosa koja dodeljuje novu vrednost nekom registru, sadržaj tog registra će ostati nepromenjen. Takođe,
naredba registarskog prenosa ne definiše vrednost koju registar, naveden sa leve strane znak ← ima u datom
stanju, već vrednost koja će biti upisana u registar sledećom aktivnom ivicom taktnog signala, tj. u trenutku
napuštanja tekućeg stanja. Na primer, razmotrimo stanje S1 iz ASM dijagrama sa Sl. 2-54(b). Da se radi o
konvencionalnom dijagramu toka, po ulasku u stanje S1, promenljiva regA bi najpre bila pomerena udesno, a
zatim bi se u blokovima grananja koji slede ispitivala njena nova vrednost. Pošto ASM dijagram opisuje
sekvencijalno kolo, do promene promenljivih regA i regB, koje predstavljaju izlaze flip-flopova, dolazi tek
nakon sledeće aktivne ivice takta. To znači da se u testiranjima koja slede nakon bloka stanja S1 koristi stara
vrednost regA (pre pomeranja). Ako je regA=0, sledeća aktivna ivica takta iniciraće prelaz ASM-a u stanje S2 i,
u isto vreme, pomeranje regA udesno. Ako je regA≠0, ASM ne menja stanje, već ostaje u S1. Bez obzira na to,
regA se pomera udesno, a regB uvećava za 1, pod uslovom ako je regA(0)=1. Iako je operacija pomeranja u
ASM dijagramu na početku, a u pseudo kodu na kraju petlje, efekat je isti, s obzirom da se u oba slučaju
pomeranje obavlja na kraju tekuće iteracije.
U nastavku je dat VHDL kôd BJ-a koji odgovara ASM dijagramu sa Sl. 2-54(b). Struktura kôda je slična
kodnom šablonu #1, s tom razlikom što se sada sekvencijalni proces ne bavi samo registrom stanja, pr_state,
već opisuje i registarske promenljive iz ASM dijagrama, regA i regB. U CASE naredbi, za svako stanje
navedene su naredbe registarskog prenosa pridružene tom stanju, kako one Murovog tipa (napisane u
odgovarajućem bloku stanja) tako i one Milijevog tipa (navedene u blokovima uslovnog izlaza koji su
pridruženi tom stanju). Na primer, u stanju S0, obavljaju se dve bezuslovne (Murove) naredbe registarsko
prenosa; u stanju S1 postoji jedna Murova naredba i jedna Milijeva, zajedno sa odgovarajućim uslovom; u
stanju S2 ne postoje naredbe registarskog prenosa (zato je u odgovarajućoj WHEN grani navedeno NULL).
Kombinacioni proces, slično kao kod konačnih automata, opisuje funkciju kombinacione logike koja definiše
sledeće stanje i vrednosti Murovih i Milijevih izlaza u zavisnosti od tekućeg stanja, trenutnog ulaza i trenutne
vrednosti registarskih promenljivih.
Rezultati simulacije VHDL kôda, za slučaj kada je ulazni podatak a=˝00010111˝ dati su na Sl. 2-55.
1 -----------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE ieee.std_logic_unsigned.all;
5 -----------------------------------------------
6 ENTITY ones_counter IS
7 PORT (a : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
8 clk, rst, start : IN STD_LOGIC;
9 b : OUT STD_LOGIC_VECTOR(2 DOWNTO 0);
10 kraj : OUT STD_LOGIC);
11 END ones_counter;
12 -----------------------------------------------
13 ARCHITECTURE ASM OF ones_counter IS
14 SIGNAL regA : STD_LOGIC_VECTOR(7 DOWNTO 0);
15 SIGNAL regB : STD_LOGIC_VECTOR(2 DOWNTO 0);
16 TYPE state IS (S0, S1, S2);
17 SIGNAL pr_state, nx_state : state;

91
18 BEGIN
19 -- sekvencijalni process --------------------
20 PROCESS (clk,rst)
21 BEGIN
22 IF(rst='1')THEN
23 pr_state <=S0;
24 regA <= "00000000";
25 regB <= "000";
26 ELSIF(clk'EVENT AND clk='1') THEN
27 pr_state <= nx_state;
28 CASE pr_state IS
29 WHEN S0 =>
30 regA <= a;
31 regB <= "000";
32 WHEN S1 =>
33 regA <= '0' & regA(7 DOWNTO 1);
34 IF(regA /= "00000000" AND regA(0) = '1') THEN
35 regB <= regB + 1;
36 END IF;
37 WHEN S2 => NULL;
38 END CASE;
39 END IF;
40 END PROCESS;
41 -- kombinacioni process --------------------
42 PROCESS(regA, start, pr_state)
23 BEGIN
44 nx_state <= pr_state;
45 kraj <= '0';
46 CASE pr_state IS
47 WHEN S0 =>
48 if(start = '1') then
49 nx_state <= S1;
50 end if;
51 WHEN S1 =>
52 if(regA = "00000000") THEN
53 nx_state <= S2;
54 end if;
55 WHEN S2 =>
56 kraj <= '1';
57 nx_state <= S0;
58 END CASE;
59 END PROCESS;
60 b <= regB;
61 END ASM;
62 -----------------------------------------------

Sl. 2-55 Rezultati simulacije sekvencijalnog brojača jedinica iz Pr. 2-54.

92
2.8 Memorijske komponente
U ovom poglavlju razmatra se projektovanje memorijskih komponenti u VHDL-u.
ROM
ROM (Read-Only Memory) je memorija sa fiksnim sadržajem, tj. memorijska komponenta koja može samo da
se čita. Sadržaj ROM-a se definiše u toku projektovanja i ne može se menjati u toku njegove eksploatacije. Blok
dijagram ROM-a prikazan je na Sl. 2-56. ROM čini m memorijskih lokacija, ili reči, od po n bita. Na ulazni port
addr postavlja se adresa lokacije koja se čita, dok se sa izlaznog porta data preuzima sadržaj adresirane reči.
Sledi generički opis ROM-a.

Sl. 2-56 ROM.

Parametar bits (linija 6) definiše dužinu (broj bita) reči, a parametar words (linija 7) broj reči ROM-a. Za
kreiranje ROM-a može se koristiti niz konstantnih vrednosti (linije 15-22). Najpre se definiše novi tip podataka
mem_array (linije 14 i 15), koji se potom koristi u deklaraciji konstante memory (linija 15). Dati VHDL kôd
odgovara ROM-u 8x8 (8 reči dužine 8 bita) sa sledećim vrednostima zapamćenim na adresama 0 do 7: 0, 2, 4, 8,
16, 32, 64 i 128 (linije 15-22). Telo arhitekture (linija 24) sadrži konkurentnu naredbu dodele koja na izlazni
port data prenosi vrednost zapamćenu na adresi addr konstantnog niza memory.
1 ----------------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------------
5 ENTITY ROM IS
6 GENERIC (bits: INTEGER := 8; -- broj bita po reci
7 words: INTEGER := 8); -- broj reci u memoriji
8 PORT (addr : IN INTEGER RANGE 0 TO words-1;
9 data : OUT STD_LOGIC_VECTOR(bits-1 DOWNTO 0));
10 END ROM;
11----------------------------------------------------
12 ARCHITECTURE rom OF ROM IS
13 TYPE mem_array IS ARRAY (0 TO words-1) OF
14 STD_LOGIC_VECTOR(bits-1 DOWNTO 0);
15 CONSTANT memory : mem_array := ( "00000000",
16 "00000010",
17 "00000100",
18 "00001000",
19 "00010000",
20 "00100000",
21 "01000000",
22 "10000000" );
23 BEGIN
24 data <= memory(addr);
25 END rom;
26----------------------------------------------------
U suštini ROM nije ˝prava˝ memorija. S obzirom da se svaka binarna kombinaciji sa ulaznog porta preslikava u
tačno definisanu binarnu kombinaciju na izlazu, ROM se može razumeti i ako kombinaciona komponenta sa
višebitnim ulazom addr i višebitnim izlazom data. Zato se ROM ne sintetiše u registre, već se za njegovu
implementaciju koriste logička kola, ili LUT blokovi (kod FPGA).
RAM sa ulaznim i izlaznim portom za podatke
RAM je memorija sa mogućnošću čitanja i upisa podataka. Na Sl. 2-57 je ilustrovana organizacija RAM-a sa
razdvojenim ulaznim i izlaznim portom za podatke. Vrednost prisutna na adresnom portu, addr, bira (adresira)
reč kojoj se pristupa. Pri wr_ena=´1´, vrednost prisutan na ulaznom portu za podatke, data_in, pod dejstvom
takta, clk, upisuje se u adresiranu reč. Sadržaj adresirane reči je dostupan na izlaznom portu za podatke,
data_out.

93
 Sl. 2-57 RAM sa razdvojenim ulazim i izlazim portovima za podatke.
Ispod je dat VHDL kôd koji realizuje RAM sa Sl. 2-57. Izabran je kapacitet 16x8, tj. words=16 i bits=8. Kôd je
u potpunosti generički. Kao i kod ROM-a, uveden je tip podataka mem_array koji predstavlja dvodimenzionalo
polje dimenzija 16x8 (linije 15 i 16), ali za razliku od ROM-a, zbog potrebe upisa, ˝memorijski medijum˝
memory nije konstanta već signal (linija 17). Arhitektura sadrži proces (linije 19-26), koji reguliše upis, i
konkurentnu naredbu dodele (linija 27), koja je zadužena za čitanje memorije. Proces sadrži dve ugnježdene IF
naredbe: prva dozvoljava upis ako je wr_ena jednak 1 (linija 21), a druga sinhroniše upis sa rastućom ivicom
taktnog signala clk. S obzirom da linija 23 predstavlja sinhronu narednu dodele, signal mamory se sintetiše u
polje od 16x8=128 flip-flopova. Konkurentno sa procesom, naredba dodele iz linije 27, prenosi sadržaj
adresirane reči na izlazni port data_out.
1 ----------------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------------
5 ENTITY RAM IS
6 GENERIC (bits: INTEGER := 8; -- broj bita po reci
7 words: INTEGER := 16); -- broj reci u memoriji
8 PORT (wr_ena, clk : IN STD_LOGIC;
9 addr : IN INTEGER RANGE 0 TO words-1;
10 data_in : IN STD_LOGIC_VECTOR(bits-1 DOWNTO 0);
11 data_out : OUT STD_LOGIC_VECTOR(bits-1 DOWNTO 0));
12 END RAM;
13----------------------------------------------------
14 ARCHITECTURE ram OF RAM IS
15 TYPE mem_array IS ARRAY (0 TO words-1) OF
16 STD_LOGIC_VECTOR(bits-1 DOWNTO 0);
17 SIGNAL memory : mem_array;
18 BEGIN
19 PROCESS(clk, wr_ena)
20 BEGIN
21 IF(wr_ena = '1') THEN
22 IF(clk'EVENT AND clk='1') THEN
23 memory(addr) <= data_in;
24 END IF;
25 END IF;
26 END PROCESS;
27 data_out <= memory(addr);
28 END ram;
29----------------------------------------------------
RAM sa bidirekcionim ulazno-izlaznim portom za podatke
Organizacija RAM-a sa bidirekcionim ulazno-izlaznim portom prikazana je na Sl. 2-58. Struktura je slična onoj
sa Sl. 2-57 osim što se sada upis i čitanje podataka vrši preko istog porta, bidir. Kada je wr_ena=1, podatak
spolja postavljen na port bidir, pod dejstvom taktnog signala, upisuje se u reč adresiranu vrednošću prisutnom
na adresnom portu, addr. Kada je wr_ena=0, podatak iz adresirane reči prenosi se na port bidir. Na taj način,
signal wr_ena reguliše smer bidirekcionog porta bidir: za wr_ena=1, bidir se ponaša kao ulazni, a za wr_ena=0
kao izlazni port.

94
 Sl. 2-58 RAM sa bidirekcionim portom za podatke
1 ----------------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------------
5 ENTITY RAM IS
6 GENERIC (bits: INTEGER := 8; -- broj bita po reci
7 words: INTEGER := 16); -- broj reci u memoriji
8 PORT (wr_ena, clk : IN STD_LOGIC;
9 addr : IN INTEGER RANGE 0 TO words-1;
10 bidir : INOUT STD_LOGIC_VECTOR(bits-1 DOWNTO 0));
11 END RAM;
12----------------------------------------------------
13 ARCHITECTURE ram OF RAM IS
14 TYPE mem_array IS ARRAY (0 TO words-1) OF
15 STD_LOGIC_VECTOR(bits-1 DOWNTO 0);
16 SIGNAL memory : mem_array;
17 BEGIN
18 PROCESS(clk, wr_ena)
19 BEGIN
20 IF(wr_ena = '0') THEN
21 bidir <= memory(addr);
22 ELSE
23 bidir <= (OTHERS => 'Z');
24 IF(clk'EVENT AND clk='1') THEN
25 memory(addr) <= bidir;
26 END IF;
27 END IF;
28 END PROCESS;
29 END ram;
----------------------------------------------------
U gornjem VHDL kôdu, koji odgovara RAM-u sa Sl. 2-58, uočimo liniju 11 u kojoj se deklariše port bidir. Smer
porta je postavljen na INOUT što ukazuje da se radi o bidirekcionom portu. Za opis funkcije RAM-a koristi se
proces (linije 19-29). Operacija čitanja (wr_ena=1) realizuje se na identičan način kao kod RAM-a sa dva porta:
podatak iz adresirane reči se prenosi na port bidir (linija 22). Međutim, operacija upisa (wr_ena=1) dodatno
zahteva da se port bidir postavi u stanje visoke impedanse (linija 24). Pod tim uslovom, podatak koji se prihvata
sa porta bidir i pamti u niz memory (linija 26) određen je vrednošću koja se spolja postavlja na ovaj port.
Fizički, bidirekcioni portovi se realizuju pomoću trostatičkih bafera (na šta ukazuje linija 24 u kojoj se na port
postavlja vrednost ´Z´). Princip je ilustrovan na Sl. 2-59. Unutar kola i dalje egzistiraju razdvojeni jednosmerni
putevi za podatke (magistrale), data_in i data_out, koji se spajaju u zajedničku tačku koja odgovara eksternom
bidirekcionom portu. Pri tome se magistrala data_out može prekinuti trostatičkim baferom. Za wr_ena=1,
vrednost sa magistrale data_out prolazi kroz trostatički bafer i pojavljuje se na portu bidir. Za wr_ena=0, veza
magistrale data_out i porta je prekinuta zakočenim trostatičkim baferom, tako da na port bidir slobodno može
da se postavi podatak koji će magistralom data_in stići do svog odredišta.

Sl. 2-59 Princip realizacije bidirekcionog porta.

95
2.9 Paketi i komponente
U dosadašnjem izučavanju VHDL-a ovladali smo osnovama jezika i tehnikama kôdiranja, što obuhvata sledeće:
• Struktura kôda: biblioteka, entitet, arhitektura
• Tipovi podataka
• Operatori i atributi
• Konkurentne naredbe i konkurentni kôd
• Sekvencijalne naredbe i sekvencijalni kôd
• Signali, varijable i konstante
• Projektovanje konačnih automata
• Projektovanje memorijskih komponenti
Drugim rečima, u ovom trenutku smo u stanju da realizujemo VHDL kôd čija struktura odgovara levom delu Sl.
2-60. Dobro razumevanje ove materije od velikog je značaja kako za projektovanje kola male složenosti tako i za
projektovanje velikih i složenih sistema.

Sl. 2-60 Osnovne jedinice VHDL jezika.

U nastavku proučavanja VHDL-a, već izložena materija biće proširena aspektima jezika koji se prevashodno
odnose na rad sa bibliotekama (levi deo Sl. 2-60). Konkretno, razmatraćemo:
• Pakete
• Komponente
• Funkcije
• Procedure
Ove nove jezičke celine mogu biti smeštene u i samom glavnom kôdu (levi deo Sl. 2-60). Međutim, kako je
njihova osnovna namena da omoguće ponovno korišćenje i razmena zajedničkih delova kôda, njihovo pravo
mesto je u biblioteci. Drugim rečima, često korišćeni delovi kôda pišu se u obliku funkcija (FUNCTION),
procedura (PROCEDURE) i komponenti (COMPONENT) i smeštaju u pakete (PACKET) koji se kompajliraju
u biblioteke (LIBRARY).
Kao što već znamo, barem tri biblioteke su potrebne svakom projektu: ieee, std i work. Nakon upoznavanja sa
preostalom materijom bićemo u mogućnosti da pišemo naše sopstvene biblioteke i da ih potom koristimo na isti
način kao i prethodno navedene.

2.9.1 PACKAGE
Kao što je već rečeno, često korišćeni delovi VHDL kôda pišu se u obliku komponenti, funkcija i procedura.
Takav kôd se smešta u paket i kompajlira i na taj način generiše biblioteke. Značaj ove tehnike je u sledećem:
omogućava podelu kôda na manje jedinice, olakšava razmenu kôda sa drugim projektantima i pruža mogućnost
ponovnog korišćenje kôda u novim projektima.
Osim komponenti, funkcija i procedura, paket može sadržati i deklaracije drugih jezičkih celina, kao što su
tipovi podataka, konstante i globalno vidljivi signali. Paket ima sledeću sintaksu:

96
PACKAGE ime_paketa IS
(deklaracije)
END ime_paketa
[PACKAGE BODY ime_paketa IS
(funkcije i procedure )
END ime_paketa]
Sintaksu paketa čine dve celine: deklaracija paketa (PACKAGE) i telo paketa (PACKAGE BODY). Prva celina
je obavezna i sadrži sve deklaracije. Telo paketa je opciono i neophodno samo ako u deklaracija paketa postoji
jedna ili više deklaracija potprograma (funkcija ili procedura) u kom slučaju sadrži opise (tela) svih
potprograma. PACKAGE i PACKAGE BODY moraju imati isto ime.
Pr. 2-55 Primer jednostavnog paketa
VHDL kôd iz ovog primera definiše paketa imena nas_paket. S obzirom da paketa sadrži samo deklaracije tipa
TYPE i CONSTANT (dva tipa podataka i jednu konstantu), telo paketa nije neophodno.
1 ----------------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------------
5 PACKAGE nas_paket IS
6 TYPE state IS (st1,st2,st3,st4);
7 TYPE boja IS (crvena, bela, plava);
8 CONSTANT niz: STD_LOGIC_VECTOR(7 DOWNTO 0) := "11111111";
9 END nas_paket;
10----------------------------------------------------
Pr. 2-56 Paket sa funkcijama
Paket iz ovog primera, pored deklaracije dva tipa podataka i jedne konstante, sadrži i jednu funkciju. Iz tog
razloga telo paketa je neophodno. Deklaracija funkcije je smeštena u deklaraciji paketa, a telo funkcije u telu
paketa.
1 ----------------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------------
5 PACKAGE nas_paket IS
6 TYPE state IS (st1,st2,st3,st4);
7 TYPE boja IS (crvena, bela, plava);
8 CONSTANT niz: STD_LOGIC_VECTOR(7 DOWNTO 0) := "11111111";
9 FUNCTION rastuca_ivica(SIGNAL s : STD_LOGIC) RETURN BOOLEAN;
10 END nas_paket;
11----------------------------------------------------
12 PACKAGE BODY nas_paket IS
13 FUNCTION rastuca_ivica(SIGNAL s : STD_LOGIC) RETURN BOOLEAN IS
14 BEGIN
15 RETURN (s'EVENT AND s='1');
16 END rastuca_ivica;
17 END nas_paket;
18----------------------------------------------------
Oba paketa iz prethodnih primera se mogu kompajlirati i tako postati deo radne biblioteke work (ili bilo koje
druge). Paket se uključuje u VHDL kôd naredbom USE koja se piše na početku glavnog kôda:
--------------------------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE work.nas_paket.all;
--------------------------------
ENTITY . . .
. . .
ARCHITECTURE . . .
. . .

97
2.9.2 COMPONENT
Pojam komponenta odnosi se celoviti deo VHDL kôda (entitet plus arhitektura) koji opisuje neko kolo. Takva
jedna celina se može deklarisati kao COMPONENT i na taj način postati dostupna za korišćenje u drugim
delovima VHDL kôda za konstrukciju složenijih kola ili u novim projektima, bez potrebe ponovnog pisanje
istog kôda.
COMPONENT konstrukcija VHDL jezika predstavlja osnovu strukturnog i hijerarhijskog projektovanja.
Strukturno projektovanje znači da se složenija kola realizuju povezivanjem jednostavnijih komponenti.
Hijerarhijsko projektovanje odnosi se na mogućnost da strukturno opisano kolo može takođe biti deklarisano
kao komponenta i zatim korišćeno u realizaciji još složenijih kola. Na primer, često korišćena kola, kao što su
flip-flopovi i logička kola, mogu se jednom opisati VHDL kôdom, deklarisati kao komponente, a zatim
proizvoljan broj puta koristiti (instancirati) za realizaciju složenijih struktura, kao što su registri, sabirači i td.

Sl. 2-61 Kolo iz Pr. 2-57.

Pr. 2-57 Jednostavan strukturni opis
Razmotrimo kolo sa Sl. 2-61 i njegov strukturni VHDL opis:
1 ENTITY gating IS
2 PORT (a,clk,mr,din : BIT;
3 rdy,ctrl : OUT BIT);
4 END ENTITY
5 ------------------------------------------------
6 ARCHITECTURE struktura OF gating IS
7 COMPONENT AND2
8 PORT(x,y: IN BIT; z OUT BIT);
9 END COMPONENT;
10 COMPONENT DFF
11 PORT(d,clock: IN BIT; q, not_q OUT BIT);
12 END COMPONENT;
13 COMPONENT NOR2
14 PORT(x,y: IN BIT; z OUT BIT);
15 END COMPONENT;
16 SIGNAL s1, s2 : BIT;
17 BEGIN
18 D1: DFF PORT MAP(a,clk,s1,s2);
19 A1: AND2 PORT MAP(s2,din,ctrl);
20 N1: NOR2 PROT MAP(s1,mr,rdy);
21 END stuktura;
22------------------------------------------------
U kôdu su deklarisane tri komponente, AND2 (dvoulazno I kolo, linije 7-9), DFF (D flip-flop, linije 10-12) i
NOR2 (dvoulazno NILI kolo, linije 13-15). (Pretpostavka je da se VHDL opis ovih komponenata nalazi u
nekom drugom fajlu projekta; da su kompajlirane i na taj način prisutne u biblioteci work. Komponente DFF,
AND2 i NOR2 su potom instancirane u arhitekturi (linije 18-20) i povezane sa odgovarajućim portovima
entiteta gating kao i međusobno pomoću dva signala, s1 i s2. Naredbe za instanciranje komponente spadaju u
grupu konkurentnih naredbi i s toga redosled njihovog navođenja u telu arhitekture nije od značaja. Jedna ista
komponenta se može instancirati proizvoljan broj puta, ali svaka instanca mora imati jedinstvenu labelu.
Sve komponente koje se instanciraju u telu arhitekture moraju biti deklarisane u njenom deklarativnom delu
shodno sledećoj sintaksi:
Deklaracija komponente:
COMPONENT ime_komponente IS
PORT (
ime_porta : mode_signala tip_signala;
ime_porta : mode_signala tip_signala;
. . .
END COMPONET;

98
Instanciranje komponente:
labela: ime_komponente PORT MAP(lista_portova);
Deklaracija komponente slična je deklaraciji entiteta: navode se imena portova zajedno sa njihovim mode-ovima
(IN, OUT, BUFER ili INOUT) i tipom (STD_LOGIC, BIT, INTEGER i sl.). U naredbi za instanciranje
komponente navodi se labela, posle koje sledi ime komponente i deklaracija PORT MAP. Lista portova
sadržana u PORT MAP deklaraciji povezuje portove i signale kola koje se projektuje sa portovima ranije
projektovane komponente koja se instancira.
Deklaracija komponente AND2 iz primera (linije 7-9) tumači se ovako: komponenta ima dva ulazna porta, x i y i
jedan izlazni port z, svi tipa BIT. U telu arhitekture, kola koje se projektuje, ova komponenta je jedanput
instancirana (linija 19). Labela A1 definiše ime ove instance u arhitekturi. Lista portova, PORT
MAP(s2,din,ctrl), povezuje signal s2 sa portom x komponente AND2, kao i portove din i ctrl entiteta gating
sa portovima y i z komponente AND2. Uočimo da redosled navođenja signala u listi portova odgovara redosledu
u kome su portovi navedeni u deklaraciji komponente. Ovakav način uspostavljanja korespondencije zove se
poziciono povezivanje.
Princip rada sa komponentama ilustrovan je na Sl. 2-62. Pre korišćenja, komponenta mora biti projektovana,
kompajlirana i smeštena u biblioteku. Postoje dva osnovna načina za uključivanje komponenti u glavni kôd.
Pristup koga smo koristili u prethodnom primeru, podrazumeva da se komponente deklarišu u glavnom kôdu, tj.
u deklarativnom delu arhitekture (Sl. 2-62(a)). Drugi način je da se deklaracije svih komponenti prvo smeste u
paket koji se potom uključuje u glavni kôd (Sl. 2-62(b)). Na taj način eliminiše se potreba da se komponenta
eksplicitno deklariše u svakoj arhitekturi gde se koristi. Primeri oba pristupa izloženi su u nastavku.

(a) (b)
Sl. 2-62 Načini za deklaraciju komponenti: (a) deklaracija u glavnom kôdu; (b) deklaracija u paketu.
a
x
b

c y
d

Sl. 2-63 Kolo iz Pr. 2-58.

Pr. 2-58 Deklaracija komponenti u glavnom kôdu
Naš cilj je realizacija kola sa Sl. 2-63 korišćenjem isključivo komponenti (INV, NAND2 i NAND3) na način
ilustrovan na Sl. 2-62(a) koji ne koristi paket. Potrebna su četiri VHDL celine (fajla): po jedan fajl za svaku
komponentu plus fajl za glavni kôd. Sadržaj sva četiri fajla dat je ispod. Pošto se ne koristi paket, komponente
moraju biti deklarisane u glavnom kôdu (fajl projekat.vhd).
1 ------ Fajl inv.vhd -------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY inv IS
6 PORT ( a: IN STD_LOGIC; b : OUT STD_LOGIC);
7 END inv;
8 ---------------------------------------------

99
9 ARCHITECTURE inv OF inv IS
10 BEGIN
11 b <= NOT a;
12 END inv;
13 --------------------------------------------
1 ------ Fajl nand2.vhd -------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY nand2 IS
6 PORT ( a,b: IN STD_LOGIC; c : OUT STD_LOGIC);
7 END nand2;
8 ---------------------------------------------
9 ARCHITECTURE nand2 OF nand2 IS
10 BEGIN
11 c <= a NAND b;
12 END nand2;
13 ---------------------------------------------
1 ------ Fajl nand3.vhd -------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY nand3 IS
6 PORT ( a,b,c: IN STD_LOGIC; d : OUT STD_LOGIC);
7 END nand3;
8 ---------------------------------------------
9 ARCHITECTURE nand3 OF nand3 IS
10 BEGIN
11 d <= NOT(a AND b AND c);
12 END nand3;
13 ---------------------------------------------
1 ------ Fajl projekat.vhd -------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY projekat IS
6 PORT ( a,b,c,d: IN STD_LOGIC;
7 x,y : OUT STD_LOGIC);
8 END projekat;
9 ---------------------------------------------
10 ARCHITECTURE struktura OF projekat IS
11 ----------------
12 COMPONENT inv IS
13 PORT(a: IN STD_LOGIC; b: OUT STD_LOGIC);
14 END COMPONENT;
15 ----------------
16 COMPONENT nand2 IS
17 PORT(a,b: IN STD_LOGIC; c: OUT STD_LOGIC);
18 END COMPONENT;
19 ----------------
20 COMPONENT nand3 IS
21 PORT(a,b,c: IN STD_LOGIC; d: OUT STD_LOGIC);
22 END COMPONENT;
23 ----------------
24 SIGNAL w: STD_LOGIC;
25 BEGIN
26 K1: inv PORT MAP(b,w);
27 K2: nand2 PORT MAP(a,b,x);
28 K3: nand3 PORT MAP(w,c,d,y);
29 END struktura;
30 ---------------------------------------------
Pr. 2-59 Deklaracija komponenti u paketu.
Ponovo ćemo realizovati projekat iz prethodnog primera ( Sl. 2-63), ali sada na način kao na Sl. 2-62(b) koji
podrazumeva kreiranje paketa sa deklaracijama svih korišćenih komponenti (inv, nand2 i nand3). Biće nam

100
potrebno pet fajlova: tri za VHDL kôd komponenata i po jedan za paket i projekat. Iako u odnosu na pristup iz
primera, sada postoji jedan dodatni fajl (PACKAGE), paket se kreira samo jedanput, a koristi proizvoljan broj
puta u različitim projektnim fajlovima. Na taj način se izbegava ponavljanje deklaracija komponenti u svakom
projektnom fajlu u kome se one koriste. Sledi VHDL kôd kompletnog projekta. Fajl nase_komponente.vhd
sadrži istoimeni paket u sa navedenim deklaracijama komponenti. Paket se uključuje u glavni kôd (fajl
projekat.vhd) u liniji 3 (USE work.nase_komponente.all;).
1 ------ Fajl inv.vhd -------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY inv IS
6 PORT ( a: IN STD_LOGIC; b : OUT STD_LOGIC);
7 END inv;
8 ---------------------------------------------
9 ARCHITECTURE inv OF inv IS
10 BEGIN
11 b <= NOT a;
12 END inv;
13 --------------------------------------------
1 ------ Fajl nand2.vhd -------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY nand2 IS
6 PORT ( a,b: IN STD_LOGIC; c : OUT STD_LOGIC);
7 END nand2;
8 ---------------------------------------------
9 ARCHITECTURE nand2 OF nand2 IS
10 BEGIN
11 c <= a NAND b;
12 END nand2;
13 ---------------------------------------------
1 ------ Fajl nand3.vhd -------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY nand3 IS
6 PORT ( a,b,c: IN STD_LOGIC; d : OUT STD_LOGIC);
7 END nand3;
8 ---------------------------------------------
9 ARCHITECTURE nand3 OF nand3 IS
10 BEGIN
11 d <= NOT(a AND b AND c);
12 END nand3;
13 ---------------------------------------------
1 ------ Fajl nase_komponente.vhd ----------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 PACKAGE nase_komponente IS
6 -- invertor -----------
7 COMPONENT inv IS
8 PORT(a: IN STD_LOGIC; b: OUT STD_LOGIC);
9 END COMPONENT;
10 -- dvoulazno NI kolo --
11 COMPONENT nand2 IS
12 PORT(a,b: IN STD_LOGIC; c: OUT STD_LOGIC);
13 END COMPONENT;
14 -- troulazno NI kolo --
15 COMPONENT nand3 IS
16 PORT(a,b,c: IN STD_LOGIC; d: OUT STD_LOGIC);
17 END COMPONENT;
18 ----------------
19 END nase_komponente;
---------------------------------------------

101
1 ------ Fajl projekat.vhd -------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE work.nase_komponente.all;
5 ---------------------------------------------
6 ENTITY projekat IS
7 PORT ( a,b,c,d: IN STD_LOGIC;
8 x,y : OUT STD_LOGIC);
9 END projekat;
10 ---------------------------------------------
11 ARCHITECTURE struktura OF projekat IS
12 SIGNAL w: STD_LOGIC;
13 BEGIN
14 K1: inv PORT MAP(b,w);
15 K2: nand2 PORT MAP(a,b,x);
16 K3: nand3 PORT MAP(w,c,d,y);
17 END struktura;
18 ---------------------------------------------

2.9.3 PORT MAP

Postoje dva načina za povezivanje portova komponente sa spoljašnjim signalima tokom njenog instanciranja:
poziciono i nominalno. Razmotrimo sledeći primer:
COMPONENT inv IS
PORT(a: IN STD_LOGIC; b: OUT STD_LOGIC);
END COMPONENT;
. . .
K1: inv PORT MAP(x,y);
Primenjeno je poziciono povezivanje: signali x i y odgovaraju portovima a i b, respektivno. Povezivanje je
implicitno, određeno redosledom u kome su portovi navedeni u deklaraciji komponente. Identično povezivanje
može se postići i sledećim nominalnim povezivanjem:
K1: inv PORT MAP(x=>a,y=>b);

Zapis x=>a znači da se signal x povezuje na port a, a y=>b da se y povezuje na port b. Povezivanje je
eksplicitno, jer se za svaki spoljašnji signal navodi porto na koji se povezuje. Kod nominalnog povezivanja,
redosled povezivanja nije bitan. Sledeća naredba instanciranja komponente ima identičan efekat kao i
prethodna:
K1: inv PORT MAP(y=>b,x=>a);
Poziciono povezivanje je lakše za pisanje, ali je zato nominalno preglednije. Portovi komponente mogu ostati i
nepovezani, što se postiže upotrebom ključne reči open:
K2: nase_kolo PORT MAP(x=>a, y=>b, w=>open, z=>d);

2.9.4 GENERIC MAP

Generičke komponente (sekcija ) takođe se mogu instancirati. Pri tome, naredbu instanciranja komponente treba
proširiti konstrukcijom GENERIC MAP koja postavlja vrednosti generičkih parametra, shodno sledećoj
sintaksi:
labela: ime_komponente GENERIC MAP (lista_parametara) PORT MAP(lista_portova);
Lista parametara, slično listi portova, definiše stvarne vrednosti generičkih parametara komponente. Kao i
PORT MAP, može se koristiti poziciono ili nominalno povezivanje. Korišćenje GENERIC MAP konstrukcije je
ilustrovano u sledećem primeru.

Sl. 2-64 Generički generator parnosti (ponovljena Sl. 2-12)

102
Pr. 2-60 Instancirane generičke komponente
Razmotrimo generički generator parnosti iz Pr. 2-19 ( Sl. 2-64), koji ulazni vektor (input) proširuje jednim bitom.
Ovaj bit ima vrednost ´0´ ako je broj 1-ca u ulaznom vektoru paran, odnosno vrednost ´1´ ako je broj 1-ca u
ulaznom vektoru neparan. Na ovaj način, izlazni vektor (output) uvek sadrži paran broj 1-ca.
Ispod je dat generički VHDL kôd generatora parnosti (tj. važi za svako pozitivno n). Prikazana su dva fajla:
parity_gen.vhd koji sadrži opis komponente generator_parnosti i pgen2.vhd koji sadrži glavni kôd u kome
se ova komponenta instancira.
Uočimo da će podrazumevana vrednost generičkog parametra (n=8) (fajl parity_gen.vhd, linija 3) biti prepisana
vrednošću n=2 koja se prenosi instanciranoj komponenti putem GENERIC MAP konstrukcije u fajlu pgen2.vhd
linija 16. Na ovaj način, glavni kôd realizuje 2-bitni generator parnosti. Napomenimo da je GENERIC
deklaracija u naredbi deklaracije komponente u glavnom kôdu (linije 9-13) neophodna, s obzirom da je deo
entiteta ove komponente (fajl parity_gen.vhd, linije 2-6). Međutim, u deklaraciji komponente nije neophodno
ponovo navoditi podrazumevane vrednosti generičkih parametra.
1 ----- fajl parity_gen.vhd ---------------------
2 ENTITY generator_parnosti IS
3 GENERIC (n : INTEGER := 8); -- podrazumevana vrednost je 7
4 PORT (input: IN BIT_VECTOR (n-1 DOWNTO 0);
5 output: OUT BIT_VECTOR (n DOWNTO 0));
6 END generator_parnosti;
7 ----------------------------------------------
8 ARCHITECTURE parnost OF generator_parnosti IS
9 BEGIN
10 PROCESS (input)
11 VARIABLE temp1: BIT;
12 VARIABLE temp2: BIT_VECTOR (output'RANGE);
13 BEGIN
14 temp1 := '0';
15 FOR i IN input'RANGE LOOP
16 temp1 := temp1 XOR input(i);
17 temp2(i) := input(i);
18 END LOOP;
19 temp2(output'HIGH) := temp1;
20 output <= temp2;
21 END PROCESS;
22 END parnost;
23 ----------------------------------------------

1 ----- fajl nas_kod.vhd ---------------------

2 ENTITY pgen2 IS
3 PORT (inp: IN BIT_VECTOR (1 DOWNTO 0);
4 outp: OUT BIT_VECTOR (2 DOWNTO 0));
5 END pgen2;
6 ----------------------------------------------
7 ARCHITECTURE parnost OF pgen2 IS
8 -- genericki generator parnosti --
9 COMPONENT generator_parnosti IS
10 GENERIC (n : INTEGER);
11 PORT (input: IN BIT_VECTOR (n-1 DOWNTO 0);
12 output: OUT BIT_VECTOR (n DOWNTO 0));
13 END COMPONENT;
14 -----------------------------------
15 BEGIN
16 G1: generator_parnosti GENERIC MAP(2) PORT MAP(inp, outp);
17 END parnost;
18 ---------------------------------------------
Pr. 2-61 Strukturni opis ALU
ALU (Aritmetičko logička jedinica) projektovana je u primeru. VHDL kôd iz tog primera bio je celovit, tj. nije
koristio spoljašnje komponente, funkcije ili procedure. U ovom primeru, pretpostavićemo da u projektnoj
biblioteci postoje komponente od kojih je ALU sačinjena (logic_unit, arith_unit i mux), a ALU ćemo realizovati
instanciranjem i odgovarajućim povezivanjem tih komponenti.

103
Osim glavnog kôda (fajl alu.vhd) ispod su dati i fajlovi sa kôdom korišćenih komponenti (arith.vhd, logic.vhd i
mux.vhd). Kao što se može videti, komponente su deklarisane u glavnom kôdu.
sel Operacija Funkcija Jedinica
0000 y <= a Transfer a
0001 y <= a + 1 Inkrement a
0010 y <= a - 1 Dekrement a
0011 y <= b Transfer b
Aritmetička
0100 y <= b + 1 Inkrement b
0101 y <= b - 1 Dekrement b
0110 y <= a + b Sabiranje a i b
0111 y <= a+b + cin Sabiranje a i b sa ul. pren.
1000 y <= NOT a Komplement a
1001 y <= NOT b Komplement b
1010 y <= a AND b I
1011 y <= a OR b ILI
Logicka
1100 y <= a NAND b NI
1101 y <= a NOR b NILI
1110 y <= a XOR b Iskljucivo ILI
1111 y <= a NXOR b Iskljucivo NILI
(a) (b)
Sl. 2-65 ALU: (a) Blok dijagram; (b) tabela istinitosti. (ponovljena Sl. 2-26)
1 ----- fajl arith_unit.vhd --------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE ieee.std_logic_unsigned.all;
5 ---------------------------------------------
6 ENTITY arith_unit IS
7 PORT (a,b : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
8 cin : IN STD_LOGIC;
9 sel : IN STD_LOGIC_VECTOR(2 DOWNTO 0);
10 x : OUT STD_LOGIC_VECTOR(7 DOWNTO 0));
11 END arith_unit;
12 ---------------------------------------------
13 ARCHITECTURE arith_unit OF arith_unit IS
14 SIGNAL arith, logic : STD_LOGIC_VECTOR(7 DOWNTO 0);
15 BEGIN
16 WITH sel(2 DOWNTO 0) SELECT
17 arith <= a WHEN "000",
18 a+1 WHEN "001",
19 a-1 WHEN "010",
20 b WHEN "011",
21 b+1 WHEN "100",
22 b-1 WHEN "101",
23 a+b WHEN "110",
24 a+b+cin WHEN OTHERS;
25 END arith_unit;
26 ---------------------------------------------
1 ----- fajl logic_unit.vhd --------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY logic_unit IS
6 PORT (a,b : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
7 sel : IN STD_LOGIC_VECTOR(2 DOWNTO 0);
8 x : OUT STD_LOGIC_VECTOR(7 DOWNTO 0));
9 END logic_unit;
10---------------------------------------------
11 ARCHITECTURE logic_unit OF logic_unit IS
12 BEGIN
13 WITH sel(2 DOWNTO 0) SELECT
14 x <= NOT a WHEN "000",
15 NOT b WHEN "001",

104
16 a AND b WHEN "010",
17 a OR b WHEN "011",
18 a NAND b WHEN "100",
19 a NOR b WHEN "101",
20 a XOR b WHEN "110",
21 NOT (a XOR b) WHEN OTHERS;
22 END logic_unit;
23 ---------------------------------------------

1 ----- fajl mux.vhd --------------------------

2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY mux IS
6 PORT (a,b : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
7 sel : IN STD_LOGIC;
8 x : OUT STD_LOGIC_VECTOR(7 DOWNTO 0));
9 END mux;
10---------------------------------------------
11 ARCHITECTURE mux OF mux IS
12 BEGIN
13 WITH sel SELECT
14 x <= a WHEN '0',
15 b WHEN OTHERS;
16 END mux;
17 ---------------------------------------------

1 ----- fajl alu.vhd (glavni kod) -------------

2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY alu IS
6 PORT (a,b : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
7 sel : IN STD_LOGIC_VECTOR(3 DOWNTO 0);
8 cin : IN STD_LOGIC;
9 y : OUT STD_LOGIC_VECTOR(7 DOWNTO 0));
10 END alu;
11 ---------------------------------------------
12 ARCHITECTURE alu OF alu IS
13 ----------------
14 COMPONENT arith_unit IS
15 PORT (a,b : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
16 cin : IN STD_LOGIC;
17 sel : IN STD_LOGIC_VECTOR(2 DOWNTO 0);
18 x : OUT STD_LOGIC_VECTOR(7 DOWNTO 0));
19 END COMPONENT;
20 ----------------
21 COMPONENT logic_unit IS
22 PORT (a,b : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
23 sel : IN STD_LOGIC_VECTOR(2 DOWNTO 0);
24 x : OUT STD_LOGIC_VECTOR(7 DOWNTO 0));
25 END COMPONENT;
26 ----------------
27 COMPONENT mux IS
28 PORT (a,b : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
29 sel : IN STD_LOGIC;
30 x : OUT STD_LOGIC_VECTOR(7 DOWNTO 0));
31 END COMPONENT;
32 ----------------
33 SIGNAL x1,x2: STD_LOGIC_VECTOR(7 DOWNTO 0);
34 BEGIN
35 U1: arith_unit PORT MAP (a,b,cin,sel(2 DOWNTO 0),x1);
36 U2: logic_unit PORT MAP (a,b,sel(2 DOWNTO 0),x2);
37 U3: mux PORT MAP (x1,x2,sel(3),y);
38 END alu;
39 ---------------------------------------------

105
2.9.5 GENERATE naredba u strukturnom opisu
GENERATE naredba je razmatrana u sekciji 2.4.4, u poglavlju posvećenom konkurentnom kôdu. Primeri koji
su tom prilikom analizirali ukazali su kako se ova naredba može koristiti za kreiranje konciznog konkurentnog
kôda. Ipak, moć GENERATE naredbe do punog izražaja dolazi tek u kombinaciji sa naredbama instanciranja
komponenti prilikom kreiranja generičkih regularnih struktura sačinjenih od većeg broja instanci jednostavnijih
komponenti.

Sl. 2-66 Pomerački registar iz Pr. 2-62

Pr. 2-62 Strukturni opis pomeračkog registra
U ovom primeru realizovaćemo strukturni opis generičkog pomerački registar sa asinhronim resetom.
Pomerački registar se sastoji iz n redno povezana DFF sa zajedničkim signalom takta i signalom za resetovanje
(Sl. 2-66). Rešenje koristi komponentu DFF za koju pretpostavljamo da je dostupna u radnoj biblioteci. FOR
GENERATE naredba generiše i povezuje n instanci D flip-flopa. Za povezivanje flip-flopova koristi se interni
n-bitni vektor z. Bitovi ovog vektora odgovaraju vezama između flip-flopova, kao na Sl. 2-66. Bit z(0)
preklopljen je sa ulaznim portom din, a bit z(n) sa izlaznim portom dout. Ulaz d i-tog flip-flopa povezan je sa
bitom z(i), a izlaz q sa signalom z(i+1).
1 -----------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -----------------------------------------------
5 ENTITY pomreg IS
6 GENERIC(n : INTEGER := 4);
7 PORT (din, clk, rst: IN STD_LOGIC;
8 dout: OUT STD_LOGIC);
9 END pomreg;
10-----------------------------------------------
11 ARCHITECTURE structural OF pomreg IS
12 ---------------------------------
13 COMPONENT dff IS
14 PORT (d, clk, rst: IN STD_LOGIC;
15 q: OUT STD_LOGIC);
16 END COMPONENT;
17 ---------------------------------
18 SIGNAL z : STD_LOGIC_VECTOR(0 TO n);
19 BEGIN
20 z(0) <= din;
21 dout <= z(n);
22 G1:FOR i IN 0 TO n-1 GENERATE
23 dffx : dff PORT MAP (d=>z(i),clk=>clk,rst=>rst,q=>z(i+1));
24 END GENERATE;
25 END structural;
26-----------------------------------------------

Sl. 2-67 n-bitni asinhroni brojač.

Pr. 2-63 Asinhroni brojač
Na Sl. 2-67 je prikazana struktura n-bitnog asinhronog binarnog brojača. Brojač se sastoji od n redno povezanih
T flip-flopova. Ulazni taktni signal, clk, pobuđuje samo prvi flip-flop (tff_0), dok se takt za svaki sledeći flip-

106
flop uzima sa izlaza prethodnog. S obzirom da se T flip-flopovi okidaju opadajućom ivicom takta (naznačeno
kružićem na ulazu za takt), i-ti flip-flop menja svoje stanje kada se stanja svih prethodnih flip-flopova promene
sa 1 na 0 (što odgovara binarnoj sekvenci brojanja).
VHDL opis se sastoji iz dva fajla: tff.vhd, koji sadrži kôd T flip-flopa (TFF) i asyn_counter.vhd, koji sadrži
generički opis n-bitnog asinhronog brojača, a u kome se TFF koristi kao komponenta. U arhitekturi T flip-flopa,
za čuvanje tekućeg stanja, koristi se pomoćni signal ff koji se postavlja na ´0´ ako je reset signal aktivan (linija
16), odnosno komplementira (linija 18), ako je detektovana opadajuća ivica taktnog signala, clk (linija 16).
Stanje flip-flopa se prenosi na izlaz q u liniji 21.
Strukturni VHDL kôd asinhronog brojača koristi FOR GENERATE naredbu za instanciranje n T flip-flopova.
Za prenos takta između flip-flopova uveden je (n+1)-bitni vektor c, koji se koristi na način kao na Sl. 2-67.
Signal c(0) prihvata ulazni takt (linija 20). i-ti flip-flop se taktuje signalom c(i), a njegov izlaz q pobuđuje signal
c(i+1) (linija 22). Bitovi 1, ..., n vektora c su ujedno i izlazi brojača (linija 24). Vremenski dijagram dobijen
simulacijom datog VHDL kôda, za n=4, prikazan je na Sl. 2-68.
1 ------ tff.vhd --------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -----------------------------------------------
5 ENTITY tff IS
6 PORT (clk, rst: IN STD_LOGIC;
7 q: OUT STD_LOGIC);
8 END tff;
9 -----------------------------------------------
10 ARCHITECTURE behavior OF tff IS
11 SIGNAL ff : STD_LOGIC;
12 BEGIN
13 PROCESS (clk, rst)
14 BEGIN
15 IF(rst='1') THEN
16 ff <= '0';
17 ELSIF (clk'EVENT AND clk='0') THEN
18 ff <= not ff;
19 END IF;
20 END PROCESS;
21 q <= ff;
22 END behavior;
23-----------------------------------------------
1 ----- asyn_counter.vhd ------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -----------------------------------------------
5 ENTITY asyn_count IS
6 GENERIC(n : INTEGER := 4);
7 PORT (clk, rst: IN STD_LOGIC;
8 q: OUT STD_LOGIC_VECTOR(n-1 DOWNTO 0));
9 END asyn_count;
10-----------------------------------------------
11 ARCHITECTURE structural OF asyn_count IS
12 ---------------------------------
13 COMPONENT tff IS
14 PORT (clk, rst: IN STD_LOGIC;
15 q: OUT STD_LOGIC);
16 END COMPONENT;
17 ---------------------------------
18 SIGNAL c : STD_LOGIC_VECTOR(n DOWNTO 0);
19 BEGIN
20 c(0) <= clk;
21 G1:FOR i IN 0 TO n-1 GENERATE
22 tffx : tff PORT MAP (clk=>c(i),rst=>rst,q=>c(i+1));
23 END GENERATE;
24 q <= c(n DOWNTO 1);
25 END structural;
26-----------------------------------------------

107
 Sl. 2-68 Rezultati simulacije za VHDL kôd iz Pr. 2-63

2.10 Funkcije i procedure

Funkcije i procedure se zajednički zovu potprogrami. Procedura može da vrati više od jednog argumenta, dok
funkcija vraća samo jedan. Svi parametri funkcije su ulazni, dok procedura može imati ulazne, izlazne i
ulazno/izlazne parametre. Po načinu konstrukcije funkcije i procedure su slične procesu u smislu da
predstavljaju zasebnu celinu sekvencijalnog VHDL kôda, koja sadrži iste sekvencijalne naredbe kao i proces
(IF, CASE i LOOP; u kôdu za sintezu WAIT nije dozvoljena). Međutim, što se primene tiče, između procesa sa
jedne i funkcija i procedura sa druge strane, postoji suštinska razlika. Dok su procesi namenjeni za korišćenje u
glavnom kôdu, funkcije i procedure se uglavnom smeštaju u biblioteke, tj. njihova namena je da realizuju često
korišćene delove kôda tako da se oni mogu ponovo koristiti ili razmenjivati sa drugim projektantima. Bez obzira
na to, potprogrami, ako je neophodno, mogu biti sadržani i u glavnom kôdu.

2.10.1 Funkcije
Između ostalog, funkcije se koriste da bi se realizovale neke tipične složenije logičke operacije i aritmetička
izračunavanja, obavila konverzija iz jednog u neki drugi tip podataka, ili kreirali novi operatori i atributi.
Jednom napisana, funkcija se može koristiti (pozivati) u glavnom kôdu proizvoljan broj puta. Na taj način,
glavni kôd postaje kompaktniji i razumljiviji.
Kao što je već rečeno, funkcija, ako i proces, može sadržati samo sekvencijalne naredbe (IF, CASE i LOOP).
Izuzetak je WAIT naredba koja nije dozvoljena u funkciji ako se ona koristi u kôdu namenjenom sintezi.
Takođe, u funkciji nije dozvoljeno deklarisati signale i instancirati komponente.
Za kreiranje i korišćenje funkcije, neophodna su dva dela: telo funkcije i poziv funkcije. Njihova sintaksa je
sledeća:
Telo funkcije:
FUNCTION ime_funkcije [<lista_parametara>] RETURN tip_podataka IS
[deklaracije]
BEGIN
(sekvencijalne naredbe)
END ime_funkcije;

U gornjoj sintaksi, <lista_parametara> definiše ulazne parametre funkcije. Broj parametara je proizvoljan
(uključujući i nulu). Parametri mogu biti konstante ili signali (varijable nisu dozvoljene), tj.:
<parametar> = [CONSTANT] ime_konstante : tip_konsatne;
<parametar> = SIGNAL ime_signala : tip_signala;
Tip parametra može biti bilo koji tip podatak koji se može sintetizovati (BOOLEAN, STD_LOGIC, INTEGER i
td.). Međutim, opseg ne treba navoditi (npr. RANGE za INTEGER ili TO/DOWNTO za
STD_LOGIC_VECTOR). Sa druge strane, funkcija može da vrati samo jednu vrednost čiji tip je naveden iza
ključne reči RETURN.
Na primer, razmotrimo funkciju:
FUNCTION f1 (a,b : INTEGER; SIGNAL c : STD_LOGIC_VECTOR) RETURN BOOLEAN IS
[deklaracije]
BEGIN
(sekvencijalne naredbe)
END f1;

108
Ime funkcije je f1. Funkcija ima tri parametra (a, b i c). Parametri a i b su konstante (uočimo da se ključna reč
CONSTANT može izostaviti), dok je parametar c signal. Parametri a i b su tipa INTEGER, a c tipa
STD_LOGIC_VECTOR. Uočimo da uz STD_LOGIC_VECTOR nije naveden opseg (TO ili DOWNTO). Tip
izlaznog parametra funkcije i BOOLEAN.
Poziv funkcije:
Poziv funkcije se uvek nalazi u nekom izrazu. Na primer:
x <= conv_integer(a); -- konvertuje a u INTEGER
y <= maximum(a,b); -- vraca vece od a i b
IF(x > maximum(a,b)) THEN ... -- poredi x sa vecim od a i b

Pr. 2-64 Funkcija positive_egde()

Funkcija iz ovog primera detektuje rastuću (pozitivnu) ivicu takta. Slična je naredbi IF(clk’EVENT AND
clk=’1’), koja se koristi u realizaciji sekvencijalnih kola (npr. DFF). Funkcija ima jedan parametar, signal tipa
STD_LOGIC i vraća vrednost tipa BOOLEAN.
-- Telo funkcije ------------------------------------------------
FUNCTION positive_edge (SIGNAL s : STD_LOGIC) RETURN BOOLEAN IS
BEGIN
RETURN (s’EVENT AND s=’1’);
END positive_edge;
-- Poziv funkcije ------------------------------------------------
. . .
IF positive_edge(clk) THEN ...
. . .
------------------------------------------------------------------

Pr. 2-65 Funkcija conv_integer()

Funkcija iz ovog primera konvertuje parametar tipa STD_LOGIC_VECTOR u odgovarajuću vrednost tipa
INTEGER. Na primer, za ulaz ˝0110˝ funkcija vraća 6. Kôd funkcije je u potpunosti generički, tj. ˝radi˝ za bilo
koji opseg (RANGE) i poredak (TO/DOWNTO) ulaznog parametra vector tipa STD_LOGIC_VECTOR. Kao
pomoćna promenljiva, u funkciji se koristi varijabla b tipa INTEGER. Njen opseg odgovara opsegu binarnih
brojeva sa vector’LENGTH bita (linija 3) . Na početku, b dobija vrednost bita najveće težine ulaznog vektora
(linije 5-7). Zatim, u petlji, počev od pozicije prve manje težine od najveće, pa do pozicije najmanje težine
(linija 8), b se množi sa 2 (linija 9) i uvećava za vrednost bita sa tekuće pozicije, i, u ulaznom vektoru (linije 10 i
11). Po izlasku iz petlje, b ima vrednost jednaku celobrojnom ekvivalentu ulaznog binarnog broja. Ova vrednost
se vraća iz funkcije naredbom RETURN (linija 13).
1 ---- telo funkcije --------------------------------
2 FUNCTION conv_integer(SIGNAL vector: STD_LOGIC_VECTOR) RETURN INTEGER IS
3 VARIABLE b: INTEGER RANGE 0 TO 2**vector'LENGTH-1;
4 BEGIN
5 IF(vector(vector'HIGH)='1') THEN b:=1;
6 ELSE b:=0;
7 END IF;
8 FOR i IN(vector'HIGH-1) DOWNTO (vector'LOW) LOOP
9 b:=b*2;
10 IF(vector(i)='1')THEN b:=b+1;
11 END IF;
12 END LOOP;
13 RETURN b;
14 END conv_integer;
15 ----------------------------------------------
---- poziv funkcije --------------------------
. . .
y <= conv_integer(a);
. . .
----------------------------------------------
Jedini ulazni parametar funkcije conv_integer() je signal. To znači da bi poziv funkcije u kome bi se kao
parametar umesto signala navela konstantna vrednost, npr. y<=conv_integer(˝00110011˝); bio
neispravan. Funkcija za konverziju konstantnih vektora tipa STD_LOGIC_VECTOR u INTEGER imala bi
zaglavlje:

109
FUNCTION conv_integer(CONSTANT vector: STD_LOGIC_VECTOR) RETURN INTEGER IS
ili
FUNCTION conv_integer(vector: STD_LOGIC_VECTOR) RETURN INTEGER IS
Napomenimo da ne postoji oblik funkcije conv_integer() koji bi omogućio konverziju varijable tipa
STD_LOGIC_VECTOR u INTEGER (zato što varijabla ne može biti ulazni parametar funkcije).

2.10.2 Pozicija funkcije

Funkcije (ili procedure) se najčešće pišu u paketu. Napisana u paketu, funkcija je vidljiva (tj. može se koristiti) u
svakom fajlu projekta u koji je paket uključen. Takođe, ako je to potrebno, funkcija se može pisati i u glavnom
kôdu (kao deo arhitekture ili entiteta). Međutim, u tom slučaju ona će biti vidljiva samo u arhitekturi/entitetu u
kome je napisana. Ako paket sadrži potprograme, tada je neophodno da takav paket ima i telo, u kome bi bila
sadržana tela svih funkcija i procedura navedenih u deklarativnom delu paketa. U nastavku su dati primeri oba
slučaja.
Pr. 2-66 Funkcija u glavnom kôdu
Kada je locirana u glavnom kôdu, funkcija može biti napisana bilo u ENTITY sekciji bilo u deklarativnom delu
sekcije ARCHITECTURE. U VHDL kôdu koji sledi, funkcija positiv_edge() iz Pr. 2-64 smeštena je u
deklarativnom delu arhitekture i iskorišćena za detekciju rastuće ivice takta u telu arhitekture koje realizuje D
flip-flop.
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY dff IS
6 PORT (d,clk,rst : IN STD_LOGIC;
7 q : OUT STD_LOGIC);
8 END dff;
9 ---------------------------------------------
10 ARCHITECTURE d_flip_flop OF dff IS
11 FUNCTION positive_edge (SIGNAL s : STD_LOGIC) RETURN BOOLEAN IS
12 BEGIN
13 RETURN (s'EVENT AND s='1');
14 END positive_edge;
15 BEGIN
16 PROCESS(clk,rst)
17 BEGIN
18 IF(rst='1') THEN q <= '0';
19 ELSIF positive_edge(clk) THEN q <= d;
20 END IF;
21 END PROCESS;
22 END d_flip_flop;
23 ---------------------------------------------
Pr. 2-67 Funkcija u paketu
Ovaj primer je sličan prethodno, sa jedinom razlikom što je sada funkcija positive_edge() locirana u paketu. U
delu PACKAGE funkcija se samo deklariše, dok se pravi opis funkcije (telo funkcije) nalazi u delu PACKAGE
BODY. Da bi funkcija bila dostupna u glavnom kôdu, dovoljno je klauzulom USE uključiti odgovarajući paket.
1 ----- paket: ---------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------------
5 PACKAGE nas_paket IS
6 FUNCTION positive_edge (SIGNAL s : STD_LOGIC) RETURN BOOLEAN;
7 END nas_paket;
8 ----------------------------------------------------
9 PACKAGE BODY nas_paket IS
10 FUNCTION positive_edge (SIGNAL s : STD_LOGIC) RETURN BOOLEAN IS
11 BEGIN
12 RETURN (s'EVENT AND s='1');
13 END positive_edge;
14 END nas_paket;
15----------------------------------------------------

110
1 ---- glavni kod ------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE work.nas_paket.all;
5 ----------------------------------------------------
6 ENTITY dff IS
7 PORT (d,clk,rst : IN STD_LOGIC;
8 q : OUT STD_LOGIC);
9 END dff;
10----------------------------------------------------
11 ARCHITECTURE d_flip_flop OF dff IS
12 BEGIN
13 PROCESS(clk,rst)
14 BEGIN
15 IF(rst='1') THEN q <= '0';
16 ELSIF positive_edge(clk) THEN q <= d;
17 END IF;
18 END PROCESS;
19 END d_flip_flop;
20----------------------------------------------------
Pr. 2-68 Primena funkcije conv_integer()
U ovom primeru ponovo ćemo razmotriti realizaciju RAM-a sa razdvojenim portovima za upis i čitanje
podataka iz 2.8, ali sa promenjenim zahtevom da tip adresnog porta, kao i portova za podatke bude
STD_LOGIC_VECTOR. Kod RAM-a iz poglavlja 2.8, adresni port je tipa INTEGER jer se vrednost sa ovog
ulaznog porta koristi kao indeks polja memory koje pamti sadržaja RAM-a. Promena tipa na
STD_LOGIC_VECTOR zahteva da se vrednost sa adresnog porta konvertuje u INTEGER prilikom pristupa
polju memory, za šta se u kôdu koji sledi koristi funkcija conv_integer() (linije 24 i 28 u fajlu ram.vhd). Kao
generički parametri sada se koriste M - broj bita u reči i N - broj adresnih bita (a ne broj reči u memoriji, kao
ranije). Sa N adresnih bita moguće je adresirati 2N memorijskih reči, što, zajedno sa brojem bita u reči, određuje
dimenzije polja mem_array (linije 16 i 17 u fajlu ram.vhd). Takođe, za detekciju rastuće ivice takta iskorišćena
je funkcija postive_edge() (linija 23 u fajlu ram.vhd). Obe korišćene funkcije smeštene su u paketu, nas_paket,
koji je uključen u glavni kôd (fajl ram.vhd).
1 ----- paket: ---------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------------
5 PACKAGE nas_paket IS
6 FUNCTION positive_edge (SIGNAL s : STD_LOGIC) RETURN BOOLEAN;
7 FUNCTION conv_integer(SIGNAL vector: STD_LOGIC_VECTOR) RETURN INTEGER;
8 END nas_paket;
9 ----------------------------------------------------
10 PACKAGE BODY nas_paket IS
11 --- funkcija positive_edge() --------------------
12 FUNCTION positive_edge (SIGNAL s : STD_LOGIC) RETURN BOOLEAN IS
13 BEGIN
14 RETURN (s'EVENT AND s='1');
15 END positive_edge;
16 --- funkcija conv_integer() --------------------
17 FUNCTION conv_integer(SIGNAL vector: STD_LOGIC_VECTOR) RETURN INTEGER IS
18 VARIABLE b: INTEGER RANGE 0 TO 2**vector'LENGTH-1;
19 BEGIN
20 IF(vector(vector'HIGH)='1') THEN b:=1; ELSE b:=0; END IF;
21 FOR i IN(vector'HIGH-1) DOWNTO (vector'LOW) LOOP
22 b:=b*2;
23 IF(vector(i)='1')THEN b:=b+1; END IF;
24 END LOOP;
25 RETURN b;
26 END conv_integer;
27 END nas_paket;
28 ----------------------------------------------------
1 -------ram.vhd -------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE work.nas_paket.all;

111
5 ----------------------------------------------------
6 ENTITY RAM IS
7 GENERIC (M: INTEGER := 8; -- broj bita po reci
8 N: INTEGER := 4); -- broj adresnih bitova
9 PORT (wr_ena, clk : IN STD_LOGIC;
10 addr : IN STD_LOGIC_VECTOR(2**N-1 DOWNTO 0);
11 data_in : IN STD_LOGIC_VECTOR(M-1 DOWNTO 0);
12 data_out : OUT STD_LOGIC_VECTOR(M-1 DOWNTO 0));
13 END RAM;
14 ----------------------------------------------------
15 ARCHITECTURE ram OF RAM IS
16 TYPE mem_array IS ARRAY (0 TO 2**N-1) OF
17 STD_LOGIC_VECTOR(M-1 DOWNTO 0);
18 SIGNAL memory : mem_array;
19 BEGIN
20 PROCESS(clk, wr_ena)
21 BEGIN
22 IF(wr_ena = '1') THEN
23 IF(positive_edge(clk)) THEN
24 memory(conv_integer(addr)) <= data_in;
25 END IF;
26 END IF;
27 END PROCESS;
28 data_out <= memory(conv_integer(addr));
29 END ram;
30----------------------------------------------------
Pr. 2-69 Preklapanje operatora ˝+˝
Funkcija iz ovog primera, nazvana ˝+˝, preklapa predefinisani operator sabiranja (˝+˝) (vidi 2.3.4). Predefinisano
˝+˝ može se primeniti samo nad sabircima tipa INTEGER, SIGNED ili UNSIGNED. Nova funkcija omogućiće
sabiranje vrednosti tipa STD_LOGIC_VECTOR. Funkcija je smeštena u paketu nas_paket. Primer korišćenja
funkcije dat je u kôdu koji sledi nakon paketa. Funkcija ima dva ulazna parametra, koji su kao i izlazna vrednost
tipa STD_LOGIC_VECTOR. Pretpostavićemo da su dužine oba ulazna i izlaznog vektora iste. Funkcija obavlja
sabiranje binarnih vektora bit-po-bit, počev od bitna najmanje težine. Za svaku bitsku poziciju, određuje se
odgovarajući bit sume, sum(i), i prenos, carry, koji se dodaje sledećoj poziciji.
1 ----- paket: ---------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------------
5 PACKAGE nas_paket IS
6 FUNCTION "+" (a,b: STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR;
7 END nas_paket;
8 ----------------------------------------------------
9 PACKAGE BODY nas_paket IS
10 --- funkcija „+“ --------------------
11 FUNCTION "+" (a,b: STD_LOGIC_VECTOR) RETURN STD_LOGIC_VECTOR IS
12 VARIABLE sum: STD_LOGIC_VECTOR(a'RANGE);
13 VARIABLE carry: STD_LOGIC;
14 BEGIN
15 carry := '0';
16 FOR i IN a'REVERSE_RANGE LOOP
17 sum(i) := a(i) XOR b(i) XOR carry;
18 carry := (a(i) AND b(i)) OR (a(i) AND carry) OR (b(i) AND carry);
19 END LOOP;
20 RETURN sum;
21 END "+";
22 END nas_paket;
23 ----------------------------------------------------
1 -------adder.vhd -------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE work.nas_paket.all;
5 ----------------------------------------------------
6 ENTITY adder IS
7 PORT ( a : IN STD_LOGIC_VECTOR(3 DOWNTO 0);
8 y : OUT STD_LOGIC_VECTOR(3 DOWNTO 0));

112
9 END adder;
10 ----------------------------------------------------
11 ARCHITECTURE adder OF adder IS
12 CONSTANT b : STD_LOGIC_VECTOR(3 DOWNTO 0) := "0110";
13 BEGIN
14 y <= a + b;
15 END adder;
16 ----------------------------------------------------
Napomenimo da postojanje funkcije za preklapanje operatora ˝+˝ ne znači zamenu predefinisanog operatora ˝+˝
novim, već proširenje njegove primene na novi tip podataka. To znači da i dalje možemo koristiti ˝+˝ za
sabiranje brojeva tipa INTEGER, SIGNED ili UNSIGNED. Koja od dve funkcije će biti primenjena,
predefinisana ili preklopljena, zavisi od tipa operanada na koje se ˝+˝ primenjuje.
Pr. 2-70 Funkcija aritmetičkog pomeranja
Funkcija iz ovog primera obavlja aritmetičko pomeranje udesno vrednosti tipa STD_LOGIC_VECTOR. Ulazni
parametri funkcije su: arg1, vektor koji se pomera, i arg2, iznos pomeraja. Funkcija je generička u smislu da
podržava ulazne vektore bilo koje dužine i poredak bitova (TO/DOWNTO). Za razliku od nekoliko prethodnih
primera, funkcija je locirana u glavnom kôdu.
1 ---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY shift_left IS
6 GENERIC (size: INTEGER := 4);
7 PORT (a : IN STD_LOGIC_VECTOR(size-1 DOWNTO 0);
8 x,y,z : OUT STD_LOGIC_VECTOR(size-1 DOWNTO 0));
9 END shift_left;
10---------------------------------------------
11 ARCHITECTURE behavior OF shift_left IS
12 FUNCTION srar (SIGNAL arg1 : STD_LOGIC_VECTOR; arg2: NATURAL)
13 RETURN STD_LOGIC_VECTOR IS
14 VARIABLE input: STD_LOGIC_VECTOR(size-1 DOWNTO 0) := arg1;
15 CONSTANT size : INTEGER := arg1'LENGTH;
16 VARIABLE copy : STD_LOGIC_VECTOR(size-1 DOWNTO 0)
17 := (OTHERS => arg1(arg1'RIGHT));
18 VARIABLE result: STD_LOGIC_VECTOR(size-1 DOWNTO 0);
19 BEGIN
20 IF(arg2 >= size-1) THEN result := copy;
21 ELSE result := copy(arg2 DOWNTO 0) & input(size-2 DOWNTO arg2);
22 END IF;
23 RETURN result;
24 END srar;
25 BEGIN
26 x <= srar(a,0);
27 y <= srar(a,1);
28 z <= srar(a,2);
29 END behavior;
30 ---------------------------------------------
Funkcija srar koristi dve pomoćne varijable: input koja se prilikom deklaracija inicijalizuje na vrednost ulaznog
vektora, i size čija je inicijalna vrednost jednaka dužini ulaznog vektora (Ovo dve varijable su neophodne zato
što unutar funkcije nije dozvoljeno menjati ulazne parametre). Konstanta copy je vektor čiji su svi bitovi jednaki
krajnjem levom bitu ulaznog vektora. Kod aritmetičkog pomeranja na desno za arg2 pozicija, pozicije sa leve
strane (njih arg2) koje ostaju upražnjene popunjavaju se vrednošću krajnjeg levog bita ulaznog vektora (Sl.
2-69). Ako je zadati pomeraj jednak ili veći od size-1, rezultat je vektor ispunjen krajnjim levim bitom ulaznog
vektora.

Sl. 2-69 Ilustracija aritmetičkog pomeranja na levo.

113
Pr. 2-71 Množač
U ovom primeru realizovana je funkcija mult() koja množi dve UNSIGNED vrednosti i vraća njihov
UNSIGNED proizvod. Parametri koji se prosleđuju funkciji ne moraju imati istu dužinu, a poredak njihovih
bitova može biti proizvoljan (TO/DOWNTO). Funkcija je smeštena u paketu pck. Osim paketa, u VHDL kôdu
koji sledi, dat je i jedan primer korišćenja funkcije mult().
1 ----- paket: ---------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE ieee.std_logic_arith.all;
5 ----------------------------------------------------
6 PACKAGE pack IS
7 FUNCTION mult (a,b: UNSIGNED) RETURN UNSIGNED;
8 END pack;
9 ----------------------------------------------------
10 PACKAGE BODY pack IS
11 FUNCTION mult (a,b: UNSIGNED) RETURN UNSIGNED IS
12 CONSTANT max : INTEGER := a'LENGTH + b'LENGTH - 1;
13 VARIABLE aa: UNSIGNED(max DOWNTO 0) :=
14 (max DOWNTO a'LENGTH => '0') & a(a'LENGTH-1 DOWNTO 0);
15 VARIABLE prod: UNSIGNED(max DOWNTO 0) := (OTHERS => '0');
16 BEGIN
17 FOR i IN 0 TO a'LENGTH-1 LOOP
18 IF(b(i)='1') THEN prod := prod + aa;
19 END IF;
20 aa := aa(max-1 DOWNTO 0) & '0';
21 END LOOP;
22 RETURN prod;
23 END mult;
24 END pack;
25 ----------------------------------------------------
1 ------- glavni kod ---------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE ieee.std_logic_arith.all;
5 USE work.pack.all;
6 ----------------------------------------------------
7 ENTITY multiplier IS
8 GENERIC (size: INTEGER := 4);
9 PORT ( a,b : IN UNSIGNED(size-1 DOWNTO 0);
10 y : OUT UNSIGNED(2*size-1 DOWNTO 0));
11 END multiplier;
12 ----------------------------------------------------
13 ARCHITECTURE behavior OF multiplier IS
14 BEGIN
15 y <= mult(a,b);
16 END behavior;
17----------------------------------------------------

2.10.3 Procedure
Procedura je slična funkciji i u osnovi ima istu namenu. Međutim, za razliku od funkcije, procedura može vratiti
više od jedne vrednosti.
Kao i kod funkcija, dva dela su potrebna za konstrukciju i poziv procedure: telo i poziv procedure.
Telo procedure:
PROCEDURE ime_procedure [<lista_parametara>] IS
[deklaracije]
BEGIN
(sekvencijalne naredbe)
END ime_procedure;
U gornjoj sintaksi, <lista_parametara> sadrži ulazne i izlazne parametre procedure:
<parametar> = [CONSTANT] ime_konstante : mode tip_konstante;
<parametar> = SIGNAL ime_signala : mode tip_signala;
<parametar> = VARIABLE ime_signala : mode tip_varijable;

114
Procedura može imati proizvoljan broj IN, OUT i INOUT parametara, koji mogu biti signali, varijable ili
konstante. Za ulazne parametre (mode=IN), podrazumeva se CONSTANT, dok se za izlazne (mode=OUT ili
INOUT) podrazumeva VARIABLE.
Kod funkcija, deklaracije WAIT, SIGNAL i COMPONENT nisu dozvoljene ako se funkcija koristi u kôdu za
sintezu. Isto važi i za procedure, sa izuzetkom da signali mogu biti deklarisani u proceduri, ali samo pod
uslovom da je takva procedura deklarisana u procesu. Uz to, pored WAIT, i bilo koji drugi način za detekciju
ivice takođe ne može biti sintetizovan ako je deo procedure (npr. konstrukcija tipa s'EVENT AND s='1' nije
dozvoljena u proceduri).
Procedura, čije je zaglavlje prikazano ispod ima tri ulazna parametra, a, b i c (mode=IN). Parametar a je
konstanta tipa BIT, dok su b i c signali istog tipa. Uočimo da za ulazne parametre ključna reč CONSTANT nije
neophodna. Procedura vraća dva signala, x (mode=OUT i tip=BIT_VECTOR) i y (mode=INOUT,
tip=INTEGER).
PROCEDURE nasa_procedura(a: IN BIT; SIGNAL b,c: IN BIT;
SIGNAL x: OUT BIT_VECTOR(7 DOWNTO 0);
SIGNAL y: INOUT INTEGER RANGE 0 TO 99) IS
BEGIN
. . .
END nasa_procedura;

Poziv procedure:
Za razliku od funkcije, čiji je poziv je uvek deo nekog izraza, procedure se mogu tretirati kao nezavisne naredbe,
koje se mogu pozivati samostalno ili biti pridružene nekoj drugoj naredbi.
Primeri poziva procedure:
min_max(in1, in2, in3, out1, out2); -- samostalan poziv procedure
deljenje(deljenik, delilac, kolicnik, ostatak); -- samostalan poziv procedure
IF(a>b) THEN min_max(in1,in2,in3,out1,out2); --procedura pridružena drugoj naredbi

2.10.4 Pozicija procedure

Procedure se pišu na istim mestima u VHDL kôdu gde i funkcije. Kao i za funkcije, tipično mesto procedure je
u paketu, ali po potrebi može biti locirana i u glavnom kôdu (bilo u entitetu bilo u deklarativnom delu
arhitekture). Paket koji sadrži proceduru mora imati telo (PACKAGE BODY) u kome će biti napisana tela svih
procedura deklarisanih u deklarativnom delu paketa.

Sl. 2-70 min_max kolo iz Pr. 2-72

Pr. 2-72 Procedura u glavnom kôdu
VHDL kôd iz ovog primera realizuje min_max kolo (Sl. 2-70) uz pomoć procedure koja se zove sort. Ulazni
parametri procedure su dva neoznačena 8-bitna cela broja, inp1 i inp2, a izlazni min_out i max_out istog tipa.
Procedura poredi ulazne vrednosti i manju prenosi na izlaz min_out, a veću na max_out. Procedura je locirana u
deklarativnom delu arhitekture (glavni kôd).
1---------------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY min_max IS
6 GENERIC(limit : INTEGER := 255);
7 PORT (ena : IN BIT;
8 inp1,inp2 : IN INTEGER RANGE 0 to limit;
9 min_out, max_out: OUT INTEGER RANGE 0 to limit);
10 END min_max;

115
11 ---------------------------------------------
12 ARCHITECTURE nasa_arhitektura OF min_max IS
13 ---------------------------------------
14 PROCEDURE sort(SIGNAL in1,in2 : IN INTEGER RANGE 0 to limit;
15 SIGNAL min, max: OUT INTEGER RANGE 0 to limit) IS
16 BEGIN
17 IF(in1 > in2) THEN
18 max <= in1;
19 min <= in2;
20 ELSE
21 max <= in2;
22 min <= in1;
23 END IF;
24 END sort;
25 ---------------------------------------
26 BEGIN
27 PROCESS(ena)
27 BEGIN
29 IF(ena='1') THEN sort(inp1,inp2,min_out,max_out);
30 END IF;
31 END PROCESS;
32 END nasa_arhitektura;
33 ---------------------------------------------
Pr. 2-73 Procedura u paketu
Ovaj primer sličan je prethodnom, s jedinom razlikom što je sada procedura sort smeštena u paketu. Na taj
način, procedura se može koristiti u različitim projektima. VHDL kôd je podeljen u dva fajla, koji se nezavisno
kompajliraju: jedan za paket, a drugi za glavni kôd.
1 ----- paket: ---------------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 ----------------------------------------------------
5 PACKAGE nas_paket IS
6 CONSTANT limit: INTEGER := 255;
7 PROCEDURE sort(SIGNAL in1,in2 : IN INTEGER RANGE 0 to limit;
8 SIGNAL min, max: OUT INTEGER RANGE 0 to limit);
9 END nas_paket;
10 ----------------------------------------------------
11 PACKAGE BODY nas_paket IS
12 PROCEDURE sort(SIGNAL in1,in2 : IN INTEGER RANGE 0 to limit;
13 SIGNAL min, max: OUT INTEGER RANGE 0 to limit) IS
14 BEGIN
15 IF(in1 > in2) THEN
16 max <= in1;
17 min <= in2;
18 ELSE
19 max <= in2;
20 min <= in1;
21 END IF;
22 END sort;
23 END nas_paket;
24 ----------------------------------------------------

1 ----- glavni kod -----------------------------------

2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE work.nas_paket.all;
5 ---------------------------------------------
6 ENTITY min_max IS
7 GENERIC(limit : INTEGER := 255);
8 PORT (ena : IN BIT;
9 inp1,inp2 : IN INTEGER RANGE 0 to limit;
10 min_out, max_out: OUT INTEGER RANGE 0 to limit);
11 END min_max;
12 ---------------------------------------------
13 ARCHITECTURE nasa_arhitektura OF min_max IS
14 BEGIN

116
15 PROCESS(ena)
16 BEGIN
17 IF(ena='1') THEN sort(inp1,inp2,min_out,max_out);
18 END IF;
19 END PROCESS;
20 END nasa_arhitektura;
21 ---------------------------------------------

2.10.5 Poređenje funkcija i procedura

• Funkcija ima nula ili više ulaznih parametara i samo jednu izlaznu vrednost. Ulazni parametri mogu
biti konstante i signali (ali ne i varijable). Podrazumevaju se konstante.
• Procedura može imati proizvoljan broj IN, OUT ili INOUT parametara, koji mogu biti signali,
konstante ili varijable. Za ulazne parametre (IN) podrazumevaju se konstante, a za izlazne (OUT ili
INOUT) varijable.
• Funkcija se poziva kao deo nekog izraza, dok je procedura naredba za sebe.
• Za funkcije, kao i za procedure, važi da se naredbe WAIT i COMPONENT ne mogu sintetizovati.
• Procedure i funkcije se mogu pisati na istim mestima u kôdu. Uobičajeno se smeštaju u paket (iz
razloga ponovnog korišćenja), ali mogu biti locirane i u glavnom kôdu (unutar arhitekture ili entiteta).
Paket koji sadrži funkcije ili procedure, mora imati i telo (PACKAGE BODY) u kome će biti smeštena
tela svih funkcija/procedura deklarisanih deklarativnom delu paketa.

2.10.6 ASSERT
ASSERT je naredba koja se ne sintetizuje, a čija je funkcija da ispisuje poruke (na primer, na ekranu) kada se u
toku simulacije javi neki problem. Zavisno od ˝ozbiljnosti˝ problema, ASSERT naredba može da zaustavi
simulaciju. Njena sintaksa je:
ASSERT uslov
[REPORT “poruka”]
[SEVERITY nivo_kritičnosti]
Nivo kritičnosti može biti: Note (obaveštenje), Warning (upozorenje), Error (greška) ili Failure (otkaz). Poruka
se ispisuje kada je uslov netačan.
Pretpostavimo da smo napisali funkciju koja sabira dva binarna broja, gde je usvojeno da ulazni parametri
moraju imati isti broj bita. Da bi smo proverili da li je ovaj zahtev ispunjen, u telo funkcije možemo umetnuti
ASSER naredbu:
ASSERT a’LENGTH = b’LENGTH
REPORT “Error: vektori nemaju istu duzinu”
SEVERITY failure;
Kategorija note je korisna kao obaveštenje projektantu šta se trenutno dešava u kôdu koji se simulira. Kategorija
warning se može koristiti za situacije koje iako nisu katastrofalne, mogu eventualno kasnije da dovedu do
greške. Nivo error se može koristiti da upozori projektanta na pojavu situacije koja može imati katastrofalne
efekte. (Na primer, ako se pretpostavlja da neko izračunavanje treba uvek da vrati pozitivnu vrednost, a desi se
da vrati negativnu, zavisno od okolnosti to se može smatrati greškom.) Kategorija failure označava uslove koji
neizostavno uzrokuju katastrofalne posledice, na primer, deljenje nulom, ili indeks polja izvan granica.
Napomenimo još jedanput da ASSER naredba ne generiše hardver. Alati za sintezu jednostavno ignorišu ovu
naredbu.

117
3 RTL projektovanje
3.1 Projektovanje odozgo-naniže
Postoje dva osnovna pristupa rešavanju problema: ¨odozdo-naviše¨ (bottom-up) i ¨odozgo-naniže¨ (top-down).
Kod pristupa ¨odozdo-naviše¨, projektant započinje rad rešavanjem nekog izdvojenog detalja celokupnog
problema. Nakon toga, projektant prelazi na neki drugi detalj, koji nije u vezi sa prvim. Konačno, projektant
dolazi u situaciju da spaja nezavisno rešene delove problema u konačno rešenje. Kod problema većeg obima,
pojedinačno rešavani delovi se obično ne uklapaju idealno jedni s drugim. To je posledica samog pristupa koji
fokusiranjem na izdvojene detalje odvlači pažnju projektanta sa slike o celovitosti rešenja. Konačni rezultat je
takav da se najveći deo ukupnog projektantskog vremena troši na uklapanje nezavisnih detalja, što često
uključuje i prepravku već rešenih delova opšteg problema.
Kod pristupa ¨odozgo-naniže¨, projektant započinje rad na problemu razradom globalnog plana što
podrazumeva sveobuhvatno sagledavanje problema, razradu strategije rešavanja problema, dekompoziciju
problema na potprobleme manjeg obima, i definisanje odnosa između pojedinih potproblema. Drugim rečima,
projektant se trudi da polazni problem, koji je obično isuviše obiman da bi se rešio ¨u jednom dahu¨, razloži na
veći broj jasno definisanih problema manjeg obima. Pri tome, projektant ne rešava odmah uočene potprobleme,
već ih tretira kao apstraktne sklopove (crne kutije) koje međusobno uklapa i povezuje. U drugoj fazi
projektovanja, projektant nastavlja sa razradom i rešavanjem uočenih potproblema. Pri tome, projektant može
slobodno da se usredsredi na svaki pojedinačni, prethodno definisani potproblem, bez brige oko njihovog
uklapanja, koje je razradio u prvoj fazi projekta i time ih ugradio u definiciju svakog pojedinačnog potproblema.
Projektanti-početnici obično ne doživljavaju projektovanje ¨odozgo-naniže¨ kao prirodni pristup. Prirodno je da
neko ko nema iskustva u projektovanju hardvera bude zabrinut detaljima koji se odnose na realizaciju (kao
razvesti napajanje, koja digitalna kola koristiti i kako ih povezati, i td.). Pristup ¨odozgo-naniže¨ zasnovan je na
iskustvu i samopouzdanju projektanta: neko ko je ranije rešavao detalje slične onima koji se javljaju u tekućem
problemu, može ignorisati te detalje u toku razrade globalnog plana, siguran da će onda kada pređe na
realizaciju svog plana, moći da reši svaki od izdvojenih potproblema.
Generalno, projektovanje ¨odozgo-naniže¨ ostvaruje se u sledeće tri faze:
• Opis ponašanja
• Razrada
• Realizacija

3.2 Opis ponašanja

Opis ponašanja je najvažnija faza celokupnog procesa projektovanja. U ovoj fazi, sistem koja se projektuje
opisuje se na algoritamskom nivou, npr. u vidu ASM dijagrama. Jedina struktura koja postoji u ovoj fazi je blok
dijagram koji specificira ulazne i izlazne portove sistema. Drugim rečima, u ovoj fazi, sistem se tretira kao crna
kutija sa naznačenim ulazima i izlazima koja se ponaša na način koji je opisan algoritmom (ASM dijagramom).
Obično, projektant ne kreira samo jedan ASM dijagram, već istražuje različite opcije i varijante mogućih
rešenja, vrednujući ih u skladu sa postavljenim performansnim kriterijumima (brzina rada, hardverska složenost
i sl.). Napomenimo da ASM dijagram, iako apstraktni opis, pruža dovoljno informacija na osnovu kojih se može
odrediti broj taktnih ciklusa potrebnih za obavljanje pojedinih aktivnosti i grubo proceniti složenost hardverske
realizacije, na primer, na osnovu broja registarskih promenljivih.

3.2.1 Interfejs
Pored algoritma koji definiše osnovnu funkciju sistema, opis ponašanja sadrži i specifikaciju interfejsa. Kao
pojam, interfejs označava mesto na kome se dva nezavisna sistema susreću ili spajaju (ili sredstvo koje koriste)

118
radi zajedničkog dejstva ili međusobne komunikacije. Digitalni sistem u toku rad ineraguje sa svojim
okruženjem. Okruženje mogu činiti drugi digitalni sistemi, ne-digitalni uređaji, kao što su prekidači ili senzori,
pa čak i čovek koji posredstvom odgovarajućih ulazno-izlaznih uređaja komunicira sa sistemom. Rećićemo da
se okruženje digitalnog sistema sastoji od nezavisnih aktora, koji koordinirano, ali u paraleli, rade i interaguju
kako sa digitalnim sistemom tako i između sebe. Sa tačke gledišta projektanta digitalnog sistema, detalji koji se
odnose na rad i implementaciju aktora nisu od značaja. Za projektanta je bitno je da poznaje informacije koje se
razmenjuju između sistema i aktora kao i način na koji aktori komuniciraju sa sistemom, kako bi mogao da ih
ugradi u specifikaciju interfejsa. Za razliku od projektanta digitalnog hardvera, programeri imaju na
raspolaganju standardne, sofisticirane korisničke interfejse (tastatura, miš, monitor), koji olakšavaju korisnicima
da interaguju sa softverom. Korisnički interfejsi ovog tipa rešavaju dva bazična problema koji se uvek javljaju
kada dva aktora pokušavaju da komuniciraju: (a) koji podaci se razmenjuju u toj komunikaciji i (b) kada i kako
obaviti prenos informacije. Kod projektovanja hardvera, javljaju se isti problemi, ali, sada je odgovornost na
projektantu digitalnog sistema da ih reši.
statusni/ statusni/
.. .. upravljacki
upravljacki . .
ulazi izlazi

.. DIGITALNI .. izlazi
ulazi
podataka . SISTEM . podataka

rst
clk

Sl. 3-1 Uopšteni blok dijagram digitalnog sistema.

Specifikacija interfejsa digitalnog sistema uključuje specifikaciju ulaza i izlaza (tj. portova) proširenu pravilima
za korišćenje sistema od strane korisnika. U opštem slučaju, digitalni sistem sa aktorima iz okruženja
razmenjuje dva tipa ulaznih i izlaznih informacija: (a) upravljački i statusni signali i (b) podaci (Sl. 3-1).
Upravljački i statusni signali su najčešće jednobitni, dok su podaci višebitni signali. Putem upravljačkih ulaza,
aktor inicira neku akciju sistema, dok preko statusnih obaveštava sistem o svom trenutnom stanju. Preko
statusnog ulaza sistem dobija odgovor na pitanje tipa ¨da-ne¨, kao što je, na primer, pitanje: ¨da li je prekidač
zatvoren?¨ U ASM dijagramu koji opisuje ponašanje sistema, imena statusnih i upravljačkih ulaza se javljaju
samo unutar blokova grananja, tj. koriste se za donošenje direktnih odluka, ali ne i za neka druga izračunavanja.
Slično, sistem koristi upravljačke izlaze da bi inicirao neku akciju aktora, a statusne da bi obavestio okruženje o
svom trenutnom stanju (npr. ´izračunavanje je završeno´). Klasifikacija na upravljačke i statusne signale nije
stroga, a projektant ima slobodu da klasifikaciju obavi na način za koji smatra da je najprikladniji u kontekstu
konkretnog problema. Ulazi podataka imaju istu ulogu kao i ulazne promenljive kod konvencionalnih
programskih jezika, tj. za prosleđivanje sistemu informacije koju on treba da obradi. U ASM dijagramu ulazi
podataka se uvek javljaju samo sa desne strane naredbi registarskog prenosa i/ili uslova u blokovima grananja.
Preko izlaza podataka sistem predaje okruženju obrađenu informaciju (analogno izlaznim promenljivama kod
programskih jezika). Vrednost koja se postavlja na izlaz podataka uzima se iz nekog internog registra sistema.
Dodatno, sekvencijalni digitalni sistemi poseduju još dva signala: signal takta, clk, i signal asinhronog
resetovanja, rst, kojim se sistem, na početku rada, postavlja u početno stanje. Pošto su ova dva signala
podrazumevana, oni se obično i ne crtaju.
PASIVNO
rdy

0 1
start

Blokovi stanja, grananja i

uslovnog izlaza koji
realizuju izracunavanje
kolicnika. (ova stanja ne
start rdy postavljaju signal rdy
SEKVENCIJALNI
x DELITELJ
q
y

(a) (b)
Sl. 3-2 Sekvencijalni delitelj: (a) blok dijagram; (b) ASM opis ponašanja interfejsa.

119
Pr. 3-1 Interfejs sekvencijanog delitelja
Na Sl. 3-2(a) je prikazan blok dijagram sekvencijalnog delitelja. Kolo obavlja operaciju q=x/y, gde su x i y
neoznačeni celi brojevi. Upravljački ulaz start se koristi za startovanje rada delitelja, a po završenom deljenju
sistem postavlja rezultat na izlaz podataka q i aktivira statusni izlaz rdy. Osim ulaza i izlaza, interfejs može
definisati i neka dodatna ograničenja koja se odnose na interakciju sistema i korisnika. Na primer, mogu se
postaviti sledeći zahtevi:
1) Pre aktiviranja upravljačkog ulaza start (start=1) korisnik, treba da postavlja deljenik i delilac na ulazima
podatak x i y. Korisnik ne sme da menja x i y za vreme dok traje izračunavanje (dok je rdy=0).
2) Trajanje signala start mora biti tačno jedan taktni period.
3) Korisnik je u obavezi da pre sledećeg aktiviranja signala start čeka barem dva taktna ciklusa nakon što je
sistem završio prethodno izračunavanje.
Kao što se može zaključiti, specifikacija interfejsa uključuje specifikaciju ulaza i izlaza, proširenu pravilima za
korišćenje sistema od strane korisnika. U suštini, interfejs predstavlja neku vrstu ugovora između dva aktora,
koga se moraju pridržavati obe strane kako bi krajnji rezultat njihove interakcije bio korektan. ¨Prijateljski¨
korisnik je onaj koji se u radu sa sistemom pridržava svih navedenih ograničenja.
Globalni oblik ASM dijagrama, koji opisuje ponašanje korisničkog interfejsa sekvencijalnog delitelja prikazan
je na Sl. 3-2(b). Za sada ASM dijagram ima samo jedno stanje, PASIVNO, u kome čeka na aktiviranje signala
start i pri tome drži na izlazu rdy vrednost 1. U nastavku projektovanja, ¨oblak¨ u ASM dijagramu biće
zamenjen blokovima stanja, grananja i uslovnih izlaza, uz pomoć kojih će biti opisan rad algoritma za deljenje.
Međutim, ni u jednom od blokova stanja ili uslovnog izlaza sadržanih u ¨oblaku¨ neće postojati naredba koja će
postavljati signal rdy. To znači da u prvom narednom taktnom periodu nakon što korisnik aktivira signal start,
signal rdy postaje 0 i zadržava ovu vrednost za sve vreme izračunavanja količnika. Nakon što količnik bude
izračunat i ASM se vrati u stanje PASIVNO, signal rdy će ponovo uzeti vrednost 1.
Pr. 3-2 Handshake interfejs
Za prenos podataka između digitalnih sistema često se koristi tzv. handshake interfejs. Handshake se odnosi na
način koordinacije koji se ostvaruje putem dva signala, req (request - zahtev) i ack (acknowladge - potvrda) (Sl.
3-3(a)). Jedan sistem je predajnik, a drugi prijemnik. Aktivnosti predajnika i prijemnika tokom jednog ciklusa
prenosa podatka prikazani su vremenskim dijagramom sa Sl. 3-3(b). Predajnik postavlja na magistralu data
podatak koji želi da preda prijemniku i aktivira signal req (1). Sa druge strane, prijemnik čeka na zahtev i po
njegovom prijemu (req=1), prihvata podatak sa magistrale data, i preko signala ack potvrđuje prijem (ack=1,
(2)). Nakon prijema potvrde, predajnik deaktivira signal req (3), kako bi se pripremio za sledeći prenos (1).
req=0 je znak prijemniku da treba da deaktivira signal potvrde, (ack=0, (4)) i nastavi da čeka na novi zahtev.
Delimični ASM dijagrami predajnika i prijemnika, koji se opisuju ponašanje handshake interfejsa prikazani su
na Sl. 3-3(c) i (d).

(a) (b)

120
 . . .
. . .
. . .

. . .
(c) (d)
Sl. 3-3 Handshake interfejs: (a) blok dijagram; (b) vremenski dijagram; (c) ASM dijagram predajnika; (d) ASM
dijagram prijemnika.

3.2.2 Konverzija algoritma u ASM dijagram

Procese rešavanja datog problema obično počinje kreiranje algoritma visokog nivoa. Algoritam se piše u obliku
pseudo koda ili dijagrama toka i kao takav, u suštini, predstavlja softversko rešenje datog problema. Osnovna
pretpostavka kod softverskog algoritma je da se algoritamski koraci izvršavaju jedan za drugim, strogo
sekvencijalno. Može se desiti da su dve ili više sukcesivnih operacija međusobno nezavisne i da bi zbog toga
mogle biti izvršene istovremeno (paralelno). Međutim, pomoću softverskog algoritma nije moguće izraziti
paralelizam. Takođe, softverski algoritam ne sadrži informaciju o trajanju operacija. Razlog za to je takođe
pretpostavka o sekvencijalnom izvršenju koje garantuje da konačni rezultat ne zavisi od vremena izvršenja
pojedinačnih operacija. Zbog svega navedenog, softverski algoritam nije pogodno sredstvo za opis ponašanja
digitalnih sistema.
Digitalni sistem se obično sastoji iz više komponenti koje rade paralelno i neprekidno i u mogućnosti su da
izvršavaju različite operacija. Digitalni sistem se pobuđuje taktnim signalom, a u svakom taktnom periodu u
mogućnosti je da izvrši jednu ili više elementarnih operacija. Ovakav model izračunavanja, koji dozvoljava
paralelizam i nameće diskretizaciju vremena, efikasno se prestavlja ASM dijagramom. ASM dijagram definiše
stanja digitalnog sistema i operacije koje se izvršavaju u svakom stanju. Svako stanje traje jedan taktni period, a
sve operacije pridružene stanju izvršavaju se istovremeno (u paraleli).
Međutim, algoritam je obično teže predstaviti u obliku ASM dijagrama nego u obliku softverskog dijagrama
toka ili pseudo koda. Iz tog razloga, opis ponašanja digitalnog sistema tipično počinje kreiranjem softverskog
algoritma, koji se potom konvertuje u ekvivalentni ASM dijagram.
U ovoj sekciji biće opisano kako se algoritam, predstavljen u obliku pseudo koda ili dijagrama toka, može
konvertovati u ASM dijagram. Osnovna pretpostavka kod softverskog algoritma jeste da se operacije izvršavaju
jedna za drugom, strogo sekvencijalno, tako što izvršenje sledeće operacije počinje u trenutku kada se tekuća
završi. Sa druge strane, ASM dijagrami ne nameću strogu sekvencijalnost u izvršavanju algoritamskih operacija,
s obzirom na pretpostavku da se sve operacije navedene u istom bloku stanja izvršavaju u paraleli. Iz tog
razloga, direktno prevođenje softverskog algoritma u ASM dijagram, naredba po naredba, nije korektno. Da bi
rezultujući ASM bio korektan, neophodno je prilikom prevođenja, u ASM dijagram uvesti dodatna ograničenja
kako zavisnosti između softverskih naredbi ne bi bile narušene. To se postiže primenom sledećih pravila:
1. Svaka naredba dodele softverskog algoritma se prevodi u naredbu registarskog prenosa koja se smešta
u zaseban blok stanja ASM dijagrama iza koga ne sledi blok grananja.
2. Svaka if ili while naredba softverskog algoritma se transformiše u prazan blok stanja nakon koga
sledi blok grananja sa upisanom relacijom iz softverske naredbe.
Promenljive iz softverskog algoritma se tretiraju kao registri, a naredbe dodele kao naredbe registarskog
prenosa. Ograničenja sadržana u pravilima 1 i 2 obezbeđuju da se u bloku grananja neće javiti promenljiva kojoj
je u prethodnom bloku stanja dodeljena nova vrednost. (Podsetimo se da se blok stanja zajedno sa pridruženim
grananjima izvršava u jednom taktnom periodu, a da se upis nove vrednosti u registar obavlja tek na kraju
taktnog perioda.).

121
Pr. 3-3 ASM dijagram sekvencijalnog delitelja
U cilju ilustracije konverzije softverskog algoritma u ASM dijagrama razmotrićemo hardversku realizaciju
sekvencijalnog delitelja neoznačenih celih brojeva. Blok dijagram i interfejs delitelja specificirani su u Pr. 3-1.
Mada, za ovu namenu postoji veći broj efikasnih i brzih algoritama, u ovom primeru biće korišćen trivijalni
algoritam deljenja, koji se zasniva na uzastopnom oduzimanju delioca od deljenika. Rad algoritma prikazan je u
vidu sledećeg pseudo koda:
r1 = x;
r2 = 0;
while (r1 >= y)
{ r1 = r1 – y;
r2 = r2 + 1; }
Lako se uočava da nakon izlaska iz petlje, promenljiva r2 ima vrednost x/y. Očigledno, radi se o sporom
algoritmu, s obzirom da se petlja mora izvršiti x/y puta. Uočimo da će algoritam biti korektan i u slučaju da se
zameni redosled naredbi unutar while petlje:
r1 = x;
r2 = 0;
while (r1 >= y)
{ r2 = r2 + 1;
r1 = r1 – y; }
Primenom pravila 1 i 2, dve gornje varijante softverskog algoritma deljenje lako se prevode u ASM dijagrame
koji su prikazani na Sl. 3-4.

(a) (b)
Sl. 3-4 ASM dijagrami sekvencijalnog delitelja dobijeni konverzijom pseudo koda: (a) varijanta 1, (b) varijanta 2.
Jedina razlika između ASM dijagrama prikazanih Sl. 3-4 je u redosledu stanja C1 i C2 u petlji koja oduzima
delilac od deljenika i računa količnik. Sa stanovišta algoritma deljenja, redosled ove dve operacije je nebitan,
tako da su oba ASM dijagrama korektna.
Pregledom dva ASM dijagrama može se zapaziti da iza stanja PASIVNO sledi blok grananja koji ispituje
upravljački ulaz start, što, na prvi pogled, nije u skladu sa prvim pravilom prevođenja softverskog algoritma u
ASM dijagram. Međutim, testiranje signal start u stanju PASIVNO deo je specifikacije interfejsa i ne potiče iz
softverskog algoritma, i time ne narušava softverske zavisnosti između naredbi registarskog prenosa.
Razmotrimo, sada, sa više detalja rad ASM dijagrama sa Sl. 3-4(a). Ulazni podatak x se upisuje u registar r1 u
stanju PASIVNO. Ako je start=1, ASM prelazi u stanje INIT, gde će u registar r2 biti upisana inicijalna
vrednost količnika, tj. 0. U suprotnom, ako je start=0, stanje PASIVNO se ponavlja. Kako se u stanju
PASIVNO registar r2 ne menja, a pri tome, r2 sadrži rezultat poslednjeg deljenja, ovako koncipiran interfejs,
pruža korisniku onoliko vremena koliko mu je potrebno da očita rezultat. Uočimo, da interfejs, a ne algoritam
deljenja, zahteva da nakon startovanja sistema r2 bude inicijalizovan u posebnom stanju, INIT. Naime, sa
stanovišta algoritma deljenja, inicijalizacija registra r2 u stanju PASIVNO bila bi korektna, a pri tome bi i
ukupan broj stanja u ASM dijagramu bio za jedan manji. Međutim, kod takvog rešenja, rezultat deljenja bi bio
dostupan za očitavanje sa izlaza registra r2 samo u trajanju od jednog taktnog ciklusa.

122
Deo ASM dijagrama koji izračunava količnik je petlja koju čine stanja TEST, C1 i C2. U stanju TEST (tj. u
bloku grananja koji je pridružen ovom stanju) ispituje se da li je r1 veće od y, a to je isto ono ispitivanje koje
postoji u while naredbi softverskog algoritma. Stanja C1 i C2, u uzastopnim taktnim ciklusima, realizuju, u
vidu naredbi registarskog prenosa, naredbe dodele koje čine telo while petlje. Obe varijante ASM dijagrama,
ispravno rade i u slučajevima kada je x < y. Za x < y uslov iz bloka grananja u stanju TEST je netačan i ASM se
vraća u stanje PASIVNO sa nulom u registru r2 (tj. q=0).
Pažljivom analizom ASM dijagrama sa Sl. 3-4(b), može se uočiti razlog neophodnosti stanja TEST. Stanje
TEST, osim ispitivanja relacije r1≥y, koja mu je pridružena, ne sadrži nikakvu dodatnu aktivnost. U stanju C1,
koje u ovoj varijanti ASM dijagrama, prethodi stanju TEST, sadržana je naredba registarskog prenosa r1←r1–y.
Upis nove vrednosti u registar r1 obaviće se pri ulasku u stanje TEST, gde će, zatim, nova vrednost registra r1,
biti iskorišćena u relaciji r1≥y. Izostavljanjem stanja TEST, rad algoritma bio bi poremećen, jer bi ispitivanje
r1≥y bilo, praktično, pridruženo stanju C1 i koristilo bi staru vrednost registra r1.
Razmatrani primer pokazuje da je softverski algoritam uvek moguće prevesti u korektan ASM dijagram,
primenom jednostavnih pravila. Međutim, često, za isti polazni algoritam postoji više varijanti ASM dijagrama,
pri čemu ona koja se dobija direktnim prevođenjem softverskog algoritma ne mora biti uvek i najbolja. Naime,
ASM dijagrami, dobijeni direktnim prevođenjem softverskih algoritama, mada garantovano ispravni, ne moraju
biti i najefikasniji mogući, u pogledu broja stanja i broja registara. Glavni uzrok neefikasnosti se krije u činjenici
da su u ovako dobijene ASM dijagrame prenesene sve zavisnosti iz softverskog programa, koje forsirajući
strogo sekvencijalan redosled izvršenja naredbi registarskog prenosa, onemogućavaju ispoljavanje paralelizma u
radu različitih delova digitalnog sistema. Zato, ovako dobijene ASM treba koristiti kao polaznu osnovu za
detaljniju analizu koja bi imala za cilj pronalaženje optimalne varijante ASM dijagrama, što će biti tema
narednog primera.
Pr. 3-4 Optimizacija sekvencijalnog delitelja
Eliminacija stanja TEST
Stanje TEST uvedeno je samo iz razloga mehaničkog (direktnog) prevođenja softverskog algoritma u ASM. U
mnogim slučajevima, ispitivanje, kao što je ono koje je pridruženu stanju TEST može biti spojeno sa nekim
drugim stanjem, a da to ne nariši korektnost algoritma. Na taj način, eliminiše se jedno stanje, što ubrzava rad
sistema. Podsetimo se da blok grananja koji sledi nakon bloka stanja koji nije prazan, znači da se ispitivanje u
bloku grananja i izračunavanja u bloku stanja izvršavaju u paraleli. Iz tog razloga, nije korektno spojiti grananje
sa stanjem u kome se obavlja izračunavanje čiji se rezultat koristi u uslovu grananja. Razmotrimo modifikovanu
verziju ASM dijagrama sa Sl. 3-4, kod kojih je stanje TEST, prosto, obrisano.

(a) (b)
Sl. 3-5 ASM dijagrami sekvencijalnog delitelja sa izbačenim stanjem TEST: (a) neispravno rešenje; (b) ispravno
rešenje.
Mada, ASM dijagram sa Sl. 3-5(a) ispravno radi za x<y (ne ulazi u petlju), greška u izračunavanju količnika se
javlja pri x≥y. Kao ilustraciju pogrešnog rada, razmotrimo rad ovog ASM dijagrama za x=14 i y=7, pod
pretpostavkom da je registar r1 12-bitni:

123
 Tekuće stanje
PASIVNO r1= ? r2= ? start=0 rdy=1
PASIVNO r1= 14 r2= ? start=1 rdy=1
INIT r1= 14 r2= ? start=0 rdy=0
C2 r1= 14 r2= 0 start=0 rdy=0
C1 r1= 14 r2= 1 start=0 rdy=0
C2 r1= 7 r2= 1 start=0 rdy=0
C1 r1= 7 r2= 2 start=0 rdy=0
C2 r1= 0 r2= 2 start=0 rdy=0
C1 r1= 0 r2= 3 start=0 rdy=0
PASIVNO r1= 4089 r2= 3 start=0 rdy=1
PASIVNO r1= ? r2= 3 start=0 rdy=1
Uočimo da se relacija r1≥y javlja u dva različita stanja: PASIVNO i C1. Izračunavanje obuhvaćeno stanjem
PASIVNO uključuje jedino registar r2, što nema uticaja na ispitivanje r1≥y (tj. 14 ≥ 7). Problem postoji u stanju
C1, jer izračunavanje obuhvaćeno ovim stanjem uključuje registar r1, a odlučivanje koje sledi zasnovano je
upravo na vrednosti registra r1. Prilikom drugog prolaska kroz stanje C1 (vrsta u tabeli prikazana masnim
slovima), r1 još uvek sadrži vrednost 7. Naredba registarskog prenosa r1←r1 – y nalaže promenu vrednosti u r1
na 0, ali to će se desiti tek prilikom ulaska u sledeće stanje. S obzirom da ispitivanje r1≥y koristi tekuću
vrednost registra r1 (tj. 7), petlja će se ponoviti još jedanput, što daje pogrešan rezultat (r2=3). Vrednost 4089,
koju dobija registar r1 prilikom trećeg prolaska kroz petlju, posledica je podkoračenja prilikom izvođenja
operacije r1 – y (4089+7 = 212).
Mada je eliminacijom stanja TEST iz ASM dijagrama sa Sl. 3-4(b) dobijamo pogrešno rešenje, postavlja se
pitanje šta će se desiti ako isto stanje odstranimo iz ASM dijagrama sa Sl. 3-4(a), gde je stanje C1 na početku
petlje (Sl. 3-5(b)). U ASM dijagramu sa Sl. 3-5(b), ispitivanje r1≥y se javlja u dva različita stanja PASIVNO i
C2. Razlika u odnosu na prethodno analizirani ASM je u tome što sada izračunavanje obuhvaćeno stanjem C2,
r2 ← r2 + 1, koje prethodi ispitivanju uslova r1≥y, ne utiče na rezultat ispitivanje. Iz tog razloga, ASM dijagram
sa Sl. 3-5(b) je ispravan. S obzirom da petlja sada obuhvata dva, a ne tri stanja kao što je to bio slučaj kod ASM
dijagrama iz Pr. 3-3, ukupno vreme izračunavanja količnika je smanjeno i iznosi: 3+2*količnik taktnih
ciklusa. U suštini, ubrzanje koje smo dobili, posledica je preklapanja izvršenja dve nezavisne operacije, naredbe
registarskog prenosa r2 ← r2 + 1 i ispitivanja uslova r1≥y.
Eliminacija stanja INIT
Stanje INIT se koristi za inicijalni upis vrednosti 0 u registar r2. Razmotrićemo mogućnost eliminacije ovog
stanja, pripajanjem operacije r2←0 stanju PASIVNO. Prosto prebacivanje naredbe registarskog prenosa iz
stanja INIT u stanje PASIVNO daje ASM dijagram sa Sl. 3-6.

Sl. 3-6 ASM dijagram sekvencijalnog delitelja sa izbačenim stanjem INIT (pogrešno rešenje).
Broj naredbi registarskog prenosa koje se, obuhvaćene istim stanjem, izvršavaju u paraleli, može biti
proizvoljan, sve dok su registri sa leve strane ovih naredbi jedinstveni u okviru tog stanja. U konkretnom
primeru, stanje PASIVNO sadrži dve naredbe registarskog prenosa, koje iniciraju upise u registre r1 i r2; sam
upis biće obavljen na početku sledećeg taktnog perioda, tj. pri ulasku u stanje C1. S obzirom na pretpostavku da
pri rdy=1, korisnik čeka barem dva taktna ciklusa pre nego što aktivira signal start (vidi specifikaciju interfejsa
u Pr. 3-1), r1 i r2 će biti ispravno inicijalizovani pre ulaska u petlju. ASM će korektno izračunati količnik i
napustiti petlju posle odgovarajućeg broja prolazaka.
Međutim, kod ove ASM javlja se novi problem, koji nije postojao kod prethodnih varijanti: količnik se zadržava
u registru r2 samo za vreme jednog taktnog ciklusa. Razlog za ovakvo ponašanje je taj što se ASM odmah

124
nakon završenog izračunavanja vraća u stanje PASIVNO, gde se u r2 upisuje 0. Sa matematičke tačke gledišta,
ASM je ispravna, ali sa tačke gledišta korisničkog interfejsa, ovakvo ponašanje je neprihvatljivo.
Problem u radu interfejsa koji se javlja u ASM sa Sl. 3-6 može se prevazići uvođenjem još jednog registra, r3,
koji će se koristi za pamćenje količnika (Sl. 3-7(a)). ASM sa Sl. 3-7(a) radi korektno za x≥y (s napomenom da je
sada konačni rezultat smešten u r3, a ne u r2). Nažalost, u ovom ASM dijagramu postoji jedna suptilna greška: u
slučajevima kada rezultat treba da bude nula (x<y), r3 ostaje nepromenjen, umesto da bude obrisan. To se
događa zato što se upis u r3 obavlja samo unutar petlje. Međutim, u slučajevima kada je x<y, u petlju se ne
ulazi, a r3 zadržava zatečenu vrednost. Problem se može rešiti ako se uvede još jedno grananje, neposredno pre
ulaska u petlju, koje će ispitati uslov x<y (odnosno, uslov r1≥y), kao što je prikazano na Sl. 3-7(a). Uvođenje
dodatnog stanja, C3, ima za posledicu produženje vremena izračunavanja, koje sada iznosi: 2+3*količnik.
(Ponekada, projektant mora da razmotri sporije rešenje, da bi nakon toga, eventualno, stigao do bržeg).

(a) (b)
Sl. 3-7 ASM dijagram sekvencijalnog delitelja sa dodatnim registrom za pamćenje količnika: (a) pogrešno rešenje;
(b) ispravno rešenje.
Parelelizacija petlje
U ovom odeljku, polazeći od ASM dijagrama sa Sl. 3-7(b) isprobaćemo različite varijante realizacije petlje, u
smislu promene redosleda operacija i uvođenja paralelizma u izvršenju operacija. Konačni cilj je naći rešenje
koje će biti brže od polaznog.

PASIVNO
r1 <- x
r2 <- 0 PASIVNO
rdy r1 <- x
r2 <- 0
rdy

0 1
start
0 1
start
0 1
r1 >= y
0 1
N3 r1 >= y
1
r3 <- 0 r1 >= y
C1 N3
1
0 r1 <- r1 - y r3 <- 0 r1 >= y
C1
C3 0 r1 <- r1 - y
r3 <- r2
C23
C2
r2 <- r2 + 1
r2 <- r2 + 1 r3 <- r2

(a) (b)
Sl. 3-8 Varijacije u petlji ASM dijagrama sekvencijalnog delitelja (pogrešna rešenja).
Zamena redosleda stanja C2 i C3, daje pogrešno rešenje (Sl. 3-8(a)). Očigledno, upis u r3 se obavlja prerano i
konačni rezultat je za jedan manji od ispravnog. Još jedna varijanta izvođenja petlje, koja je, nažalost, iz sličnih

125
razloga kao i prethodna, takođe, pogrešna, dobija se spajanjem stanja C2 i C3 u jedinstveno stanje C23 ( Sl.
3-8(b)). Mada je unutar bloka stanja C23, operacija upisa u registar r2 navedena ispred operacije upisa u registar
r3, obe ove operacije izvršavaju se u paraleli (istovremeno). S obzirom da između operacija r2 ← r2 + 1 i r3 ←
r2 postoji zavisnost, ASM sa Sl. 3-8(b) nije ekvivalentan korektnom ASM dijagramu sa Sl. 3-7(b), kod koga su
ove dve operacije razdvojene u posebna stanja. Nasuprot tome, ponašanje ASM sa Sl. 3-8(b), ekvivalentno je
ponašanju pogrešnog ASM dijagrama sa Sl. 3-8(a).
Varijanta petlje, koja daje ne samo korektno, već i brže rešenje je ona kod koje su sve tri operacije, koje čine
telo petlje, spojene u jedinstveno stanje C123 ( Sl. 3-9). Ispitivanje uslova r1≥y pripada stanju C123 (kao što
pripada i stanju PASIVNO). Uočimo da se r1 menja u ovim stanjima. Takođe, između operacija obuhvaćenih
stanjem C123 postoji, ranije pomenuta, međuzavisnost. Međutim, i pored svega toga, ASM sa Sl. 3-9 predstavlja
ispravno rešenje, a razlog za to je upravo činjenica da se sve pomenute operacije izvršavaju u paraleli. U tom
smislu, rešenje sa predstavlja suprotnost u odnosu na koncept softverske sekvencijalnosti, od koga smo pošli u
traženju rešenja koje bi bilo optimalno u kontekstu hardverske realizacije sekvenicjalnog delitelja.

Sl. 3-9 ASM dijagram sekvencijalnog delitelja sa paralelizovanom petljom.

U razmatranoj ASM, registar r3 i dalje se koristi za čuvanje količnika nakon što se sistem po završenom
izračunavanju vrati u stanje PASIVNO. Međutim, u ASM sa Sl. 3-9, registar r3 ostvaruje još jednu, čak važniju
funkciju. Postojanje registra r3 kompenzuje činjenicu da se stanje C123 izvršava jedanput više u odnosu na
odgovarajuću softversku petlju. Čak iako je konačna vrednost u registru r2 za jedan veća od ispravnog rezultata,
registar r3, koji se uvek puni starom (prethodnom) vrednošću registra r2, na kraju izračunavanja sadrži ispravan
količnik.
Petlja, koja sada sadrži samo jedno stanje, C123, poseduje još jednu zanimljivu osobinu, koja se retko sreće kod
softverskih petlji: petlja se ili ne izvrši ni jedanput ili se izvršava barem dva puta. Razlog za ovakvo ponašanje je
u tome što je ispitivanje r1≥y sastavni deo dva različita stanja: PASIVNO i C123.
Vreme rada ASM iznosi 3+količnik taktnih ciklusa. Značajno ubrzanje rada ostvareno je zahvaljujući
maksimalnoj paralelizaciji unutrašnje petlje ASM dijagrama.
Eliminacija stanja N3
Pažljivom analizom rada ASM-a iz prethodnog odeljka možemo zaključiti da bi se stanje N3 moglo eliminisati
ako bi se stanje C123 izvršavalo jednom ili više puta, umesto dva ili više puta. Naime, ako bi smo obezbedili da
ASM uđe u petlju i za x<y, tada bi naredba registarskog prenosa r3←r2, koja je deo stanja C123, imala isti
efekta kao i naredba r3←0, koja je deo stanja N3. (Zato što pri napuštanju stanja PASIVNO, r2 ima vrednost 0).
Drugim rečima, treba obezbediti da ASM iz stanja PASIVNO pređe u stanje C123, bez obzira na ishod
ispitivanja r1≥y, a da nakon toga, nastavi da koristi ovo ispitivanje kako test za kraj petlje. Razdvajanje prvog
ulaska u stanje C123 i ulaska u isto ovo stanje koje je posledica ponavljanja petlje može se ostvariti na osnovu
vrednosti ulazno upravljačkog signala start, koji je 1 pri prelasku iz stanja PASIVNO u stanje C123, a 0 za sve
vreme dok traje izračunavanje količnika. (Ovo podrazumeva da mašinu koristi ¨prijateljski¨ korisnik, koji se
pridržava zahteva da trajanje start=1 mora biti tačno jedan taktni ciklus.) Na Sl. 3-10 prikazan je ASM dijagram
kod koga je ispitivanje uslova za kraj petlje prošireno testiranjem ulaznog signala start.

126
 Sl. 3-10 ASM dijagram sekvencijalnog delitelja sa eliminisanim stanjem N3.
Aktiviranje signala start, koji traje tačno jedan taktni ciklus ima kao jedinu posledicu inicijalni ulazak u petlju.
Svako naredno eventualno ponavljanje petlje isključivo zavisi od sadržaja registra r1. S obzirom da se za x≥y
petlja izvršava najmanje dva puta, pridruživanje signala start uslovu r1≥y nema efekta na rad ASM-a za x≥y.
Efekat pridruživanja signala start uslovu r1≥y ispoljava se kada je x<y. Drugim rečima, umesto da se stanje
C123 ne izvrši ni jedanput, start=1 forsira da se ovo stanje izvrši. U ovom slučaju, stanje C123 se izvršava tačno
jednom zato što x (tj. r1) nije ≥y.
Činjenica da se nakon izvršenja stanja C123 sadržaji registara r1 i r2 razlikuju od onih koje su oni imali nakon
izvršenja stanja N3 u prethodnoj varijanti ASM-a nije od značaja, s obzirom da korisnik očekuje konačni
rezultat u registru r3.
ASM sa Sl. 3-10 prikazan je u obliku strukturnog dijagrama, u smislu da programska realizacija ovog ASM
dijagrama ne zahteva upotrebu goto naredbe. U suštini, konkretni ASM dijagram sadrži while petlju
(testiranje uslova r1≥y | start) ugneždenu unutar if naredbe (testiranje signala start). Takođe, uočimo da se u
ASM dijagramu sa Sl. 3-10, ulazni signal start ispituje dva puta u toku istog taktnog ciklusa (stanje PASIVNO).
Ova redundantnost u dijagramu je direktna posledica težnje za strukturnom formom ASM dijagram. Dvostruko
ispitivanje signala start možemo lako eliminisati, ali to rezultuje u ASM dijagramu koji nije više strukturnog
oblika (Sl. 3-11)

Sl. 3-11 Nestrukturni ASM dijagram sekvencijalnog delitelja.

3.2.3 ASM dijagrami Milijevog tipa

Podsetimo se da se ASM dijagram sastoji od blokova stanja, grananja i uslovnih izlaza povezanih strelicama. U
prethodnim primerima, blokovi uslovnog izlaza nisu korišćeni. ASM dijagram koji ne sadrži blokove uslovnog
izlaza predstavlja konačni automat Murovog tipa. ASM dijagrami koji pored blokova stanja i grananja, sadrže i
blokove uslovnog izlaza predstavljaju konačne automate Milijevog tipa. U mnogim slučajevima, ASM
dijagrami Milijevog tipa omogućavaju opis algoritama koji su brži (a u nekim slučajevima i niže cene) od
odgovarajućih Murovih ASM dijagrama.
Operacije koje se javljaju u blokovima stanja (kako naredbe registarskog prenosa tako i postavljanje signala),
nazivaju se bezuslovnim operacijama, s obzirom da se izvršavaju uvek kada se ASM nađe u stanju koje
odgovara konkretnom bloku stanja. Blokovi uslovnog izlaza se koriste da bi se predstavile uslovne operacije, tj.

127
operacije koje se ponekad (ali ne i uvek) izvršavaju kada je ASM u određenom stanju. Blokovi uslovnog izlaza
nisu sami po sebi stanja, već se mogu smatrati ¨decom¨ nekog roditeljskog stanja. S obzirom da blokovi
uslovnog izlaza predstavljaju uslovne operacije, oni se uvek nalaze ispod jednog ili više blokova grananja. Kada
se u ASM dijagramu Milijevog tipa prate strelice, onda se polazeći od bloka stanja uvek prođe kroz jedan ili
više blokova grananja dok se ne stigne do bloka uslovnog izlaza. Strelica koja izvire iz bloka uslovnog izlaza,
utiče ili u blok grananja ili u blok stanja.
Sve naredbe registarskog prenosa i relacije navedene u bloku stanja i svim blokovima uslovnog izlaza i grananja
koji su međusobno povezani (bez blokova stanja između njih) obavljaju se u istom taktnom ciklusu. U suštini,
kombinacija blokova grananja i blokova uslovnog izlaza omogućava projektantu da realizuje ugneždenu if
then else konstrukciju koja se izvršava u jednom taktnom ciklusu. U takvoj ASM, veliki broj uslova se
može ispitivati u paraleli, što može bitno ubrzati rad algoritma.
ZELENO

BRZINA=3

ZUTO

STOP
BRZINA=1 OSTANI
BROJAC<-BROJAC+1

1
BROJAC /= 0

NAPUSTI

CRVENO

STOP
BROJAC<-BROJAC+2

Sl. 3-12 ASM dijagram iz Pr. 3-5.

Pr. 3-5 Jednostavan Milijev ASM dijagram
ASM dijagram sa Sl. 3-12 sadrži dva uslovna izlazna upravljačka signala: OSTANI i NAPUSTI. Signal OSTANI
ima vrednost 1 za sve vreme dok ASM, zbog BROJAČ ≠ 0, ostaje u stanju ŽUTO. Signal NAPUSTI ima
vrednost 1 u toku poslednjeg taktnog perioda u kome je ASM u stanju ŽUTO. Signali OSTANI i NAPUSTI
nikada nisu aktivni u isto vreme.
U sledećoj tabeli prikazano je ponašanje ASM dijagrama sa Sl. 3-12, pod pretpostavkom da je trajanje taktnog
perioda 0.5s:
Vreme Tekuće stanje Signali i promenljive
0.0 ZELENO STOP=0 BRZINA=11 BROJAČ=000 OSTANI = 0 NAPUSTI = 0
0.5 ŽUTO STOP=1 BRZINA=01 BROJAČ=000 OSTANI = 0 NAPUSTI = 1
1.0 CRVENO STOP=1 BRZINA=00 BROJAČ=001 OSTANI = 0 NAPUSTI = 0
1.5 ZELENO STOP=0 BRZINA=11 BROJAČ=011 OSTANI = 0 NAPUSTI = 0
2.0 ŽUTO STOP=1 BRZINA=01 BROJAČ=011 OSTANI = 1 NAPUSTI = 0
2.5 ŽUTO STOP=1 BRZINA=01 BROJAČ=100 OSTANI = 1 NAPUSTI = 0
3.0 ŽUTO STOP=1 BRZINA=01 BROJAČ=101 OSTANI = 1 NAPUSTI = 0
3.5 ŽUTO STOP=1 BRZINA=01 BROJAČ=110 OSTANI = 1 NAPUSTI = 0
4.0 ŽUTO STOP=1 BRZINA=01 BROJAČ=111 OSTANI = 1 NAPUSTI = 0
4.5 ŽUTO STOP=1 BRZINA=01 BROJAČ=000 OSTANI = 0 NAPUSTI = 1
5.0 CRVENO STOP=1 BRZINA=00 BROJAČ=001 OSTANI = 0 NAPUSTI = 0
5.5 ZELENO STOP=0 BRZINA=11 BROJAČ=011 OSTANI = 0 NAPUSTI = 0
6.0 ŽUTO STOP=1 BRZINA=01 BROJAČ=011 OSTANI = 1 NAPUSTI = 0
… … …
Između 0.5 s i 1.0 s, ASM je u stanju ŽUTO, ali, zbog toga što je BROJAČ = 0, ASM nastavlja putanjom koja
vodi u stanje CRVENO. Na ovoj putanji nalazi se blok uslovnog izlaza koji postavlja signal NAPUSTI. Ovaj

128
uslovni signal je aktivan u toku celog taktnog ciklusa, baš kao i bezuslovni signal STOP. Signal OSTANI, koji
se nalazi na drugoj putanji, ostaje neaktivan u toku ovog taktnog ciklusa.
Između 2.0 s i 2.5 s, ASM je ponovo u stanju ŽUTO, ali kako je sada vrednost registra BROJAČ različita od
nule, ASM nastavlja putanjom koja je vraća u isto stanje. Ova putanja prolazi kroz blok uslovnog izlaza koji
postavlja signal OSTANI. Signal NAPUSTI se ne aktivira u ovom taktnom ciklusu.
S obzirom da je BROJAČ trobitna promenljiva, BROJAČ ponovo postaje nula u vremenu 4.5-5.0s. To je zadnji
taktni ciklus u kome je ASM u stanju ŽUTO. Znači, u toku ovog taktnog ciklusa, signal NAPUSTI je aktivan, a
signal OSTANI nije.
Pr. 3-6 Milijeva verzija sekvencijalnog delitelja
Eliminacija stanja INIT (po drugi put)
U Pr. 3-4 na Sl. 3-5(b) prikazana je jedna korektna varijanta ASM dijagrama sekvencijalnog delitelja sa četiri
stanja koja sadrži samo dva registra (r1 i r2). Na Sl. 3-6 je prikazan jedan neuspešan pokušaj eliminacije stanja
INIT iz ove ASM. U ASM sa Sl. 3-7(b) uveden je registar r3 kako bi se ispravila greška u korisničkom interfejsu
koja je postojala u ASM sa Sl. 3-6.
Problem koji postoji u ASM sa Sl. 3-6 posledica je činjenice da se u stanju PASIVNO vrši bezuslovni upis u r2.
Korišćenjem bloka uslovnog izlaza, moguće je eliminisati stanje INIT, a da se pri tome ne naruši sadržaj registra
r2 za vreme dok mašina u stanju PASIVNO čeka da signal start bude aktiviran. Drugim rečima, u r2 se upisuje
nula u trenutku kada ASM prelazi iz stanja PASIVNO u stanje C1 ( Sl. 3-13).

Sl. 3-13 Milijeva ASM sekvencijalnog delitelja sa eliminisanim stanjem INIT.

U narednoj tabeli ilustrovan je rad sekvencijalnog delitelja za slučaj x=14 i y=7:
Tekuće stanje
PASIVNO r1= ? r2= ? start = 0 rdy = 1
PASIVNO r1= ? r2= ? start = 0 rdy = 1
PASIVNO r1= 14 r2= ? start = 1 rdy = 1
C1 r1= 14 r2= 0 start = 0 rdy = 0
C2 r1= 7 r2= 0 start = 0 rdy = 0
C1 r1= 7 r2= 1 start = 0 rdy = 0
C2 r1= 0 r2= 1 start = 0 rdy = 0
PASIVNO r1= 0 r2= 2 start = 0 rdy = 1
PASIVNO r1= ? r2= 2 start = 0 rdy = 1
Vrsta u gornjoj tabeli napisana masnim slovima, ukazuje na situaciju kada se ispoljava dejstvo uslovnog upisa
nule u registar r2. Naravno, efekat ove operacije je vidljiv u trenutku delovanja naredne rastuće ivice taktnog
signala, odnosno u trenutku kada mašina iz stanja PASIVNO prelazi u stanje C1.
ASM sa Sl. 3-7 izračunava količnik za 2+2*količnik taktnih ciklusa., što je za jedan taktni ciklus brže u
odnosu na korektni Murovu ASM sa dva registra (Sl. 3-5(b)).
Spajanje stanja C1 i C2
ASM sa Sl. 3-13 zahteva dvostruko duže vreme izračunavanja u odnosu na najbrže rešenje koje ne koristi
blokove uslovnog izlaza. Da bi smo postigli isti nivo preformansi i sa Milijevom varijantom sekvencijalnog
delitelja, neophodno je paralelizovati operacije koje se izvršavaju unutar petlje. Razmotrimo neispravnu ASM
sa Sl. 3-14.

129
 Sl. 3-14 Milijev ASM dijagram sekvencijalnog delitelja sa paralelizovanom petljom (neispravno rešenje)
U trenutku kada se, nakon obavljenog izračunavanja, ASM vrati u stanje PASIVNO, registar r2 je inkrementiran
jedanput više nego što bi to bio slučaj pri ispravnom radu sistema. U Pr. 3-4, ovaj problem bio je rešen
uvođenjem registra r3 koji je služio za čuvanje ispravnog količnika. Međutim, bolje rešenje bilo bi ono kod
koga bi se izbeglo korišćenje dodatnog registra. U tom cilju, neophodno je u stanju C12 vršiti upis u r2 samo
ako ASM ostaje u petlji, a zadržati zatečenu vrednost ako ASM napušta petlju da bi se vratila u stanje
PASIVNO. Ovakav rad ASM-a zahteva uvođenje bloka uslovnog izlaza (Sl. 3-15).

Sl. 3-15 Milijev ASM dijagram sekvencijalnog delitelja sa paralelizovanom petljom (ispravno rešenje)
ASM sa Sl. 3-15 izračunava korektan količnik za 3+količnik taktnih ciklusa i to korišćenjem samo dva
umesto tri registra. Znači, ovaj ASM je jednako brz kao i najbrži Murov ASM i pri tome koristi manji broj
registara.
Ranije postavljanje signala rdy
Razlog zbog koga Milijev ASM sa paralelizovanom unutrašnjom petljom sa Sl. 3-15 nije brži od Murovog ASM
iz sa Sl. 3-10 jeste u zahtevu da je korisnik u obavezi da čeka barem dva taktna ciklusa nakon što sistem postavi
signal rdy pre nego što ponovo inicira deljenje. Kod Murovih ASM dijagrama situacija rdy =1 je isto što i biti u
stanju PASIVNO. Međutim, kod Milijevih ASM dijagrama postoji mogućnost da se signal rdy postavi jedan
taktni ciklus ranije. Postoje dva razloga koji opravdavaju ranije postavljanje signala rdy. Prvo, u toku poslednjeg
taktnog ciklusa u kome je ASM u stanju C (Sl. 3-15), registar r2 već sadrži ispravan količnik, te se zbog toga ne
inicira operacija inkrementiranja registra r2 (grana ¨0¨ uslovnog koraka r1≥y iz bloka grananja koji sledi odmah
nakon bloka stanja C). Drugo, korisnik nije svestan tekućeg stanja sistema, već se on oslanja na signal rdy koji
ukazuje na trenutak kada signal start može ponovo biti aktiviran.
ASM sa Sl. 3-16 postavlja signal rdy u stanju PASIVNO, ali takođe i u poslednjem taktnom ciklusu stanja C.
Dok je ASM u stanju C, test r1≥y sa dna petlje se obavlja u isto vreme kada i test r1≥y sa vrha petlje. U taktnim
ciklusima kada ASM treba da ostane u petlji, r2 se inkrementira. U taktnom ciklusu kada ASM treba da napusti
petlju, postavlja se signal rdy.

130
 Sl. 3-16 Konačni oblik Milijevog ASM dijagrama sekvencijalnog delitelja.
Uslovno postavljanje signala rdy nakon izlaska iz petlje (grana ¨0¨ romba sa vrha petlje) ne bi bila legalna
operacija, jer postavljanje signala rdy već postoji u okviru stanja PASIVNO, kome, takođe, pripada i dotični
blok grananja. Postavljanje signala rdy, na način kako je to pokazano na Sl. 3-16, predstavlja legalnu operaciju,
jer se ona dešava samo u stanju C, tj. blok grananja sa dna petlje pripada samo stanju C, a ne i stanju PASIVNO.
Naredna tabela ilustruje rad ASM sa slike za x=14 i y=7:
Tekuće stanje
PASIVNO r1= ? r2= ? start = 0 rdy = 1
PASIVNO r1= 14 r2= ? start = 1 rdy = 1
C r1= 14 r2= 0 start = 0 rdy = 0
C r1= 7 r2= 1 start = 0 rdy = 0
C r1= 0 r2= 2 start =0 rdy = 1
PASIVNO r1= 4089 r2= 2 start = 0 rdy = 1
U poslednjem taktnom ciklusu stanja C, r2 već sadrži korektan količnik i signal rdy je postavljen. Umesto da
čeka još jedan taktni ciklus, korisnik može od ovog momenta otpočeti sa odbrojavanjem ciklusa.
ASM sa Sl. 3-16 izračunava korektan količnik za 2+količnik taktnih ciklusa korišćenjem samo dva registra.
Znači, sekvencijalni delitelj realizovan na osnovu Milijevog ASM dijagrama sa Sl. 3-16 je jeftiniji i brži od bilo
kog rešenja zasnovanog na nekom od Murovih ASM dijagrama iz Pr. 3-4.

3.3 Razrada
ASM dijagram nije ništa više od grafičkog prikaza algoritma, sa preciznom informacijom o tajmingu i
indikacijom o tome koje operacije se obavljaju u paraleli, a koje sekvencijalno. ASM dijagram ništa ne govori o
hardverskim komponentama koje su potrebne da bi se opisano izračunavanje realizovalo. Krajnji cilj
projektovanja je realizacija fizičkog sistema, tj. precizna specifikacija strukture sistema (na primer, u vidu
logičke šeme). ASM dijagram govori o tome šta projektant želi da mašina radi, a ne govori ništa o tome kako
povezati fizičke komponente da bi se ostvarilo željeno ponašanje sistema. Sa programerske tačke gledišta,
postavlja se pitanje zašto nastaviti dalje, zar problem nije rešen samim tim što smo našli algoritam. Slično,
projektant hardvera, može se zapitati zašto trošiti vreme na ASM dijagram, kada to ionako nije oblik rešenja koji
nam je potreban. Odgovor na oba ova pitanja je da kreiranje ASM dijagrama povećava šansu da će projektant
realizovati korektno rešenje. Sledeća faza projektovanja, razrada, upravo uključuje jedan deo ukupne
transformacije algoritma u hardversku strukturu.

Sl. 3-17 Struktura digitalnog sistema u fazi razrade.

131
Faza razrade ima za cilj da polazni problem, prethodno precizno opisan ASM dijagramom, podeli na dva
razdvojena ali povezana aktora: upravljačku jedinicu i staza podataka (Sl. 3-17). Staza podataka sadrži: (a)
hardverske registre neophodne za čuvanje vrednosti promenljivih koje se javljaju u naredbama registarskog
prenosa; i (b) kombinacionu logiku neophodnu za obavljanje izračunavanja specificiranih naredbama
registarskog prenosa. Na primer, ako u ASM dijagramu postoji naredba A <- B + C, tada u stazi podatak postoje
tri registra za smeštanje vrednosti promenljivih A, B i C i sabirač. Iako sadrži sve što je neophodno da bi se
izvršila izračunavanja i memorisali među-rezultati, staza podataka nije u stanju da samostalno sprovodi
sekvencu izračunavanja na način koji je predviđen algoritmom. To je razlog postojanja upravljačke jedinice, čiji
je zadatak da u svakom taktnom ciklusu ¨naloži¨ stazi podataka šta da uradi. Drugim rečima, u upravljačkoj
jedinici ugrađeno je ponašanje sistema, dok se resursi neophodni za obavljanje svih potrebnih izračunavanja i
memorisanje podataka nalaze u stazi podataka. Upravljačka jedinica umesto naredbi registarskog prenosa izdaje
komande stazi podataka (tj. postavlja interne upravljačke signale). Staza podataka prima komande, obavlja
aktivnosti koje su naložene komandom i kao odgovor generiše interne statusne signale. Upravljačka jedinica
ispituje statusne signale koje dobija od staze podataka i na bazi njihove vrednosti i vrednosti upravljačkih i
statusnih ulaza, donosi odluke koje određuju dalji tok rada sistema.
Uobičajeno je da se i u ovoj fazi projektovanja koristi ASM dijagram, ali samo za opis ponašanja upravljačke
jedinice, dok se staza podataka predstavlja u vidi hardverskog strukturnog opisa. ASM dijagram pridružen
upravljačkoj jedinici ne sadrži naredbe registarskog prenosa i relacije (jer su registri prebačeni u stazu
podataka), ali zato sadrži detaljan opis aktivnosti upravljačke jedinice, u vidu postavljanja upravljačkih signala i
ispitivanja statusa, koje su neophodne da bi se u stazi podatak obavila izračunavanja i registarski prenosi i to u
redosledu i na način koji je predviđen polaznim ASM dijagramom. Mada je nakon obavljene razrade, struktura
sistema složenija, a opis ponašanja sadrži više detalja, ponašanje celokupnog sistema, gledano sa strane
spoljnjeg sveta ostaje identično polaznoj specifikaciji.
Pr. 3-7 Razrada sekvencijalnog delitelja (rešenje 1)
Proces projektovanja na način ¨odozgo-naniže¨ uključuje tri glavne faze, kao što je to opisano u sekciji 3.1. U
Pr. 3-3, Pr. 3-4 i Pr. 3-6 iz sekcije 3.2, kao primer prve faze, razmatrane su različite varijante opisa ponašanja
sekvencijalnog delitelja. U ovom primeru biće razmatrana druga faza projektovanja (razrada) ovog kola. Za
ilustraciju razrade opisa ponašanja sekvencijalnog delitelja u strukturu sačinjenu od upravljačke jedinice i staze
podataka možemo uzeti bilo koji korektan ASM dijagram iz sekcije 3.2. Na primer, usredsredimo se na ASM sa
Sl. 3-10 iz Pr. 3-4, koji je ujedno predstavlja i najjednostavniji Murov ASM za deljenje. Za početak,
ignorisaćemo signale start i rdy, s obzirom da se radi o upravljačkom ulazu i statusnim izlazu sistema, koji
ionako ostaju nepromenjeni u fazi razrade. Cilj faze razrade jeste eliminacija naredbi registarskog prenosa i
relacionih izraza.
Uočimo naredbe registarskog prenosa u ASM dijagramu sa Sl. 3-10. U stanju PASIVNO, inicira se upis
vrednosti x u registar r1 i, u paraleli, brisanje registra r2. U stanju C123, inicira se upis u sva tri registra.
Naravno, sve inicirane promene registara desiće se na početku sledećeg taktnog ciklusa.
Postoji veliki broj različitih hardverskih struktura koje bi mogle realizovati naredbe registarskog prenosa iz
ASM sa Sl. 3-10. Na projektantu je da se odluči koje će hardverske komponente koristiti za ovu namenu.
Kriterijumi mogu biti različiti: brzina rada, cena, raspoloživost komponenti, i td. Jedini zahtev je da način na
koji su izabrane komponente povezane može obezbediti izvođenje svih naredbi registarskog prenosa uz striktno
poštovanje tajminga koje je specificiran polaznim ASM dijagramom. Najlakši (mada ne obavezno uvek i
najbolji) način da se ovo postigne jeste izabrati takve registarske komponente koje osim osnovne funkcije
memorisanja podataka, omogućavaju i neku dodatnu obradu koja se može iskoristiti za realizaciju celokupne (ili
barem jednog dela) naredbe registarskog prenosa. Na primer, u konkretnom slučaju, za realizaciju registra r2
možemo iskoristiti brojač. Brojač, kao digitalna registarska komponenta, osim memorisanja podatka,
omogućava brisanje (resetovanje) i inkrementiranje sadržaja, upravo one funkcije koje su potrebne za izvođenje
naredbi r2←0 i r2←r2+1, koje se javljaju u stanjima PASIVNO i C123, a uključuju registar r2. Realizacijom
registra r2 uz pomoć brojača bili bi smo u mogućnosti da eliminišemo obe ove naredbe registarskog prenosa i
zamenimo ih upravljačkim signalima za resetovanje i inkrementiranje brojača.
Ukoliko projektant za realizaciju registra r2, umesto brojača, odluči da koristi prihvatni registar, on će morati da
obezbedi dodatnu kombinacionu logiku kako bi nadomestio nedostatak funkcija resetovanja i inkrementiranja,
ugrađenih u brojaču. Izbor prihvatnog registra za realizaciju r2 nije pogrešno rešenje, već samo zahteva veće
angažovanje projektanta. Da bi smo zadržali jednostavnost primera, usvojićemo da se r2 realizuje uz pomoć
brojača.
Sa druge strane, registri r1 i r3, za razliku od brojača, uvek se pune vrednostima koje ne zavise direktno od
tekućeg sadržaja tih registara. Iz tog razloga, za realizaciju r1 i r3, razumno je koristiti najjednostavnije
registarske komponente, kao što je prihvatni registar, koji osim bazičnih registarskih funkcija upisa i

132
memorisanja podataka, poseduje još jedino funkciju dozvole upisa. Naravno, biće neophodan dodatni hardver
kako bi se obezbedili podaci za upis u ove registre.
Nakon što smo odlučili koje tipove registara ćemo koristiti u stazi podataka, neophodno je razmotriti na koji
način će registri biti povezani. Za trenutak, usredsredimo se samo na naredbe registarskog prenosa u stanju
C123. U ovom stanju, r1 se puni razlikom r1-y, r2 se inkrementira, a r3 se puni starom vrednošću registra r2.
Sve tri operacije izvršavaju se u paraleli. Za izračunavanje razlike r1-y koristićemo oduzimač. Ovo kolo će uvek
računati razliku između r1 i y (nezavisno od toga što se razlika upisuje u r1 samo kada je mašina u stanju C123).
Punjenje registra r3 starom vrednošću registra r2 lako se ostvaruje, tako što se izlazi brojačkog registra koji
realizuje r2 direktno povezuju sa ulazima prihvatnog registra koji realizuje r3. Kada bi se r1, r2 i r3 javljali
samo u stanju C123, staza podataka bi izgledala kao na Sl. 3-18.
12 ldr1 clrr2 incr2 ldr3

12 12
x/y
12
12 (-)
y
r1 r2 r3

Sl. 3-18 Staza podataka sa oduzimačem. Napomena: ldr – signal dozvole upisa u registar; clr – signal dozvole
resetovanja brojača; inc – signal dozvole inkrementiranja brojača; trougao označava taktni ulaz registra.
Uočimo da u stazi podataka sa Sl. 3-18 nije moguće realizovati operacije registarskog prenosa koje se javljaju u
stanju PASIVNO, r2←0 i r1←x. Naime, ne postoji mogućnost da se u r1 upiše x.
Pristup koji se često koristi kada staza podataka u različitim stanjima treba da obavi različite operacije sastoji se
u ugradnji aritmetičko-logičke jedinice (ALU). Za razliku od kombinacionih kola fiksne funkcije (kao što je
oduzimač), ALU predstavlja kombinaciono kolo koje može da obavi veći broj različitih aritmetičkih ili logičkih
operacija nad dva višebitna operanda. Takođe, prilikom korišćenja ALU obično je potrebno ugraditi jedan ili
više multipleksera za izbor podataka koji će kao operandi biti prosleđena do ulaza ALU. U konkretnom primeru,
u r1, u različitim stanjima, upisuju se sledeće informacije: (1) razlika r1-y, ili (2) vrednost deljenika x. Ako
usvojimo da se informacija za upis u r1 generiše od strane ALU jedinice, takva ALU mora biti sposobna da
obavi barem dve različite operacije: izračunavanje razlike i propuštanje, bez ikakve promene, jednog od ulaznih
operanada na izlaz. U ovom primeru koristićemo ALU jedinicu iz Pr. 2-27 koja ispunjava postavljene zahteve.
Izbor operacije koju će ALU obaviti vrši postavljanjem odgovarajuće binarne kombinacije na upravljačkom, 4-
bitnom ulazu aluctrl ALU jedinice. 4-bitne binarne kombinacije kojima se biraju dve operacije koje su nam
potrebne u konkretnom primeru simbolički ćemo imenovati kao: 'ODUZIMANJE i 'PROPUŠTANJE. (Simbol '
označava da dotično ime ukazuje na binarnu kombinaciju). Znači, u jednom slučaju ALU oduzima y od r1, a u
drugom propušta ulaznu vrednost x. Da bi se to ostvarilo neophodan je multiplekser tipa ¨2-u-1¨. Izlaz
multipleksera se vezuje na drugi ulaz ALU kola; ulaz 0 multipleksera je povezan sa ulazom podataka x, a ulaz 1
sa ulazom y. Kada je upravljački ulaz multipleksera muxctrl postavljen na 0, multiplekser propušta x, a kada je
postavljen na 1, propušta y. Korišćenjem ALU i multipleksera, staza podataka dobija oblik kao na Sl. 3-19.

aluctrl 12 ldr1 clrr2 incr2 ldr3

4
12 12
12 x/y
x 12
0 12 ALU
12 r1 r2 r3
y 1

muxctrl

Sl. 3-19 Staza podataka sa ALU

Staza podataka, prikazana na Sl. 3-19, iako u stanju da realizuje sve naredbe registarskog prenosa koje se
javljaju u ASM dijagramu sa Sl. 3-10, ne pruža mogućnost ispitivanja relacionog izraza r1≥y. Najjednostavniji
način za realizaciju relacionog izraza jeste korišćenje namenske kombinacione logike (obično je to komparator),
koja izračunava interni statusni signal čija vrednost ukazuje na rezultat poređenja. U razrađenoj varijanti ASM
dijagrama, koja opisuje ponašanje upravljačke jedinice, relacioni izraz iz polaznog ASM dijagrama biće

133
zamenjeni testiranjem ovog internog statusnog signala. U konkretnom primeru, za obavljanje poređenja r1≥y
koristićemo komparator čiji su ulazi r1 i y.
Komparator, kao namensko kombinaciono kolo, poseduje tri izlaza: strogo manje (<); jednako (==) i strogo
veće (>). Izlaz tipa ¨≥¨ ne postoji, ali se može lako oformiti, s obzirom da predstavlja negaciju izlaza ¨strogo
manje¨. Znači, da bi smo realizovali željeno poređenje, iskoristićemo izlaz ¨strogo manje¨ komparatora i
invertor. Izlaz invertora biće interni statusni signal r1gey, koji kada je 1 ukazuje da je r1 veće ili jednako y
(r1gey – r1 is Grater or Equal then Y).
Konačno, došli smo do strukture staze podataka koja može korektno da realizuje sve naredbe registarskog
prenosa i relacione izraze navedene u polaznom ASM dijagramu. Sada, kad su svi detalji staze podataka poznati,
prevođenje polaznog ASM dijagrama sa Sl. 3-10 u razrađeni ASM dijagram upravljačke jedinice, predstavlja, u
suštini, mehanički postupak. Svrha ovog prevođenja je da se umesto naredbi registarskog prenosa koriste
upravljački signali (kao što je incr2 ili aluctrl), a umesto relacionih izraza interni statusni signali (kao što je
r1gey). Svaka naredba ← se prevodi u jedan ili više upravljačkih signala (kao što su ldr1, clrr2, incr2 ili ldr3).
Na primer, da bi se u stazi podataka sa Sl. 3-19 obavila naredba r2←r2+1 potrebno je aktivirati upravljački
signal incr2. Znači, u ASM dijagramu naredbu r2←r2+1 treba zameniti signalom incr2. Slično, naredbu
r1←r1-y treba zameniti naredbama postavljanja internih upravljačkih signala muxctrl, aluctrl='ODUZIMANJE
i ldr1, i td.
Prelaz sa ASM dijagrama koji opisuje ponašanje celokupnog sistema na razrađeni ASM koji opisuje ponašanje
upravljačke jedinice, uvek ima u vidu strukturu staze podataka. Mada, obično, postoji veći broj staza podataka,
različite strukture, koje mogu realizovati naredbe registarskog prenosa i relacione izraze sadržane u polaznim
ASM dijagramom, svaka od varijanti zahtevaće različiti razrađeni ASM, prilagođen strukturi konkretne staze
podataka.
Slike Sl. 3-20, Sl. 3-21 i Sl. 3-22 prikazuju redom: stazu podataka, koju smo projektovali u ovom primeru,
razrađeni ASM dijagram dobijen na osnovu polaznog ASM dijagrama i projektovane staze podataka, i blok
dijagram koji pokazuje spregu upravljačke jedinice i staze podataka.

Sl. 3-20 Konačni oblik staze podataka.

Sl. 3-21 Razrađen ASM dijagram koja odgovara polaznom ASM dijagramu sa Sl. 3-10 i stazi podataka sa Sl. 3-20

134
 Sl. 3-22 Razrađeni blok dijagram sekvencijalnog delitelja.

Pr. 3-8 Razrada sekvencijalnog delitelja (rešenje 2)

Pažljivom analizom, možemo zaključiti da staza podataka, razvijena u prethodnom primeru, može da realizuje
bilo koji korektan ASM dijagrama sekvencijalnog delitelja iz Pr. 3-3 i Pr. 3-4. Međutim, to nije morao biti
slučaj; šta više, retko se dešava da jedna staza podataka može poslužiti za realizaciju različitih ASM-ova. Ono
što izdvaja ASM dijagram sa Sl. 3-10, koji je poslužio kao osnova za razvoj staze podataka iz prethodnog
primera od ostalih ASM dijagrama razmatranih u Pr. 3-3 i Pr. 3-4, jeste maksimalni paralelizam. Postoji jedno
neformalno pravilo koje kaže da staza podataka projektovana za maksimalni paralelizam može realizovati ASM
koji zahteva manji nivo paralelizma. Na primer, prva ASM iz Pr. 3-3 ( Sl. 3-4(a)) može biti realizovana
korišćenjem staze podataka iz prethodnog primera (slike Sl. 3-20). U ovom ASM dijagramu, registar r3 se ne
koristi. To znači da će izlaz podataka delitelja biti r2 umesto r3. Na Sl. 3-23 prikazan je razrađeni ASM dijagram
koji odgovara ASM dijagramu sa Sl. 3-4(a) i stazi podataka sa Sl. 3-20.
PASIVNO
ldr1
aluctrl = 'PROPUŠTANJE
muxctrl = 0
SPREMAN

0 1
start
INIT
clrr2

TEST

1
r1gey
C1
0
ldr1
aluctrl = 'ODUZIMANJE
muxctrl = 1

C2
incr2

Sl. 3-23 Razrađeni ASM dijagram iz Pr. 3-8

Pr. 3-9 Razrada sekvencijalnog delitelja (rešenje 3)
Ukoliko za realizaciju sekvencijalnog delitelja usvojimo sekvencijalni ASM dijagram sa Sl. 3-20, postoji
mogućnost da ćemo naći jeftiniju stazu podataka (ali sa manjim potencijalnim paralelizmom). Jedan od
uobičajenih načina za smanjenje cene (tj. hardverske složenosti) rešenja, mada na račun smanjenja brzine rada,
zasnovan je na korišćenju ALU kao centralne jedinice uz pomoć koje se obavljaju sve operacije koje su
specificirane polaznim ASM dijagramom. Konkretno, ALU može na svom izlaz da postavi ¨sve nule¨ (kada je
aluctrl = ‘NULA) i da inkrementira jedan od ulaznih operanada (kada je aluctrl = ‘INKREMENT). Pošto se
ALU koristi za različite operacije nad različitim podacima, rešenje zahteva multiplekser sa dovoljnim brojem

135
ulaza kako bi se do ulaza u ALU prosledili svi potrebni operandi. U konkretnom primeru, potreban je
multiplekser sa tri ulaza (što znači da je ulaz multipleksera za selekciju muxctrl dvo-bitni). Ovo će omogućiti
da se izabere jedna od vrednosti x, r1 i r2 i prosledi do ulaza u ALU.
Kod opisanog rešenja više nije neophodno da r2 bude realizovan kao brojački registar, s obzirom da operaciju
r2←r2+1 može da obavi ALU. Takođe, izlaz ALU jedinice mora biti dostupan na centralnoj magistrali, sa koje
će se vršiti upis u registre r1 i r2.
ALU jedinica standardno poseduje signal izlaznog prenosa (cout) koji se može iskoristiti za određivanje
rezultata testa r1≥y. Ovo je dozvoljeno jer ASM Sl. 3-20 poseduje stanje TEST sa praznim blokom stanja. U
razrađenoj ASM, ovaj pravougaonik neće biti prazan, mada i dalje neće sadržati bilo kakav upis u registre r1 ili
r2. Postavljanjem odgovarajućih internih upravljačkih signala (aluctrl i muxctrl) u prazan blok stanja TEST,
staza podataka se može tako konfigurisati da ALU izračunava razliku r1 i y, ali bez upisa rezultata u bilo koji
registar. Izlazni prenos postavljen prilikom izračunavanja ove razlike, tačnije njegova komplementarna
vrednost, ~cout, ukazuje na ishod poređenja r1≥y. Struktura staze podataka za treći primer prikazana je na Sl.
3-24(a), a razrađeni ASM koji opisuje ponašanje upravljačke jedinice na Sl. 3-24(b).

(a) (b)
Sl. 3-24 Sekvencijalni delitelj sa centralizovanom ALU: (a) staza podataka i (b) razređeni ASM dijagram.
Primeri razrade opisa ponašanja u strukturu ¨upravljačka jedinica – staza podataka¨, opisani u prethodnim
primerima, ukazuju da se u fazi razrade projektant sreće sa širokim spektarom mogućnih rešenja. Staza podataka
zasnovana na centralizovanoj ALU (ilustrovana u Pr. 3-9) koja obavlja sva neophodna izračunavanja,
predstavlja jedan kraj ovog spektra. Druga krajnost je metodička staza podataka, ilustrovana u Pr. 3-7 i Pr. 3-8,
kod koje se sva izračunavanja predviđena algoritmom obavljaju zasebnim hardverskim jedinicama. Pristup
zasnovan na centralizovanoj ALU, tipično, zahteva manje hardvera, ali zato, može da realizuje samo određene
vrste ASM-ova. Na primer, ASM dijagrami koji predviđaju više od jednog izračunavanja po taktnom ciklusu ne
mogu se ostvariti u stazi podataka zasnovanoj na centralizovanoj ALU, zato što ALU može da obavi samo jednu
operaciju u jednom taktnom ciklusu.
Kod metodičke staze podataka iz Pr. 3-7, izlaz ALU jedinice je povezan samo sa ulazom u registra r1; kod staze
podataka sa centralizovanom ALU iz Pr. 3-9, izlaz ALU jedinice je povezan sa oba registra r1 i r2. Kod ASM
koja je realizovana uz pomoć metodičke staze podataka, u jednom taktnom ciklusu izvršava se više naredbi
registarskog prenosa. Pristup koji koristi centralizovanu ALU je sporiji jer polazi od sekvencijalnog ASM
dijagrama.

3.4 Realizacija
Završna faza projektovanja bavi se realizacijom hardvera digitalnog sistema. Razrađena struktura sistema
opisuje se u jeziku za opis hardvera, kao što je VHDL, a zatim sintetiše u hardver pomoću alata za sintezu. Pri
tome, ASM dijagram upravljačke jedinice se opisuje kao konačni automat, dok se staza podataka opisuje
strukturnim VHDL kôdom. Za realizaciju staze podataka projektanti se obično oslanjaju na pretprojektovane

136
bibliotečke komponente (registri, ALU, multiplekseri). Konačni VHDL opis digitalnog sistema se dobija
povezivanjem upravljačke jedinice i staze podataka.
Prilikom korišćenja VHDL-a u kombinaciji sa alatom za sintezu, kreativni deo posla projektanta obično se
završava okončanjem faze razrade. Ponekada, projektanti preskaču čak i fazu razrade i prepuštaju alatu za
sintezu da na osnovu opisa ponašanja automatski izvrši sintezu hardvera. Međutim, ovakav pristup je moguć
samo kod projektovanja relativno jednostavnih sistema, koji u ograničenom obimu koriste aritmetičke operacije.
U svakom slučaju, važno je da projektant dobro razume mogućnosti i ograničenja alata za sintezu kako bi bio u
stanju da kreira efikasan i korektan VHDL kôd.
Rezultat druge faze projektovanja je opis sistema u vidu strukture koju čine upravljačka jedinica i staza
podataka, zajedno sa ASM dijagramom upravljačke jedinice. Međutim, čak i na ovom nivou, može se desiti da
pojedina kola koja su deo staze podataka nisu raspoloživa kao bibliotečke komponente. Takva kola moraju biti
namenski projektovana i opisana u VHDL-u. Ukoliko se radi o složenim kolima, koja se ne mogu sintetizovati
na osnovu bihejvioralnog opisa, proces njihovog projektovanja može zahtevati dodatu razradu. Međutim, s
obzirom da je interfejs takvih kola već definisan u fazi razrade staze podataka globalnog sistema, projektant
može slobodno da se usredsredi na projektovanje konkretnog kola siguran da će se ono bez problema uklopiti u
strukturu staze podataka. U svakom slučaju, konačni rezultat projektovanja koji sledi koncept ˝odozgo-naniže˝
je hijerarhijski VHDL opis koji se može razložiti na bibliotečke komponente i entitete koji sadrže bihejvioralni
opis koji se može sintetizovati.
Pr. 3-10 Sekvencijalni brojač jedinica
Funkcionalni ASM dijagram sekvencijalnog brojača jedinica razvijen je Pr. 2-54. U ovom primeru, obavićemo
njegovu razradu i opisaćemo kompletno kolo u VHDL-u. Funkcionalni ASM dijagram sadrži dve promenljive,
regA i regB (Sl. 2-54(b)) kojima će u stazi podataka odgovarati dve registarske komponente . Za manipulaciju
promenljivom regA može se koristiti pomerački registar sa pomeranjem udesno (zbog operacije regA←regA>>1
u stanju S1). Zbog operacije regA←a iz stanja S0, ovaj registar mora imati i mogućnost paralelnog upisa. Sa
druge strane, za regB potreban je brojač (zbog regB←regB+1 iz bloka uslovnog izlaza stanja S1). Dodatno,
brojač treba da ima mogućnost sinhronog resetovanja (zbog regB←0 u stanju S0). Takođe, obe registarske
komponente moraju imati ulaz za dozvolu rada, kako bi njihov rad mogao da se onemogući u stanjima u kojima
se ne obavljaju njihove operacije. Blok dijagram sekvencijalnog brojača jedinica dobijen razradom
funkcionalnog ASM dijagram prikazan je na Sl. 3-25(a). Strukturu čine upravljačka jedinica (blok control) i
staze podataka (datapath) koja sadrži dve opisane registarske komponente.

(a) (b)
Sl. 3-25 Razrada sekvencijalnog brojača jedinica: (a) strukturni blok dijagram; (b) ASM dijagram upravljačke
jedinice.
Upravljački ulaz pomeračkog registra (komponenta shift) su: ld - dozvola paralelnog upisa i ena dozvola rada.
Na paralelne ulaze pomeračkog registra doveden je ulaz podataka a, a na serijski ulaz fiksno je postavljena ´0´.
Za ld=1 i ena=1, obavlja paralelni upis, a za ld=0 i ena=1, pomeranje udesno pri čemu se na krajnju levu
poziciju upisuje 0. Brojač (komponenta counter) poseduje istoimene upravljačke ulaze. Za ld=1 i ena=1, u
brojač se upisuju ˝sve nule˝, postavljene na njegovom paralelnom ulazu, din. Na taj način, realizovana je
funkcija sinhronog resetovanja. Za ld=0 i ena=1, sadržaj brojača se uvećava za 1. Izlaz brojača je ujedno i izlaz

137
podataka b sekvencijalnog brojača jedinica. Za testiranje uslova regA=0, koristi se NILI kolo. Izlaz NILI kola, z,
biće z=1 ako pomerački registar sadrži sve nule. Takođe, za spregu sa upravljačkom jedinom, osim z, izdvojen
je i krajnji desni bit pomeračkog registra a0. Radi jednostavnosti izostavljeni su signali takta, clk, i asinhonog
resetovanja, rst, koji pobuđuju upravljačku jedinicu i obe registarske komponente.
Nakon što smo precizno opisali stazu podataka, u mogućnosti smo da kreiramo razrađeni ASM dijagram (Sl.
3-25(b)). Ovaj dijagram ima identičnu strukturu kao i polazni, funkcionalni ASM dijagram, s tom razlikom što
su naredbe registarskog prenosa i relacije zamenjene naredbama postavljanja upravljačkih signala i ispitivanjima
statusnih signala staze podataka. Na primer, blok stanja S1 sadrži ime signala ea. To znači da će u ovom stanju
važiti ea=1 i la=eb=lb=0. Pod ovim uslovima, u pomeračkom registru će se obaviti pomeranje udesno, dok će
sadržaj brojača ostati nepromenjen, što ima isti efekat kao i naredba registarskog prenosa regA←regA>>1
sadržana u istoimenom stanju funkcionalnog ASM dijagrama. Blok grananja koji sledi odmah ispod bloka stanja
S1 u funkcionalnom ASM dijagramu sadrži ispitivanje regA=0. U razrađenom ASM dijagramu, ova relacija je
zamenjena testiranjem statusnog signala staze podataka, z.
U nastavku je izložen kompletna VHDL kôd projekta sekvencijalnog brojača jedinica, pod pretpostavkom da je
ulaz podataka a 8-bitni, a izlaz podataka b 3-bitni. Najpre su realizovani bihejvioralni opisi pomeračkog registra
(fajl shift.vhd) i brojača (fajl counter.vhd), koji su potom iskorišćeni kao komponente u strukturnom opisu staze
podataka (fajl datapath.vhd). Primetimo da VHDL kôd staze podataka nije u potpunosti strukturni, jer se za
realizaciju NILI kola koristi konkurentna WHEN/ELSE naredba, a ne komponenta. Sledeći deo VHDL kôda
(fajl control.vhd) opisuje upravljačku jedinicu na osnovu razrađenog ASM dijagrama sa Sl. 3-25(b). Ovaj kôd je
usklađen sa kodnim šablonom za konačne automate. Konačno, komponente datapath i control objedinjene su u
vršni modul ones_counter.vhd.
Lako se primećuje da je VHDL kôd kreiran na osnovu razrađene strukture značajno obimniji od VHDL kôda
koji je u Pr. 2-54 kreiran na osnovu funkcionalnog ASM dijagrama. Kôd iz Pr. 2-54 je manje obiman zato što su
u njemu naredbe registarskog prenosa realizovane direktno u kôdu, a ne pomoću komponenti, kao što je to
urađeno u ovom promeru. Napomenimo da se i kôd iz Pr. 2-54 može sintetizovati. Međutim, zbog višeg nivoa
opisa, sinteza takvog kôda predstavljaće teži zadatak za alat za sintezu, pa će i sintetizovano kolo biti hardverski
složenije od onoga koje se dobija na osnovu VHDL kôda razrađene strukture. Iako nepogodan za sintezu,
funkcionalni VHDL kôd je koristan zato što može poslužiti za simulaciju kako bi se verifikovala ispravnost
funkcionalnog ASM dijagrama.
1 ----- shift.vhd ------------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -----------------------------------------------
5 ENTITY shift IS
6 PORT (si,ld,ena,rst,clk : IN STD_LOGIC;
7 din : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
8 q : OUT STD_LOGIC_VECTOR(7 DOWNTO 0));
9 END shift;
10-----------------------------------------------
11 ARCHITECTURE Behavioral OF shift IS
12 SIGNAL reg : STD_LOGIC_VECTOR(7 DOWNTO 0);
13 BEGIN
16 PROCESS (clk,rst)
17 BEGIN
18 IF(rst='1')THEN
19 reg <="00000000";
20 ELSIF(clk'EVENT AND clk='1') THEN
21 IF(ld='1') THEN
22 reg <= din;
23 ELSIF(ena = '1') THEN
24 reg <= si & reg(7 DOWNTO 1);
25 END IF;
26 END IF;
27 END PROCESS;
28 q <= reg;
29 END Behavioral;
30 -----------------------------------------------
1 ------ counter.vhd -----------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE ieee.std_logic_unsigned.all;

138
5 -----------------------------------------------
6 ENTITY counter IS
7 PORT (ld,ena,rst,clk : IN STD_LOGIC;
8 din : IN STD_LOGIC_VECTOR(2 DOWNTO 0);
9 q : OUT STD_LOGIC_VECTOR(2 DOWNTO 0));
10 END counter;
11-----------------------------------------------
12 ARCHITECTURE Behavioral OF counter IS
13 SIGNAL count : STD_LOGIC_VECTOR(2 DOWNTO 0);
14 BEGIN
15 PROCESS (clk,rst)
16 BEGIN
17 IF(rst='1')THEN
18 count <="000";
19 ELSIF(clk'EVENT AND clk='1') THEN
20 IF(ld='1') THEN
21 count <= din;
22 ELSIF(ena = '1') THEN
23 count <= count + 1;
24 END IF;
25 END IF;
26 END PROCESS;
27 q <= count;
28 END Behavioral;
29-----------------------------------------------
1 --------datapath.vhd ----------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -----------------------------------------------
5 ENTITY datapath IS
6 PORT (la,ea,lb,eb,rst,clk : IN STD_LOGIC;
7 z,a0 : OUT STD_LOGIC;
8 a : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
9 b : OUT STD_LOGIC_VECTOR(2 DOWNTO 0));
10 END datapath;
11-----------------------------------------------
12 ARCHITECTURE Stuctural OF datapath IS
13 COMPONENT shift IS
14 PORT (si,ld,ena,rst,clk : IN STD_LOGIC;
15 din : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
16 q : OUT STD_LOGIC_VECTOR(7 DOWNTO 0));
17 END COMPONENT;
18 ---------------------
19 COMPONENT counter IS
20 PORT (ld,ena,rst,clk : IN STD_LOGIC;
21 din : IN STD_LOGIC_VECTOR(2 DOWNTO 0);
22 q : OUT STD_LOGIC_VECTOR(2 DOWNTO 0));
23 END COMPONENT;
24 SIGNAL sa : STD_LOGIC_VECTOR(7 DOWNTO 0);
25 BEGIN
26 SH: shift PORT MAP(si=>'0',ld=>la,ena=>ea,rst=>rst,clk=>clk,din=>a,q=>sa);
27 CT: counter PORT MAP(ld=>lb,ena=>eb,rst=>rst,clk=>clk,din=>"000",q=>b);
28 z <= '1' WHEN sa = "00000000" ELSE
29 '0';
30 a0 <= sa(0);
31 END Stuctural;
31-----------------------------------------------
1 ----- control.vhd -----------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -----------------------------------------------
5 ENTITY control IS
6 PORT (clk,rst,start,z,a0 : IN STD_LOGIC;
7 kraj,la,ea,lb,eb : OUT STD_LOGIC);
8 END control;
9 -----------------------------------------------
10 ARCHITECTURE ASM OF control IS

139
11 TYPE state IS (S0, S1, S2);
12 SIGNAL pr_state, nx_state : state;
13 BEGIN
14 -- sekvencijalni process --------------------
15 PROCESS (clk,rst)
16 BEGIN
17 IF(rst='1')THEN
18 pr_state <=S0;
19 ELSIF(clk'EVENT AND clk='1') THEN
20 pr_state <= nx_state;
21 END IF;
22 END PROCESS;
23 -- kombinacioni process --------------------
24 PROCESS(start,z,a0,pr_state)
25 BEGIN
26 nx_state <= pr_state;
27 kraj <= '0';
28 la <= '0';
29 ea <= '0';
30 lb <= '0';
31 eb <= '0';
32 CASE pr_state IS
33 WHEN S0 =>
34 la <= '1';
35 lb <= '1';
36 IF(start = '1') THEN
37 nx_state <= S1;
38 END IF;
39 WHEN S1 =>
40 ea <= '1';
41 IF(z = '1') THEN
42 nx_state <= S2;
43 ELSE
44 nx_state <= S1;
45 IF(a0 = '1') THEN
46 eb <= '1';
47 END IF;
48 END IF;
49 WHEN S2 =>
50 kraj <= '1';
51 nx_state <= S0;
52 END CASE;
53 END PROCESS;
54 END ASM;
55-----------------------------------------------
1 ------ones_counter.vhd --------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -----------------------------------------------
5 ENTITY ones_counter IS
6 PORT (a : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
7 clk, rst, start : IN STD_LOGIC;
8 b : OUT STD_LOGIC_VECTOR(2 DOWNTO 0);
9 kraj : OUT STD_LOGIC);
10 END ones_counter;
11-----------------------------------------------
12 ARCHITECTURE Structural OF ones_counter IS
13 COMPONENT control IS
14 PORT (clk,rst,start,z,a0 : IN STD_LOGIC;
15 kraj,la,ea,lb,eb : OUT STD_LOGIC);
16 END COMPONENT;
17 -------------------
18 COMPONENT datapath IS
19 PORT (la,ea,lb,eb,rst,clk : IN STD_LOGIC;
20 z,a0 : OUT STD_LOGIC;
21 a : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
22 b : OUT STD_LOGIC_VECTOR(2 DOWNTO 0));

140
23 END COMPONENT;
24 ------------------
25 SIGNAL z,a0,la,ea,lb,eb : STD_LOGIC;
26 BEGIN
27 CTRL: control PORT MAP(clk=>clk,rst=>rst,start=>start,z=>z,a0=>a0,
28 kraj=>kraj,la=>la,ea=>ea,lb=>lb,eb=>eb);
29 DPTH: datapath PORT MAP(la=>la,ea=>ea,lb=>lb,eb=>eb,rst=>rst,
30 clk=>clk,z=>z,a0=>a0,a=>a,b=>b);
31 END Structural;
32-----------------------------------------------
Pr. 3-11 Sekvencijalni delitelj (ubrzani algoritam)
U ovom primeru ponovo realizujemo sekvencijalni delitelj, ali sada umesto algoritma deljenja koji je zasnovan
na oduzimanju delioca od deljenika, koristimo brži algoritam, zasnovan na tradicionalnom, ručnom postupku
deljenja.
Algoritam
Sl. 3-26(a) prikazuje primer ručnog deljenja decimalnih brojeva 140 i 9. Prvi korak je pokušaj deljenja cifre
najveće težine deljenika (1) deliocem (9). Pošto se 9 ne sadrži u 1, uzimamo sledeću cifru deljenika (4) i
proveravamo da li se 9 sadrži u 14. Sada je deljenje moguće, što daje prvu cifru količnika 1 (=14/9) i ostatak 5
(=14 - 9*1). Postupak nastavljamo tako što uz ostatak sa desne strane dopisujemo sledeću (i poslednju) cifru
deljenika (0), i delimo 50 sa 9. To daje drugu cifru količnika 5 (=50/9) i ostatak 5 (=50-5*9). Time je deljenje
završeno. Rezultat je Q=15 (količnik) i R=5 (ostatak). Postupak je identičan i ako se umesto decimalnih dele
binarni brojevi, sa pojednostavljenjem da svaki bit količnika može biti samo 0 ili 1 ( Sl. 3-26 (b)).
R A Q

00000000 10001100 00000000

0) 00000001 00011000 00000000

1) 00000010 00110000 00000000

2) 00000100 01100000 00000000

3) 00001000 11000000 00000000

4) 00010001 10000000 00000000

-00001001 <- B
--------
00001000 10000000 00000001

A B Q 5) 00010001 00000000
10001100 : 1001 = 1111 -00001001 <- B
-1001 --------
----- 00001000 00000000 00000011
10001
-1001 6) 00010000 00000000
A B Q ----- -00001001 <- B
140 : 9 = 15 10000 --------
9 -1001 00000111 00000000 00000111
---- -----
50 01110 7) 00001110 00000000
- 9 -1001 -00001001 <- B
---- ------ --------
5 <- R 0101 <- R 00000101 00000000 00001111

(a) (b) (c)

R = 0; R = 0; R = 0;
for C = 0 to N-1 do for C = 0 to N-1 do C = N-1;
(R,A) = (R,A) << 1; (R,A) = (R,A) << 1; do
if(R ≥ B) then if(R ≥ B) then (R,A) = (R,A) << 1;
QC = 1; Q = (Q << 1)1; if(R ≥ B) then
R = R - B; R = R - B; Q = (Q << 1)1;
else else R = R - B;
QC = 0; Q = (Q << 1)0; else
end if; end if; Q = (Q << 1)0;
end for; end for; end if;
while(C≥0);
(d) (e) (f)
Sl. 3-26 Algoritam deljenja: (a) primer deljenja decimalnih brojeva; (b) primer deljenja binarnih brojeva; (c)
modifikovani postupak; (d) polazni pseudo kod; (e) pseudo kod sa pomeranjem količnika; (f) pseudo kod sa do-while
petljom.

141
Naš zadatak je da korišćenjem opisanog postupka deljenja realizujemo kolo koje na ulazu dobija dva
neoznačena n-bitna cela broja, a i b, i generiše dva n-bitna cela broja, q i r, gde je q količnik, a/b, a r ostatak.
Procedura ilustrovana u primeru sa Sl. 3-26(b), može se sprovesti i na način kao na Sl. 3-26(c), koji je pogodniji
za hardversku realizaciju. Umesto spuštanja cifara deljenika, sada se deljenik najpre proširi ciframa ostatka, koje
su na početku sve nule. Zatim se ostatak i deljenik zajedno pomere za jednu bitsku poziciju ulevo i ispita da li se
delilac sadrži u ostatku. Ako deljenje nije moguće odgovarajući bit količnika je 0. Ako je deljenje moguće bit
količnika je 1, a ostatak se koriguje oduzimanjem delioca. Ovaj postupak se ponavlja N puta, gde je N broj bita
operanada, sve dok celokupni sadržaj deljenika ne napusti promenljivu a. Algoritam opisanog postupka dat je u
obliku pseudo koda na Sl. 3-26(d). (R,A) označava 2n-bitnu promenljivu dobijenu konkatenacijom n-bitnih
promenljivih R i A. Petlja se izvršava n puta, a u svakom prolasku kroz petlju generiše se sledeći bit količnika,
QC, počev od C=0, do C=N-1. Bukvalna interpretacija algoritma, značila bi da je u svakoj iteraciji petlje
potrebno odgovarajući bit količnika, Q, postaviti na 0 ili 1. Za hardversku realizaciju, pogodnije je umesto
direktnog postavljanja bitova koristiti pomeranje količnika Q ulevo sa serijskim upisom vrednosti QC. Pseudo
kod sa ovom modifikacijom prikazan je na Sl. 3-26(e). Notacija Q← (Q<<1)1 označava pomeranje ulevo sa
serijskim upisom 1-ce na krajnju desnu poziciju. Slično, Q← (Q<<1)0, pomera Q udesno za jednu poziciju i
serijski upisuje 0.
Da bi smo olakšali konverziju pseudo koda u ASM dijagram, učinećemo još jednu modifikaciju: for petlju
zamenićemo ekvivalentnom do-while petljom. Kod do-while petlje ispitivanje uslova za kraj petlje je na kraju, a
ne na početku petlje kao kod for varijante. To znači da telo do-while petlje mora da se izvrši barem jedanput, za
razliku od for petlje koja može da se izvrši 0 ili više puta. Međutim, ova nedoslednost u konkretnom slučaju nije
od značaja zato što postoji prirodno ograničenje da N mora biti veće ili jednako 1. Takođe, uočimo da se brojač
petlje C koristi samo za odbrojavanje iteracija, ali ne i kao argument u nekoj drugoj naredbi. Cilj je obezbediti
da se petlja izvrši tačno N puta, a pri tome nije bitno da li se brojač kreće od 0 do N-1 ili, kao što je to u do-while
varijanti, od N-1 do 0.

(a) (b) (c)

Sl. 3-27 Funkcionalni ASM dijagrami sekvencijalnog delitelja iz : (a) ASM dijagram dobijen konverzijom softverskog
algoritma; (b) ASM dijagram nakon eliminacije stanja TEST1 i TEST2; (c) ASM dijagram nakon spajanja stanja
INCR, SHQ1, SUBB i SHQ2.

142
Funkcionalni ASM dijagram
Direktnom konverzijom pseudo koda sa Sl. 3-26(d), primenom pravila iz sekcije 3.2.2, dobijamo ASM dijagram
sa Sl. 3-27(a). Uočimo da ASM dijagram dodatno sadrži signale start i rdy koji su deo interfejsa sekvencijalnog
delitelja, kao je identičan kao u Pr. 3-1. Petlja se izvršava za 6 ili 5 taktnih ciklusa, u zavisnosti da li je u tekućoj
iteraciji R veće ili jednako od B ili ne. Međutim, ovo je tek polazni oblik ASM dijagrama, i treba očekivati da su
moguća značajna poboljšanja.
Prazni blokovi stanja TEST1 i TEST2 uvedeni su zbog grananja koje u uslovu koristi promenljive koje se
menjaju neposredno pre grananja. Da bi grananje koristilo aktuelnu vrednost registra, neophodno je da se upis u
registar i grananje ne vrše u istom stanju. Pri tome, nije neophodno da blok stanja koji deli ove dve operacije
bude prazan, već da ne sadrži registar koji se koristi u uslovu grananja. Oba prazna stanja iz ASM dijagrama sa
Sl. 3-27(a) se mogu eliminisati ako se promeni redosled naredbi registarskog prenosa, tako da naredba
dekrementiranja brojača petlje pređe sa kraj na početak petlje. Razmak između stanja upisa u registar R (stanje
SHRA) i grananja R≤B je očuvan, kao i između stanja INCR gde si dekrementira brojač C i ispitivanja C≥0. Na
ovaj način broj taktnih ciklusa potrebnih za jednu iteraciju petlje je smanjen na 3, odnosno 4 ( Sl. 3-27(b)).
Sledeća optimizacija se tiče stanja SHQ1, SHQ0 i SUBB. Najpre uočimo da se stanja SHQ1 i SUBB mogu
spojiti u jedno stanje (SHQ1SUBB), u kome će se u paraleli obaviti obe naredbe registarskog prenosa,
Q←(Q<<1)1 i R←R-B. To je dozvoljeno zato što su ove dve naredbe međusobno nezavisne, jer ni jedna od njih
ne koristi kao operand rezultat one druge. Na ovaj način broj taktnih ciklusa po jednoj iteraciji bio bi 3, bez
obzira na ishod testiranja R≤B.
Ubrzanje za još jedan taktni ciklus po iteraciji, mogli bi smo da ostvarimo ako bi smo izračunavanja iz stanja
SHQ1SUBB i SHQ0 pripojili stanju INCR. Drugim rečima ako bi smo blokove stanja SHQ1SUBB i SHQ0
zamenili blokovima uslovnog izlaza. Međutim, s takvom modifikacijom, stanju INTR pripalo bi i ispitivanje
C≥0 sa kraja petlje, što bi narušilo neophodan vremenski razmak između ovog ispitivanja i naredbe koja
dekrementira brojač C. Kao posledicu, petlja bi imala jedan prolazak više, jer bi se izvršila na samo za C=n-1,
..., 0, već i za C=-1. Međutim, ovaj nedostatak se može lako otkloniti ako se uslov za izlazak iz petlje promeni
na C>0. Na taj način dolazimo do ASM dijagrama sa Sl. 3-27(c) koji zahteva 2 taktna ciklusa po iteraciji. S
obzirom da je broj iteracija n deljenje n-bitnih brojeva trajaće .
Postavlja se pitanje da li je moguće sva izračunavanja koja se obavljaju u petlji obaviti u samo jednom stanju.
Međutim, pre nego što damo odgovor na to pitanje, usvojimo da je ASM dijagram sa Sl. 3-27(c) konačna verzija
funkcionalnog ASM dijagrama, i obavimo njegovu razradu.
Razrada
ASM dijagram sadrži pet promenljivih: A, B, Q, R i C. Promenljive A, B i Q učestvuju u operacijama pomeranja.
Zato je normalno za njihovu realizaciju koristiti pomeračke registre sa pomeranjem ulevo. Zajedničko
pomeranje kroz registre R i A, ostvariće se povezivanjem krajnjeg levog izlaznog bita registra A na serijski ulaz
registra R. Osim u naredbi registarskog prenosa iz SHRA koja pomera R i A, promenljiva A se javlja kao
odredište u još jednoj naredbi, A←a iz stanja PASIVNO. Ova dodatna operacija zahteva da pomerački registar
A poseduje mogućnost paralelnog upisa. Funkciju paralelnog upisa treba da poseduje i pomerački registar R. U
stanju PASIVNO R se resetuje, a u stanju INCR u R se upisuje razlika R-B. Izbor podataka koji će biti paralelno
upisan u registar R, 0 ili R-B, može se ostvariti pomoću multipleksera. Promenljiva B se koristi za memorisanje
delioca i ne menja se u toku izračunavanja. Iz tog razloga, za promenljivu B možemo koristiti prihvatni registar.
Promenljiva B, zajedno sa promenljivom R, se koristi u naredbi R-B iz stanja INCR. Za oduzimanje R-B
možemo koristiti n-bitni binarni sabirač, pri čemu će promenljiva B biti komplementirana, a na ulazni prenos
sabirača postavljena 1-ca. Za realizaciju relacije R≥B u stazi podataka nije potrebno neko dodatno kolo, pošto
informaciju o tome da li je R veće ili jednako od B imamo na izlazu za izlazni prenos sabirača koji se koristi za
oduzimanje B od R. Ako je R≥B, izlazni prenos će imati vrednost 0, a ako je R<B, izlazni prenos će biti 1. Šta
više, komplement izlaznog prenosa je upravo ona vrednost koju treba serijski upisati u pomerački registar Q, što
omogućava da se izlazni prenos sabirača preko invertora direktno poveže na serijski ulaz pomeračkog registra
Q. Konačno promenljiva C koja se koristi kao brojač petlje može se realizovati pomoću brojača naniže sa
mogućnošću paralelnog upisa. Početna vrednost N-1 se kao konstanta postavlja na paralelne ulaze brojača.
Struktura sekvencijalnog delitelja nakon izvršene razrade, prikazana je na Sl. 3-28.
Realizacija
Nakon izvršene razrade sledi opis razrađene strukture u VHDL-u. VHDL kôd staze podataka (datapath) i
upravljačke jedinice (control) dat je u nastavku. Nedostaju delovi kôda koji opisuju korišćene komponente (shift
- pomerački registar ulevo sa paralelnim upisom, counter - brojač naniže sa paralelnim upisom i adder - binarni
sabirač) kao i vršni modul koji objedinjuje upravljačku jedinicu i stazu podataka. VHDL kôd staze podataka nije

143
u potpunosti strukturnog tipa. Primetimo da se u arhitektura staze podataka za opis prihvatnog registra (B)
koristi proces; pomerački registri, brojač i sabirač se kreiraju instanciranjem odgovarajući komponenti, dok se
multiplekser i invertori realizuju konkurentnim kôdom.

Sl. 3-28 Razrađena struktura sekvencijalnog delitelja iz Pr. 3-11.

PASIVNO

rdy
eb; la; ea; lc; ec

0
start

lr; er

SHRA

er; ea

INCR

ec

1 0
cout

eq; rsel; lr; er eq

0 1
z

Sl. 3-29 Razrađeni ASM dijagram sekvencijalnog delitelja iz Pr. 3-11.

144
1 ----- datapath.vhd ----------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -----------------------------------------------
5 ENTITY datapath IS
6 PORT (a,b : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
7 rsel,lr,er,la,ea,eb,eq,lc,ec,rst,clk : IN STD_LOGIC;
8 cout,z : OUT STD_LOGIC;
9 q,r : OUT STD_LOGIC_VECTOR(7 DOWNTO 0));
10 END datapath;
11 -----------------------------------------------
12 ARCHITECTURE structure OF datapath IS
13 -----------------------
14 COMPONENT shift IS
15 GENERIC (N : INTEGER);
16 PORT (si,ld,ena,rst,clk : IN STD_LOGIC;
17 din : IN STD_LOGIC_VECTOR(N-1 DOWNTO 0);
18 q : OUT STD_LOGIC_VECTOR(N-1 DOWNTO 0));
19 END COMPONENT;
20 ----------------------
21 COMPONENT counter IS
22 GENERIC (N : INTEGER);
23 PORT (ld,ena,rst,clk : IN STD_LOGIC;
24 din : IN STD_LOGIC_VECTOR(N-1 DOWNTO 0);
25 q : OUT STD_LOGIC_VECTOR(N-1 DOWNTO 0));
26 END COMPONENT;
27 ----------------------
28 COMPONENT adder IS
29 GENERIC (N : INTEGER);
30 PORT (cin : IN STD_LOGIC;
31 x,y : IN STD_LOGIC_VECTOR(N-1 DOWNTO 0);
32 s : OUT STD_LOGIC_VECTOR(N-1 DOWNTO 0);
33 cout: OUT STD_LOGIC);
34 END COMPONENT;
35 ----------------------
36 SIGNAL regB : STD_LOGIC_VECTOR(7 DOWNTO 0); -- registar B
37 SIGNAL regB_not : STD_LOGIC_VECTOR(7 DOWNTO 0); -- komplementirano B
38 SIGNAL qa,dr,qr,sum : STD_LOGIC_VECTOR(7 DOWNTO 0); -- interne magistrale
39 SIGNAL qc : STD_LOGIC_VECTOR(2 DOWNTO 0); -- izlaz brojaca C
40 SIGNAL co, co_not : STD_LOGIC; -- izlazni prenos sabiraca i njegov komplement
41 BEGIN
42 -- prihvatni registar B
43 REG_B: PROCESS (clk,rst)
44 BEGIN
45 IF(rst='1')THEN
46 regB <=(OTHERS => '0');
47 ELSIF(clk'EVENT AND clk='1') THEN
48 IF(eb ='1') THEN
49 regB <= b;
50 END IF;
51 END IF;
52 END PROCESS;
53 REG_A: shift GENERIC MAP(N=>8)
54 PORT MAP(si=>'0',ld=>la,ena=>ea,rst=>rst,clk=>clk,din=>a,q=>qa);
55 REG_R: shift GENERIC MAP(N=>8)
56 PORT MAP(si=>qa(7),ld=>lr,ena=>er,rst=>rst,clk=>clk,
57 din=>dr,q=>qr);
58 REG_Q: shift GENERIC MAP(N=>8)
59 PORT MAP(si=>co_not,ld=>'0',ena=>eq,rst=>rst,clk=>clk,
60 din=>(OTHERS=>'0'),q=>q);
61 ADD : adder GENERIC MAP(N=>8)
62 PORT MAP(cin=>'1',x=>qr,y=>regB_not,s=>sum,cout=>co);
63 CNT : counter GENERIC MAP(N=>3)
64 PORT MAP(ld=>lc,ena=>ec,rst=>rst,clk=>clk,din=>"111",q=>qc);
64 regB_not <= not regB;
66 dr <= sum WHEN rsel = '1' ELSE (OTHERS => '0');

145
67 z <= '1' WHEN qc = "000" ELSE '0'; -- multiplekser za reg R
68 co_not <= not co; -- invertor na izlazu sabiraca
69 cout <= co_not;
70 r<=qr;
71 END structure;
72-----------------------------------------------

1 ------control.vhd -----------------------------
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 -----------------------------------------------
5 ENTITY control IS
6 PORT (clk,rst,start,cout,z : IN STD_LOGIC;
7 rdy,rsel,la,ea,eb,lc,ec,lr,er,eq : OUT STD_LOGIC);
8 END control;
9 -----------------------------------------------
10 ARCHITECTURE ASM OF control IS
11 TYPE state IS (PASIVNO, SHRA, INCR);
12 SIGNAL pr_state, nx_state : state;
13 BEGIN
14 -- sekvencijalni process --------------------
15 PROCESS (clk,rst)
16 BEGIN
17 IF(rst='1')THEN
18 pr_state <=PASIVNO;
19 ELSIF(clk'EVENT AND clk='1') THEN
20 pr_state <= nx_state;
21 END IF;
22 END PROCESS;
23 -- kombinacioni process --------------------
24 PROCESS(start,z,cout,pr_state)
25 BEGIN
26 nx_state <= pr_state;
27 rdy<='0';la<='0';ea<='0';eb<='0';lc<='0';
28 ec<='0';lr<='0';er<='0';eq<='0';rsel<='0';
29 CASE pr_state IS
30 WHEN PASIVNO =>
31 rdy<='1';eb<='1';la<='1';ea<='1';lc<='1';ec<='1';
32 IF(start = '1') THEN
33 lr<='1'; er<='1';
34 nx_state <= SHRA;
35 END IF;
36 WHEN SHRA =>
37 er<='1';ea <='1';
38 nx_state <= INCR;
39 WHEN INCR =>
40 ec<='1';
41 IF(cout = '1') THEN
42 eq<='1';rsel<='1';lr<='1';er<='1';
43 ELSE
44 eq<='1';
45 END IF;
46 IF(z = '1') THEN
47 nx_state <= PASIVNO;
48 ELSE
49 nx_state <= SHRA;
50 END IF;
51 END CASE;
52 END PROCESS;
53 END ASM;
54-----------------------------------------------

146
Pr. 3-12 Sekvencijalni delitelj (dodatna optimizacija)
Sekvencijalni delitelj iz Pr. 3-11 obavlja deljenje dva n bitna broja za 2n taktnih ciklusa. Razlog za to su dva
stanja u unutrašnjoj petlji ASM dijagrama (SHRA i INCR) (vidi Sl. 3-27(c)). Ukoliko bi smo uspeli da ova dva
stanja sažmemo u jedno, broj potrebnih taktnih ciklusa bio bi smanjen na n. U stanju INCR, pod uslovom da je
R≥B, u R se upisuje razlika R-B, a novo stanje je SHRA. U stanju SHRA, R i A, zajedno, se pomeraju za jednu
poziciju ulevo. Da bi smo stanja SHRA i INCR objedinili u jedno stanja (neka se zove AKTIVNO), potrebo je
da postoji mogućnost da u jednom koraku (taktu) na pozicije veće težine registra R upišemo razliku i u isto
vreme na poziciju najmanje težine registra R prenesemo vrednost bita najveće težine registra A. To se može
postići uvođenjem dodatnog flip-flopa, r0, za poziciju najmanje težine R (Sl. 3-30(a)). Za izračunavanje razlike
koriste se n-1 nižih bita registra R zajedno sa flip-flopom r0. Pošto r0 sadrži bit najveće težine A iz prethodnom
ciklusa, efekat je isti kao da je pre oduzimanja obavljeno (R,A) ← (R,A) << 1. Z slučaj kada je R < B, u R se ne
upisuje razlika već se R pomera ulevo sa serijskim upisom vrednosti iz r0. Ostatak deljenja (r) je razlika koja je
u poslednjem ciklusu upisana u registar R (zbog toga je neophodno da R ima svih n bita). Funkcionalni ASM
dijagram sekvencijalnog delitelja sa jednim ceklusom po iteraciji prikazan je na Sl. 3-30(b).

Sl. 3-30 Dodatno ubrzanje sekvencijalnog delitelja iz Pr. 3-11: (a) princip; (b) funkcionalni ASM dijagram (prva
varijanta); (c) funkcionalni ASM dijagram (druga varijanta, sa objedinjenim registrima A i Q).
Dodatna optimizacija, u smislu uštede hardvera, može se postići ukoliko za promenljve A i Q koristimo jedan
zajednički registar. Promenljiva A iz ASM dijagrama sa Sl. 3-30(b), na početku rada, u stanju PASIVNO, dobija
vrednost deljenika (a), a zatim se, u stanju AKTIVNO, pomera ulevo sa upisom 0 na poziciju najmanje težine
(operacija A ← A << 1). Na kraju deljenja, posle n taktnih ciklusa, sadržaj registra A biće sve nule. Sa druge
strane, u registar Q se u svakom ciklusu deljenja serijski upisuje jedan bit količnika, tako da na kraju deljenja Q
sadrži kompletan količnik. Na Sl. 3-30(c) je prikazan funkcionalni ASM dijagram sekvencijalnog delitelja koji za
obe promenljive, A i Q, koristi isti registar Q. Na početku, u Q se upisuje deljenik, a. Kako deljenje odmiče,
tako se iz Q istiskuje a, a upisuje količnik.
Strukturni blok dijagram sekvencijalnog delitelja koji odgovara ASM dijagramu sa Sl. 3-30(c), prikazan je na Sl.
3-31. Za realizaciju registra Q koristi se pomerački registar sa mogućnošću paralelnog upisa. Za r0 koristi se D
flip-flop sa dodatnim multiplekserom putem kojega se reguliše resetovanje flip-flopa (u stanju PASIVNO),
odnosno upis bita najveće težine registra Q (u stanju AKTIVNO). Razrađeni ASM dijagram, kreiran na osnovu
funkcionalnog ASM dijagrama sa Sl. 3-30(c) i strukture sa Sl. 3-31, prikazan je na Sl. 3-32(a). Napomenimo da su
moguća izvesta pojednostavljenja razrađenog ASM dijagrama. Uočimo da su upravljački signali eq i ec aktivni
u oba stanja PASIVNO i AKTIVNO, i da zbog toga mogu biti postaljeni fiksno na eq=ec=1, umesto da se
generišu iz upravljačke jedinice. Takođe, signal er je aktivan u obe grane uslovnog koraka u stanju AKTIVNO i
zbog toga može biti prebačen u blok stanja AKTIVNO. Na Sl. 3-32(b) je prikazan razrađeni ASM dijagram
nakon izrvršenih modifikacija.
Čitaocu se prepušta da samostalno kreira odgovarajući VHDL kôd.

147
 Sl. 3-31 Razrađena struktura sekvencijalnog delitelja iz Pr. 3-12.

PASIVNO PASIVNO

rdy rdy eq=ec=1

eb; lb; eb; lb;
eq; lq; lq;
ec; lc; lc;

0 0
start start

1 1

er; lr; er; lr;

AKTIVNO AKTIVNO

ec; ec;
r0sel r0sel;
er;

1 0 1 0
cout cout

eq; eq;
rsel;lr;
er; rsel;lr; er;

0 1 0 1
z z

(a) (b)
Sl. 3-32 Razrađeni ASM dijagram sekvencijalnog delitelja iz Pr. 3-12: (a) početna varijanta; (b) pojednostavljena
varijanta.

148
4 Komponente digitalnih sistema
Složeni digitalni sistemi projektuju se tako što se najpre ukupna funkcija sistema razloži na više pod-funkcija.
Zatim se pod-funkcije realizuju u vidu jednostavnijih digitalnih modula, čijim se povezivanjem konstruiše
željeni sistem. Iako je u nekim slučajevima neophodno projektovati module za neke specifične funkcije, ipak,
najčešće, u praksi, složeniji digitalni sistemi se mogu realizovati korišćenjem standardnih modula ili
komponenti. Standardne komponente obavljaju funkcije za koje je uočeno da su korisne za veliki broj različitih
primena, a dostupne su u vidu integrisanih kola ili bibliotečkih komponenti i kao takve spremne za direktnu
ugradnju u sistem koji se projektuje.
Većina digitalnih sistema, uključujući i računare, projektovana je da obrađuje ili transformiše podatke. Ove
transformacije mogu biti različitih tipova, uključujući aritmetičke i logičke operacije, kodiranje i dekodiranje
podataka i reorganizaciju podataka. U opštem slučaju, navedene transformacije podataka se obavljaju pomoću
kombinacionih komponenti. Osnovna osobina kombinacionih kola jeste činjenica da se njihove izlazne
vrednosti izračunavaju isključivo na osnovu tekućih ulaznih vrednosti. Nakon svake promene ulaznih vrednosti,
na izlazu se javljaju nove izlazne vrednosti sa kašnjenjem koje je neophodno da bi se izračunao novi rezultat.
Kombinaciono kolo nije u stanju da ¨zapamti¨ prethodne rezultate, i da onda tu informaciju, zajedno sa tekućim
ulazom, koristi za određivanje novog izlaza.
Za razliku od kombinacionih, sekvencijalne komponente sadrže memorijske elemente, kao što su leč kola i
flip-flopovi. Kao posledica toga, izlazne vrednosti sekvencijalnih komponenti zavise ne samo od tekućih već i
od prethodnih ulaznih vrednosti. Spektar sekvencijalne komponenti se proteže od bazičnih memorijskih
elemenata, kao što su leč kola i flip-flopovi, preko registarskih komponenti, kao što su prihvatni, pomerački i
brojački registri, i složenijih memorijskih struktura, kao što su RAM, FIFO, stek, do upravljačkih jedinica koje
su u mogućnosti da izvršavaju složene algoritme.

4.1 Kombinacione komponente

Kombinacione komponente se koriste za: transformaciju podataka, povezivanje, konverziju podataka i
upravljanje. Konkretno, kombinacione komponente za transformaciju podataka obavljaju: (1) aritmetičke
operacije (sabiranje, oduzimanje, množenje i deljenje), (2) logičke operacije (AND, OR, XOR i komplement),
(3) operacije poređenja (veće ili jednako, manje) i (4) operacije za manipulaciju nad bitovima (pomeranje,
rotiranje, izdvajanje i umetanje bitova). Kombinacione komponente za povezivanje su multiplekseri i
magistrale, a koriste se za povezivanje aritmetičkih i memorijskih komponenti. Komponente za konverziju
podataka, kao što su koderi i dekoderi, se koriste za konverziju podatka iz jednog u neki drugi kôd.

4.1.1 Dekoderi
Dekoderi su digitalna kola koja se koriste za dekodiranje kodiranih informacija. Binarni dekoder, predstavljen
na Sl. 4-1, je digitalno kolo sa n ulaza za binarno kodirani podatak i 2n binarnih izlaza, pri čemu svakom izlazu
odgovara jedna kombinacija n logičkih vrednosti na ulazu. Dodatni ulaz za dozvolu rada, E, upravlja izlazom
dekodera na sledeći način: ako je E=0, tada ni jedan izlaz dekodera nije aktivan; ako je E=1, aktivan je samo
izlaz yi, gde je i ceo broj jednak binarnoj vrednosti ulaza wn-1, ..., w1, w0. (Ime ulaza E potiče od engleske reči
Enable koja znači dozvola). Ovo kolo se zove binarni dekoder n-u-2 n ili n-to ulazni binarni dekoder.

Sl. 4-1 Binarni dekoder n-u-2n.

Na Sl. 4-2 je prikazan binarni dekoder 1-u-2. Grafički simbol ovog dekodera se može videti na Sl. 4-2(a), a tabela
istinitosti na Sl. 4-2(b). Dekoder 1-u-2 ima jedan ulaza za podatak w0, ulaz za dozvolu rada E i dva izlaza y1 i y0.
Sve dok je E=1, važi: y0=1 za w0=0 ili y1=1 za w0=1. Logičke jednačine koje definišu dekoder 1-u-2 su oblika:
y0 = E·w0`
y1 = E·w0
Logička šema dekodera 1-u-2 prikazana je Sl. 4-2(c).

149
 (a) (b) (c)
Sl. 4-2 Dekoder 1-u-2: (a) grafički simbol; (b) tabela istinitosti; (c) logička mreža.
Dekoder 2-u-4 je predstavljen na Sl. 4-3(a). Uočimo da dekoder 2-u-4 ima dva ulaza za podatak, w1 i w0, ulaz za
dozvolu rada, E, i četiri izlaza, y0, ..., y3. Kao što je već objašnjeno, funkcija ovog dekodera je da dekodira
binarni broj postavljen na ulazima w1 i w0 i postavi 1 na izlaz čiji je indeks jednak tom broju. Funkcija dekodera
2-u-4 definisana je sledećim sistemom logičkih jednačina:
y0 = E·w1`w0`
y1 = E· w1`w0
y2 = E· w1w0`
y3 = E· w1w0

(a) (b) (c)

Sl. 4-3 Dekoder 2-u-4: (a) grafički simbol; (b) tabela istinitosti; (c) logička mreža.
U opštem slučaju, dekoder n-u-2n može se konstruisati na osnovu sistema logičkih jednačina:
yi = E·mi, i = 0, ..., 2n-1, (4.1)
gde je mi i-ti minterm n ulaznih promenljivih wn-1, ...., w0.
Na izlazu dekodera, pod uslovom da je njegov rad dozvoljen, postoji samo jedna jedinica. Za izlaz na kome je
prisutna jedinica kažemo da je aktivan. Ovo važi za dekodere sa aktivnim visokim naponskim nivoom na izlazu.
Međutim, u upotrebi su i dekoderska kola sa aktivnim niskim naponskim nivoom na izlazu. Kod takvih
dekodera, nula je prisutna na jednom izlazu, koji je izabran binarnom kombinacijom na ulazu, dok su na svim
ostalim izlazima prisutne jedince. Grafički simbol dekodera 2-u-4 sa aktivnim niskim naponskim nivoom na
izlazu prikazan je na Sl. 4-4(a). Uočimo da je aktivan nizak naponski nivo naznačen kružićima na izlaznim
priključcima dekodera. Tabela istinitosti ovog dekodera je prikazana na Sl. 4-4(b), a logička mreža na Sl. 4-4(c).
Uočimo da je logička mreža, po strukturi, identična onoj sa Sl. 4-3(c), s tom razlikom što se sada umesto I
koriste NI kola.

(a) (b) (c)

Sl. 4-4 Dekoder 2-u-4 sa aktivnim niskim naponskim nivoom na izlazu.
Pr. 4-1 Sinteza prekidačkih funkcija na bazi dekodera.
Shodno jednačini (4.1), dekoder n-u-2n se ponaša kao generator minterma od n promenljivih. Kada je rad
dekodera dozvoljen, svaki izlaz dekodera se aktivira tačno jednom vrstom tabele istinitosti od n promenljivih.
Ako je logička funkcija zadata u obliku tabele istinitosti ili skupom decimalnih indeksa, tada se ona može
direktno realizovati pomoću dekodera u vidu kanoničke sume-proizvoda.

150
Na primer, razmotrimo funkciju f zadatu skupom decimalnih indeksa ∑ (0,2,3,5) . Karnoova mapa funkcije f
prikazana je na Sl. 4-5(a), a realizacija ove funkcije u obliku minimalne sume-proizvoda na Sl. 4-5(b). Ista
funkcija se može realizovati pomoću dekodera 3-u-8, koji generiše sve moguće minterme od tri promenljive, i
jednog OR kola, koje sumira minterme funkcije f, kao što je prikazano na Sl. 4-5(c). Na ovaj način, korišćenjem
dekodera odgovarajuće veličine, moguće je realizovati proizvoljnu prekidačku funkciju.

(a) (b) (c)

Sl. 4-5 Sinteza funkcije ∑ (0,2,3,5) : (a) Karnoova mapa; (b) logička mreža; (c) realizacija pomoću dekodera 3-u-8.
Iako je opisana tehnika sinteze gotovo trivijalna, ona postaje izrazito neefikasna u slučajevima kada je broj
promenljivih veći od nekoliko. Broj minterma, a time i složenost dekodera, raste eksponencijalno sa povećanjem
broja promenljivih, tako da će za tipičnu funkciju većeg broj promenljivih, od svih generisani minterma biti
iskorišćen tek mali deo.
Danas se dekoderi retko koriste za sintezu prekidačkih funkcija na način koji je opisan u ovom primeru.
Međutim, izloženi koncept, sinteze zasnovan na sumiranju generisanih minterma, ili u opštem slučaju,
sumiranju generisanih produktnih članova, predstavlja osnovu programabilnih logičkih kola, kao što su ROM,
PLA i PAL strukture (sekcija Error! Reference source not found.).
Shodno jednačini (4.1) binarni dekoder n-u-2n se može realizovati pomoću 2n n-to ulaznih I logičkih kola.
Međutim, sa povećanjem n ukupan broj logičkih kola i broj ulaza u logička kola postaju ograničavajući faktor,
tako da se dekoderi sa većim brojem ulaza obično realizuju u vidu dekoderskih mreža sačinjenih od više manjih
dekodera. Razmotrićemo dve tehnike konstrukcije dekoderskih mreža: koincidentno dekodiranje i hijerarhijsko
dekodiranje.
Koincidentno dekodiranje
U cilju ilustracije koncepta koincidentnog dekodiranja, razmotrimo realizaciju 8-ulaznog binarnog dekodera
pomoću 4-ulaznih binarnih dekodera (Sl. 4-6). Neka su W=w7w6...w0 osam ulaz, a Y= y255y254...y0 256 izlazi
dekoderske mreže 8-u-256. Najpre, podelimo ulaze u dve grupe: WH=w7w6w5w4 i WL=w3w2w1w0. Za realizaciju
dekoderske mreže koristimo dva dekodera 4-u-16, kao na Sl. 4-6. Grupa ulaza WH se dekodira pomoću jednog, a
grupa ulaza WL pomoću drugog 4-ulaznog dekodera. Neka su H=h15h14...h0 i L=l15l14...l0 16-to bitni izlazi ovih
dekodera. Izlazi dekoderske mreže 8-u-256 formiraju se pomoću 256 2-ulaznih I kola, tako što se svako I kolo
povezuje sa jednim parom signala (hi, lj). Izlazu yk odgovara izlaz I kola čiji su ulazi hi i lj, pri čemu važi: k =
24 × i + j. Na primer, izlaz y36 odgovara I kolu čiji su ulazi h2 i l4, s obzirom da važi: 36 = 2 4 × 2 + 4. Uočimo da
je ulaz za dozvolu rada dekoderske mreže, E, povezan sa odgovarajućim ulazom jednog od dekodera 4-u-16,
dok je ulaz za dozvolu rada drugog dekodera postavljen na 1. Ako je E=0, tada su svi izlazi iz jednog dekodera
jednaki 0, što uslovljava yi=0 za svako i.
U opštem slučaju, n-to ulazni koincidentni dekoder se realizuje pomoću dva n/2 – ulazna binarna dekodera i 2n
2-ulaznih I kola, na način kako je to prikazano na Sl. 4-7.

151
 Sl. 4-6 8-ulazni koincidentni dekoder.

Sl. 4-7 n-to ulazni koincidentni dekoder.

Hijerarhijsko dekodiranje
Druga tehnika za konstrukciju većih dekodera je hijerarhijsko dekodiranje. Radi ilustracije ove tehnike
razmotrimo realizaciju binarnog dekodera 4-u-16 pomoću dekodera 2-u-4. Kao i kod koincidentnog
dekodiranja, ulazi dekoderske mreže, W=w3w2w1w0, se dele u dve grupe: WH=w3w2 i WL=w1w0. Na osnovu ove
podele, možemo realizovati dvonivovsku mrežu koja se sastoji iz jednog dekodera 2-u-4 u prvom i četiri
dekodera 2-u-4 u drugom nivou, kao što je prikazano na Sl. 4-8. Grupa ulaza WH se dekodira u prvom, a grupa
ulaza WL u drugom nivou. Šesnaest izlaza dekoderske mreže su raspoređeni u 4 grupe od po 4 izlaza, gde se
svaka grupa generiše na izlazima jednog dekodera sa drugog nivoa. Princip rada je sledeći: Dekodiranjem ulaza
WH, dekodera sa prvog nivoa dozvoljava rad jednog dekodera sa drugog nivoa, koji dekodiranjem ulaza WL
aktivira jedan od svojih izlaza. Na primer, ako je W=0110, tada je WH=01, a WL=10. To znači da će dekoder
DEC dozvoliti rad dekoderu DEC1‚ koji s obzirom na WL=10 aktivira svoj izlaz sa indeksom 2, što odgovara
izlazu dekoderske mreže y4x1+2=y6. Uočimo da je ulaz za dozvolu rada dekoderske mreže, E, povezan sa
odgovarajućim ulazom dekodera sa prvog nivoa. Ako je E=0, tada su svi izlazi dekodera DEC postavljeni na 0.
To znači da je rad svih dekodera sa drugog nivoa zabranjen i da su na svim izlazima dekoderske mreže prisutne
nule.

152
 Sl. 4-8 4-ulazni hijerarhijski dekoder.
U opštem slučaju, n-to ulazni dekoder se može realizovati u vidu dvo-nivolske dekoderske mreže sa jednim
(n/2)-ulaznim dekoderom u prvom i 2n/2 (n/2)-ulaznih dekodera u drugom nivou.
Hijerarhijska dekoderska mreža može imati više od dva nivoa. Na primer, ako za projektovanje koristimo
dekodere 1-u-2, dekoder n-u-2n, imaće 2n-1 dekodera 2-u-1, raspoređenih u n nivoa tako da se na svakom nivo
dekodira jedan ulazni bit. Drugim rečima, ulaz najveće težine dekodira se jednim dekoderom 1-u-2, sledeći ulaz
manje težine dekodira se sa dva dekodera 1-u-2, i tako dalje, sve do ulaza najmanje težine koji se dekodira sa
n/2 dekodera 1-u-2. Izlazi dekodera sa određenog nivoa se koriste kao signali dozvole jednog od dekodera sa
sledećeg nivoa. Znači, na svakom sledećem nivou, broj dekodera će biti dva puta veći u odnosu na prethodni
nivo. Kao primer opisanog postupka konstrukcije dekodera n-u-2n, na Sl. 4-9 je prikazan dekoder 3-u-8
realizovan na bazi dekodera 1-u-2.

Sl. 4-9 3-ulazni hijerarhijski dekoder 3-u-8.

U opštem slučaju, n-to ulazni dekoder se može realizovati u obliku hijerarhijske mreže k-ulaznih dekodera
raspoređenih u r nivoa, pri čemu važi n=rk. n ulaza dekoderske mreže se deli na r grupa od po k ulaza, pri čemu
se svaka takva grupa dekodira u jednom nivou. Prvi novo sadrži jedan dekoder, a broj dekodera u svakom
sledećem nivou je 2k puta veći od broj dekodera u prethodnom nivou. Ukupan broj k-ulaznih dekodera potrebnih
za realizaciju n-to ulazne dekoderske mreže iznosi:
1 + 2k + 22k + ... + 2(r-1)k = (2n – 1)/(2k – 1)
Na primer, za n=12 i k=4, broj nivoa je r=3, a broj 4-ulaznih dekodera (2 12 – 1)/(24 – 1) = 273.

153
4.1.2 Multiplekseri
Multiplekser, često u oznaci MUX, je digitalni preklopnik – tj. kolo koje omogućava da se jedan od n izvora
podataka logički poveže na zajedničko odredište. Multiplekser ima veći broj ulaza za podatke, jedan ili više
selekcionih ulaza i jedan izlaz. Vrednost selekcionih ulaza određuje (tj. bira) jedan od ulaza za podatke čija se
vrednost, u datom trenutku, prenosi na izlaz. Na Sl. 4-10(a) je prikazan grafički simbol multipleksera 2-u-1. Ako
je s=0, izlaz multipleksera biće f=w0; ako je s=1, izlaz multipleksera je f=w1. Multiplekser 2-u-1 je po funkciji
analogan elektro-mehaničkom dvo-položajnom prekidaču sa Sl. 4-10(b), kod koga signal s upravlja položajem
preklopnika. Ponašanje multipleksera 2-u-1 opisano je tabelom istinitosti sa Sl. 4-10(c), na osnovu koje lako
možemo izvesti logički izraz oblika suma-proizvoda: f=s`w0 + sw1. Ovom izrazu odgovara logička mreža sa Sl.
4-10(d). Na Sl. 4-10(e) je prikazano kako se multiplekser 2-u-1 može realizovati pomoću transmisionih gejtova.

(a) (b) (c)

w0

s
s

w0 f w1 f

w1

(d) (e)
Sl. 4-10 Multiplekser 2-u-1: (a) grafički simbol; (b) analogija sa elektromehaničkim preklopnikom; (c) tabela
istinitosti; (d) logička mreža; (e) realizacija pomoću transmisionih gejtova.
Na Sl. 4-11(a) je prikazan jedan veći multiplekser, sa četiri ulaza za podatke, w0, …, w3 i dva selekciona ulaza s1
i s0. Kao što se može videti iz tabele istinitosti sa Sl. 4-11(b), kombinacija selekcionih ulaza (s1, s0), interpretirana
kao binarna celobrojna vrednost i, za prosleđivanje na izlaz f bira ulaz wi. Multiplekseru 4-u-1 odgovara sledeći
logički izraz oblika suma-proizvoda:
f = s1`s0`w0 + s1`s0w1 + s1s0`w2 + s1s0w3
Ovom izrazu odgovara logička mreža sa Sl. 4-11(c)

(a) (b) (c)

Sl. 4-11 Multiplekser 4-u-1: (a) grafički simbol; (b) tabela istinitosti; (c) logička mreža.
Korišćenjem istog principa, moguće je realizovati i veće multipleksere. Obično, broj ulaza za podatke, n, je
stepen broja 2. Multiplekser n-u-1 zahteva log 2 n selekcionih ulaza.
Veći multiplekseri se takođe mogu realizovati pomoću manjih multipleksera. Na primer, multiplekser n-u-1, gde
je n stepen broja 2, može se konstruisati pomoću n-1 multipleksera 2-u-1 raspoređenih u log 2 n nivoa. Svaki od
n/2 multiplekser sa prvog nivoa bira između dva izvora podataka, dok svaki od n/4 multiplekser sa drugog nivoa
bira između dva multiplekserska izlaza sa prvog nivoa. Drugim rečima, na svakom nivou, nakon prvog, svaki
multiplekser se koristi za izbor između dva izlaza generisana od strane multipleksera sa prethodnog nivoa.
Konkretno, za realizaciju multipleksera 8-u-1 potrebna su 8-1=7 multipleksera 2-u-1, a broj nivoa je 3. Na Sl.
4-12(a) je prikazana tabela istinitosti, a na Sl. 4-12(b) realizacija multipleksera 8-u-1 pomoću multipleksera 2-u-
1.

154
 Sl. 4-12 Multiplekser 8-u-1: (a) tabela istinitosti: (b) struktura.
Na Sl. 4-13(a) prikazan je grafički simbol multipleksera 2xm-u-m. Ovaj simbol na kompaktan način predstavlja
strukturu od m paralelno povezanih multipleksera sa Sl. 4-13(b). Pomoću multipleksera 2xm-u-m omogućen je
izbor jednog od dva m-bitna operanda. U opštem slučaju, multiplekser kxm-u-m sastoji se iz m multipleksera k-
u-1 sa zajedničkim selekcionim ulazima.
2xm-u-m
mux

Sl. 4-13 Multiplekser 2xm-u-m: (a) grafički simbol; (b) struktura.

Multiplekser 8-u-1 se može realizovati i na način koji je prikazan na Sl. 4-14. U ovom slučaju, za dekodovanje
selekcionih signal koristi se dekoder 3-u-8. Iako ovo rešenje izgleda jednostavno, ono, međutim, nije lako
proširljivo. Drugim rečima, broj i veličina logičkih kola u dekoderu, kao i veličina izlaznog ILI kola raste sa
povećanjem broja ulaza u multiplekser. S obzirom da se logička kola sa velikim brojem ulaza realizuju u vidu
stabla logičkih kola sa manjim brojem, cena i kašnjenje se značajno povećavaju. Iz tog razloga, rešenje sa Sl.
4-14 se koriste samo za male vrednosti n, dok se multiplekseri za veće vrednosti n konstruišu ranije opisanom
metodom, korišćenjem više nivoa multipleksera 2-u-1 ili 4-u-1.

155
 (a) (b)
Sl. 4-14 Realizacija multipleksera pomoću dekodera: (a) tabela istinitosti multipleksera 8-u-1; (b) realizacija na bazi
dekodera.
Na Sl. 4-15 je prikazana još jedna realizacija multipleksera pomoću dekodera kod koje se umesto dvo-nivovske
I-ILI mreže koristi niz trostatičkih bafera sa kratkospojenim izlazima. Dekoder obezbeđuje da će uvek biti
aktivan samo jedan trostatički bafer, koji prosleđuje vrednost sa svog ulaza na zajednički izlaz. Izlazi
trostatičkih bafera ne moraju fizički biti spojeni u jednu tačku, već mogu biti povezani vezom (magistralom)
koja kontaktira svaki izlaz, što je pogodno u slučajevima kada su izvori podatak (moduli koji generišu signale
D0-D3) prostorno razuđeni.

Sl. 4-15 Realizacija multipleksera pomoću dekodera i trostatičkih bafera.

Pr. 4-2 Krozbar prekidač
Na Sl. 4-16(a) prikazano je kolo sa dva ulaza, x1 i x2, i dva izlaza, y1 i y2. Kao što je naznačeno isprekidanim
linijama, kolo obezbeđuje kontrolisanu vezu između ulaznih i izlaznih priključaka, tj. omogućava da bilo koji
ulaz može biti povezan na bilo koji izlaz. U opštem slučaju, kolo ovog tipa, sa n ulaza i k izlaza, čija je jedina
funkcija da obezbedi spregu bilo koji ulaz sa bilo kojim izlazom, zove se krozbar prekidač nxk. Ako postoje dva
ulaza i dva izlaza, radi se o krozbar prekidaču 2x2.
Na Sl. 4-16(b) je prikazana realizacija krozbar prekidača 2x2 pomoću multipleksera 2-u-1. Selekcioni ulazi oba
multipleksera povezana su na ulazni signal s. Ako je s=0, krozbar povezuje x1 na y1 i x2 na y2; za s=1, veze su
ukrštene, tako da se podatak sa ulaza x1 sprovodi na izlaz y2, a podatak sa ulaza x2 na izlaz y1. Krozbar prekidači
su korisna kola koja nalaze primenu svuda tamo gde je neophodno povezati dva skupa veza, pri čemu se način
sprege menja s vremena na vreme.

156
 (a) (b)
Sl. 4-16 Krozbar prekidač: (a) korzbar 2x2; (b) realizacija pomoću multipleksera

4.1.3 Demultiplekseri
Kao što je rečeno u odeljku 4.1.2, multiplekser je digitalno kolo sa jednim izlazom, n ulaza za podatke i log 2 n 
selekcionih ulaza. Namena multipleksera je da multipleksira n ulaza za podatke preko jedinstvenog izlaza za
podatak, pod kontrolom selekcionih ulaza. Kolo koje obavlja suprotnu funkciju – vrednost sa jedinstvenog ulaza
za podatak prosleđuje na jedan od više izlaza za podatke, zove se demultiplekser.
Na Sl. 4-17(a) je prikazan grafički simbol demultipleksera 4-u-1. Kao što se vidi iz tabele istinitosti sa Sl.
4-17(b), binarna kombinacija vrednosti selekcionih ulaza s1 i s2 bira jedan od četiri izlaza, y0, ..., y3, na koji se
prenosi vrednost jedinstvenog ulaza za podatak, d. Demultiplekser 1-u-4 se može realizovati pomoću dekodera
2-u-4, kao što je prikazano na Sl. 4-17(c). U ovom slučaju, ulaz E dekodera se koristi kao ulaz za podatak
demultipleksera, dok su izlazi dekodera izlazi za podatke demultipleksera. Binarna kombinacija w1w0 određuje
izlaz koji će biti postavljen na vrednost E. Ako je E=0, tada će svi izlazi dekodera biti 0, uključujući i izlaz koji
je izabran kombinacijom w1w0; ako je E=1, tada kombinacija w1w0 postavlja 1 na odgovarajući izlaz. Dakle,
uvek važi y(w1w0) = E.

(a) (b) (c)

Sl. 4-17 Demultiplekser 1-u-4: (a) grafički simbol; (b) tabela istinitosti; (c) dekoder 2-u-4 kao demultiplekser 1-u-4.
Pr. 4-3 Vremenski multipleks
Par multiplekser-demultiplekser se može koristiti za prenos informacije od n izvora do n odredišta preko
jedinstvene komunikacione linije, kao što je to za slučaj n=8, prikazano na Sl. 4-18. Multiplekser bira jedan od n
izvora i prenosi podatak tog izvora na komunikacionu liniju. Na drugom kraju linije, demultiplekser usmerava
primljeni podatak ka jednom od n odredišta. Izbor para izvor-odredište obavlja se preko selekcionih ulaza
multipleksera i demultipleksera. Ovakav način prenosa informacija zove se vremenski multipleks. Uz
ograničenje da u bilo kom trenutku može postojati direktna sprega samo jednog para izvor-odredište, vremenski
multipleks omogućava značajno smanjenje broja potrebnih prenosnih linija, što može predstavljati značajnu
uštedu, naročito ako je rastojanje između izvori i odredišta podataka veliko.

Sl. 4-18 Princip vremenskog multipleksa.

157
4.1.4 Koderi
Binarni koder 2n-u-n (Sl. 4-19) kodira (transformiše) informaciju od 2 n bita u n-bitnu kodnu reč. Sa ograničenjem
da u bilo kom trenutku samo jedan od 2n ulaza može imati vrednost 1, na izlazu binarnog kodera generiše se n-
bitni binarni broj koji ukazuje na indeks ulaza čija je vrednost 1. Na Sl. 4-20(a) je prikazana tabela istinitosti
kodera 4-u-2. Tabela istinitosti je nepotpuna, jer sadrži samo one slogove koji su dozvoljeni na ulazu binarnog
kodera. Za sve ostale slogove, odziv kodera je nedefinisan. Uočimo da izlaz y0 ima vrednost 1 ako je w1=1 ili
w3=1. Slično, izlaz y1 ima vrednost 1, ako je w2=1 ili w3=1. Na osnovu ovog zapažanja možemo konstruisati
logičku mrežu binarnog kodera 4-u-2 prikazanu na Sl. 4-20(b). U opštem slučaju, binarni koder 2n-u-n može se
realizovati pomoću n (2n-1)-to ulaznih OR kola. Svako OR kolo postavlja jedan izlaz. Ulaz wi je povezan sa j-
tim OR kolom ako j-ti bit u binarnoj reprezentaciji indeksa i ima vrednost 1.

Sl. 4-19 Binarni koder 2n-u-n.

(a) (b)
Sl. 4-20 Binarni koder 4-u-2: (a) tabela istinitosti; (b) kolo.
Pr. 4-4 Jedna primena binarnog kodera
Na Sl. 4-21 je prikazan osmo-položajni mehanički preklopnik. Preklopnik ima 8 izlaza koji u kodu 1-od-8
kodiraju položaj klizača. U ovoj primeni, binarni koder 8-u-3 se koristi za kodiranje položaj kliza ča u oblik
trobitnog celog broja.

Sl. 4-21 Primena binarnog kodera.

Prioritetni koder
Kod binarnog kodera opisanog u prethodnom odeljku postoji ograničenje da u bilo kom trenutku najviše jedan
ulaz sme biti aktivan. Ako se ovo ograničenje ne poštuje, u slučajevim kada je aktivno više od jednog ulaza,
izlaz kodera biće pogrešan. Međutim, u mnogim primenama ovo ograničenje se ne može nametnuti. U takvim
slučajevima, umesto kodera treba koristiti prioritetni koder.
Kod prioritetnog kodera, svakom ulazu je dodeljen prioritet, a izlaz kodera, interpretiran kao binarni broj,
ukazuje na indeks aktivnog ulaza najvišeg prioriteta. Za sve vreme dok je aktivan ulaz visokog prioriteta, svi
ulazi nižeg prioriteta se ignorišu. Na Sl. 4-22 je prikazana tabela istinitosti prioritetnog kodera 4-u-2, pod
pretpostavkom da ulaz w3 ima najviši, a w0 najniži prioritet. Izlazi y1 i y0 predstavljaju binarni broj koji
identifikuje ulaz najvišeg prioriteta koji ima vrednost 1. Pošto je moguće da ni jedan ulaz nema vrednost 1,
predviđen je još jedan, dodatni izlaz, z koji treba da ukaže na ovu situaciju. Naime, ako je barem jedan ulaz
jednak 1, tada je z=1; inače, ako ni jedan ulaz nije jednak 1, važi z=0.

158
 Sl. 4-22 Tabela istinitosti prioritetnog kodera 4-u-2.
Rad prioritetnog kodera se najlakše može razumeti ako najpre razmotrimo poslednju vrstu u tabeli istinitosti.
Ova vrsta kazuje da ako je w3=1, izlaz se postavlja na y1y0=11. Pošto ulaz w3 ima najviši prioritet, vrednosti
ulaza w2, w1 i w0 nisu od značaja. Da bi se ukazalo na činjenicu da su njihove vrednosti irelevantne, promenljive
w2, w1 i w0 su označene simbolom X. Pretposlednja vrsta u tabeli istinitosti kazuje da se za w2=1 izlazi
postavljaju na y1y0=10, ali samo ako je pri tome w3=0. Slično, ulaz w1 uslovljava da izlaz bude postavljen na
y1y0=01, ali samo pod uslovom da važi w3=w2=0. Konačno, ulaz w0 se kodira na izlazu binarnom kombinacijom
y1y0=00, ali samo pod uslovom da je w0 jedini aktivan ulaz.

Sl. 4-23 Realizacija prioritetnog kodera.

n
Prioritetni koder 2 -u-n se može realizovati kombinovanjem dva modula kao na Sl. 4-23. Prvi modul je kolo za
razrešavanje prioriteta koje menja na 0 sve ulaze čija je vrednost 1, osim onog čiji je prioritet najviši. Drugi
modul je standardni binarni koder. Modul za razrešavanje prioriteta definisan je sledećim skupom logičkih
jednačina:
xi = w2' n −1w2' n −2 K wi'−1wi , i=0, 1, ..., 2n-1

Prethodni izraz kaže da aktivan ulaz xi zadržava vrednost 1 samo ako su svi ulazi višeg prioriteta jednaki 0.

(a) (b)
Sl. 4-24 Modul za razrešavanje prioriteta: (a) paralelna realizacija; (b) iterativna realizacija.
Modul za razrešavanje prioriteta se može realizovati u obliku logičke mreže sa Sl. 4-24(a). Kod ove realizacije,
izlaz i se generiše pomoću AND kola sa 2n-i ulaza. Ovakvo rešenje je adekvatno za module sa malim brojem
ulaza, ali je nepraktično za veće module, s obzirom da zahteva AND kola sa velikim brojem ulaza. Na Sl. 4-24(b)
je prikazana iterativna realizacija istog kola, koja je pogodna za veći broj ulaza, mada ispoljava veće kašnjenje.
Ovo rešenje je zasnovano na umnožavanju ćelija definisanih logičkim jednačinama:
ci-1 = ci + xi
zi = ci`xi
Prosto, xi=1 postavlja ci-1 na 1, što isključuje sve ulaze nižeg prioriteta.

159
Hijerarhijska realizacija prioritetnog kodera
Na Sl. 4-25(a) je prikazana realizacija prioritetnog kodera 4-u-2 pomoću prioritetnih kodera 2-u-1. Ulazi su
podeljeni u dve dvobitne grupe i nezavisno kodirani prioritetnim koderima H i L. Drugi nivo strukture sa Sl.
4-25(a), koji se sastoji iz dodatnog prioritetnog kodera 2-u-1, G, i multipleksera 2-u-1, formiran je shodno tabeli
istinitosti prioritetnog kodera 4-u-2 sa Sl. 4-22 iz koje sledi da izlaz y1 ukazuje na grupu, H ili L, koja sadrži
aktivan ulaz najvišeg prioriteta, a izlaz y0 na poziciju aktivnog ulaza najvišeg prioriteta u okviru grupe na koju
ukazuje y1. Na osnovu sličnog rezonovanja, na Sl. 4-25(b) je nacrtana struktura prioritetnog kodera 8-u-3. U
opštem slučaju, prioritetni koder 2n-u-n u prvom nivou sadržaće dva prioritetna kodera 2n-1-u-(n-1), a u drugom
jedan prioritetni koder 2-u-1, za generisanje izlaza z i yn-1 i multiplekser 2x(n-1)-u-(n-1) za prosleđivanje kodnih
izlaza jednog od kodera H ili L na izlaze yn-2, .., y0 (Sl. 4-25(c)).
Koliko je prioritetnih kodera 2-u-1 i multipleksera 2-u-1 potrebno za realizaciju prioritetnog kodera 2 n-u-n ?

(a) (b) (c)

Sl. 4-25 Iterativna realizacija prioritetnog kodera.

4.1.5 Komparator magnitude

Relacioni izrazi se formiraju uz pomoć tri osnovna operatora: veće (X>Y), jednako (X=Y) i manje (X<Y).
Takođe, za svaki od ovih operatora postoji komplementarni operator. Operator “veće ili jednako” (X≥Y) je
komplement od “manje”, “manje ili jednako” (X≤Y) je komplement od “veće”, dok je “različito” (X≠Y)
komplement od “jednako”. Rezultat bilo kog od navedenih operatora je logička promenljiva koja može imati
vrednost 0 ili 1.
Za izračunavanje relacionih operatora koriste se digitalna kola koja se zovu komparatori magnitude ili samo
komparatori. Iako je moguće projektovati komparator za bilo koji operator, u ovom odeljku pokazaćemo kao
se projektuje univerzalni komparator, koji se koristi za izračunavanje bilo kog od navedenih operatora. U
opštem slučaju, n-bitni univerzalni komparator (Sl. 4-26) poredi dva pozitivna cela broja X=xn-1,…,x0 i Y=yn-
1,…,y0 i generiše tri binarna rezultata, G, E i L, koji imaju sledeće značenje: Ako je izlaz G=1, tada je X>Y; E=1
ukazuje na X=Y, a L=1 na X<Y.

Sl. 4-26 n-to bitni univerzalni komparator magnitude.

Logička mreža komparatora se može sintetizovati na osnovu tabele istinitosti u kojoj bi za svaku kombinaciju n-
bitnih operanada X i Y bile navedene vrednosti izlaza G, E i L. Međutim, takva tabela bi bila previše velika, čak i
za relativno malo n. Zato je bolji pristup da se u cilju realizacije kompartora razmatraju pojedinačni parovi
odgovarajućih bitova dva operanda. Razmotrimo konstrukciju 4-bitnog komparatora.
Neka su X=x3x2x1x0 i Y=y3y2y1y0. Definišimo skup internih signala i3, i2, i1 i i0. Signal ik je jednak 1 ako su bitovi
sa indeksom k operanada X i Y međusobno jednaki, tj. ik = (xk ⊗ yk). Dva binarna broja su jednaka ako imaju iste
bitove. Dakle,
E = i3i2i1i0
Izraz za izlaz G se može izvesti tako što će se bitovi operanada X i Y ispitivati u redosledu počev od bita najveće
do bita najmanje težine. Prva bitska pozicija k na kojoj se bitovi xk i yk razlikuju odrediće da li je X veće ili

160
manje od Y. Pri tome, ako je xk=0 i yk=1, važi X<Y; ako je xk=1 i yk=0, važi X<Y. Dakle, izlaz G definisan je
sledećim logičkim izrazom:
G = x3y3` + i3x2y2` + i3i2x1y1` + i3i2i1x0y0`
Izlaz L se može odrediti na osnovu druga dva izlaza. Naime, X je manje od Y ako X i Y nisu ni jednaki niti je X
veća od Y, tj.
L = (E + G)´
Logička mreža koja realizuje četvorobitni univerzalni komparator prikazana je na Sl. 4-27. Opisana procedura se
može primeniti za konstrukcije univerzalnog komparatora za proizvoljno n.

Sl. 4-27 Logička mreža 4-bitnog univerzalnog komparatora.

Pr. 4-5 8-bitni univerzalni komparator
Na Sl. 4-28 je prikazano kako se pomoću dva 4-bitna univerzalna komparatora i dodatnih logičkih kola može
realizovati 8-bitni univerzalni komparator. Operande X i Y možemo napisati u obliku:
X = XH × 2 4 + XL
Y = YH × 24 + YL
gde su XH= x7x6x5x4, XL= x3x2x1x0, YH= y7y6y5y4 i YL= y3y2y1y0 više i niže tetrade brojeva X i Y. Najpre, dva 4-bitna
komparatora nezavisno porede više i niže tetrade brojeva X i Y, a zatim se na osnovu njihovih izlaza određuje
konačni rezultat. Dva broja su jednaka ako važi XH=YH i XL=YL. X je veće od Y ako je XH>YH ili ako su ako su XH
i YH jednaki i pri tome XL>YL. Konačno, X je manje od Y ako je viša tetrada broja X manja od više tetrade broja
Y ili ako su više tetrade dva broja jednake i pri tome niža tetrada broja X manja od niže tetrade broja Y.

Sl. 4-28 Realizacija 8-bitnog komparatora pomoću 4-bitnih komparatora.

Pr. 4-6 Realizacija komparatora pomoću binarnog sabirača
Na Sl. 4-29 je prikazano kako se 4-bitni univerzalni komparator može realizovati pomoću 4-bitnog sabirača.
Odnos između dva broja X i Y može se odrediti ako se brojevi najpre oduzmu, a zatim ispita rezultat.
Oduzimanje X-Y se realizuje kao sabiranje broja X i dvojičnog komplementa broja Y. Kod oduzimanja
neoznačenih binarnih brojeva važi pravilo da je izlazni prenos iz sabirača, c4, jednak 0 ako je razlika negativna,
odnosno 1 ako je razlika nula ili pozitivna. Drugim rečima, c4=0 ukazuje na X<Y, a c4=1 na X≥Y. Ovo pravilo se
lako može proveriti na sledećim konkretnim primerima:

161
Uslov X≥Y se može razložiti na dva uslova X>Y i X=Y ako se dodatno detektuje kada je rezultat 0. Za detekciju
uslova “sve nule” može se iskoristiti 4-ulazno NOR kolo, kao što je prikazano na Sl. 4-29. Dakle, ako je razlika
0, brojevi su jednaki; ako je c4=0, tada je X manje od Y, a ako razlika nije jednaka nuli i c4=1, tada je X veće od
Y.
x3 x2 x1 x0 y3 y2 y1 y0

c4 n-bitni sabirač c0 1

E (X=Y)

L (X<Y)

G (X>Y)

Sl. 4-29 Realizacija univerzalnog komparatora pomoću binarnog sabirača.

Iterativne komparatorske mreže
Razmotrimo konstrukciju 16-bitnog komparatora na osnovu 4-bitnih komparatorskih modula. Za ovu namenu,
ulazni 16-bitni operandi X=x15x14...x0 i Y=y15y14...y0 se razlažu na po četiri 4-bitna vektora:
X(i) = xi*4+3xi*4+2xi*4+1xi*4, i=0,..., 3
Y(i) = yi*4+3yi*4+2yi*4+1yi*4, i=0,..., 3
koji se koriste kao ulazi u pojedinačne 4-bitne komparatorske module. Poređenje se obavlja sukcesivno (tj.
iterativno), počev od bit-vektora najmanje težine, X(0) i Y(0), a rezultat poređenja, izražen promenljivama G, E i L
se prenosi u naredni stepen. Ako su bit-vektori X(i) i Y(i) jednaki, preuzima se rezultat iz prethodnog stepena; ako
se X(i) i Y(i) razlikuju, rezultat prethodnog stepena se zanemaruje, a stepen i dalje prosleđuje rezultat svog
poređenja. Izlazi G, E i L su u isto vreme i izrazi celokupne komparatorske mreže. Da bi se omogućila sprega
komparatorskih modula, neophodno je strukturu 4-bitnog komparatora sa Sl. 4-26 proširiti sa tri ulazna signala
prenosa, kao na Sl. 4-30. Na Sl. 4-31 je prikazana struktura 16-bitnog iterativnog komparatora magnitude,
realizovanog pomoću 4-bitnih komparatora sa Sl. 4-31.

Sl. 4-30 4-bitni komparator sa ugrađenim signalima ulaznog prenosa.

Sl. 4-31 16-bitna iterativna komparatorska mreža.

162
Opisani postupak se može primeniti za konstrukciju iterativnog komparatora sa proizvoljno velikim brojem
bitova. Međutim, kao i kod sabirača sa rednim prenosom, sa povećanjem broj spregnutih bazičnih modula
propagaciono kašnjenje komparatorske mreže linearno raste.
Hijerarhijske komparatorske mreže
Brža struktura za poređenje većih brojeva se može realizovati ako se umesto iterativne koristi hijerarhijska
mreža komparatora. Razmotrimo ponovo konstrukciju 16-bitnog komparatora na osnovu 4-bitnih
komparatorskih modula, ali sada tako da komparatorski moduli budu povezani u hijerarhijsku strukturu, kao što
je ona sa Sl. 4-32. Svaki od četiri modula sa prvog nivoa, K0 do K3 poredi dva bit-vektora od četiri bita. Izlazi iz
prvog nivoa se koriste kao ulazi u jedinstveni komparatorski modul sa drugog nivoa, K4, na sledeći način: Svi
izlazi G iz komparatorskih modula sa prvog nivoa čine bit-vektor g koji je povezan na grupu ulaza x
komparatora K4. Slično, bit-vektor l, koga čine svi izlazi L iz prvog nivoa, povezan je na grupu ulaza y
komparatora K4.
Da mreža sa Sl. 4-32 zaista realizuje funkciju 16-bitnog komparatora, može se pokazati sledećom analizom. Na
osnovu definicije komparatorskog modula, izlazi hijerarhijske mreže komparatora su:
1 ako je g > l
G=
0 inace
1 ako je g = l
E=
0 inace
1 ako je g < l
L=
0 inace

gde su g i l celi brojevi predstavljeni istoimenim bit-vektorima.

S obzirom da su g i l izlazi iz prvog nivoa komparatorskih modula, nije moguće da oba bita gi i li u isto vreme
imaju vrednost 1. Shodno tome, g>l znači da je 1-ca najveće težine u vektoru g teža od 1-ce najveće težine u
vektoru l, što odgovara slučajevima kada je X>Y. Slično, g<l sledi iz X<Y. Slučaj g=l se javlja samo ako važi
g=l=0, što znači da važi X=Y. Dakle, mreža sa slike realizuje funkciju poređenja brojeva X i Y.
X(3) Y(3) X(2) Y(2) X(1) Y(1) X(0) Y(0)
4 4 4 4 4 4 4 4

K3 K2 K1 K0

G E L G E L G E L G E L
g3 l3 g2 l2 g1 l1 g0 l0

4 4

x y
K4

G E L
Sl. 4-32 16-bitni hijerarhijski komparator.

4.1.6 Kombinacioni pomerači i rotatori

Operacije pomeranja i rotiranja često se koriste za pakovanje i raspakovanje cifara i karaktera, izdvajanje i
umetanje bitskih polja, kao i za realizaciju operacija za rad u pokretnom zarezu. Operacije pomeranja mogu se
obavljati u logičkom ili aritmetičkom režimu. Pri logičkom pomeranju, bit-vektor se pomera za m bitskih
pozicija ulevo ili udesno. Kao rezultat ove operacije, m bita sa jedne strane vektora se izbacuje, a m novih bita se
ubacuje sa druge strane vektora. Pri aritmetičkom pomeranju, pretpostavlja se da bit-vektor koji se pomera
predstavlja binarni broj, tako da pomeranje za m pozicija udesno ima isti efekat kao deljenje broja sa 2m, dok je
pomeranje za m pozicija ulevo isto što i množenje sa 2m. Ako bit-vektor predstavlja brojnu vrednost u formatu
dvojičnog komplementa, tada se prilikom pomeranja udesno, u vektor, sa leve strane, ubacuje m kopija bita
znaka. Za slučaj pomeranja ulevo, u vektor se, sa desne stane, ubacuje m nula. Dodatno, nakon pomeranja ulevo,
na poziciju bita najveće težine treba postaviti vrednost koja je jednaka bitu znaka polazne reči. Pri operaciji
rotiranja, bitovi se ne gube, jer se svaki bit koji izađe sa jedne strane reči, vraća u reč sa druge strane.
Za obavljanje operacija pomeranja i rotiranja koriste se digitalne komponente koje se zovu pomerači i rotatori.
Ove komponente se konstruišu pomoću multipleksera. Na primer, na Sl. 4-33(a) je prikazan grafički simbol 8-

163
bitnog univerzalnog pomerača/rotatora, koji može da obavlja logičko pomeranje ili rotiranje za jednu bitsku
poziciju na levo ili na desno. Kolo ima 8-bitni ulaz za podatak D=d7...d0, 8-bitni izlaz za podatak Y=y7...y0, i tri
selekcione linije, S2, S1 i S0, preko kojih se vrši izbor željene operacije. Ulaz dl definišu bitsku vrednost koja se
prilikom pomeranja na desno postavlja na krajni levi izlaz, y7, dok ulaz dl definiše vrednost koja se postavlja na
krajnji desni izlaz, y0, prilikom pomeranja na levo. Shodno funkcionalnoj tabeli sa Sl. 4-33(b), kada je S2=0,
ulazni podatak se, bez ikakve promene, prenosi na izlaz. Ako je S2=1, nad ulaznim podatkom se obavlja
operacija pomeranja ili rotiranja. Smer pomeranja, odnosno rotiranja, zavisi od vrednosti S1: za S1=0 bitski
sadržaj podatka se pokreće na levo, a za S0=1 na desno. Konačno, S0 služi za izbor između pomeranja i
rotiranja, tako da pri S0=0 pomerač/rotator radi kao pomerač, a pri S0=1 kao rotator. Na Sl. 4-33(c) su ilustrovani
različiti režimi rada univerzalnog pomerača/rotatora.

(a) (b)

(c)
Sl. 4-33 Univerzalni pomerač/rotator: (a) grafički simbol; (b) funkcionalna tabela; (c) režimi rada.
Na Sl. 4-34 je prikazana realizacija 8-bitnog univerzalnog pomerača/rotatora. Kao što se može videti,
pomerač/rotator je realizovan tako što je za svaku bitsku poziciju iskorišćen jedan multipleksera 4-u-1. Ulazi
multipleksera su tako raspoređeni da multiplekser koji zauzima poziciju i, može da bira između ulazih bita i-1, i
i i+1. Dodatno, pomerač/rotator ima dva multipleksera 2-u-1, koji služe za izbor krajnjeg levog ili krajnjeg
desnog bita.

Sl. 4-34 Realizacija 8-bitnog univerzalnog pomerača/rotatora sa Sl. 4-33 pomoću multipleksera.

164
Barel pomerač
Prethodno opisani pomerač/rotator ima mogućnost pomeranja ili rotiranja za jednu bitsku poziciju ulevo ili
udesno. To znači da ako je potrebno obaviti pomeranje ili rotiranje za više od jedne bitske pozicije, podatak bi
morao biti propušten kroz pomerač/rotator veći broj puta. Drugim rečima, na ovakvom tipu pomerača, operacija
pomeranja za proizvoljan broj pozicija se izvršava sporo. Da bi se izbeglo ovo veliko kašnjenje, kod sistema gde
se zahtevaju visoke performanse, koristi se barel pomerač, koji je tako projektovan da može obaviti pomeranje
za proizvoljan broj pozicija. n-bitni pomerač ovog tipa, gde je n=2m, sadrži m=log2n nivoa multipleksera
raspoređenih tako da i-ti nivo multipleksera (0≤i≤m-1) obavlja pomeranje za 2i pozicija, ako je selekciona linija
ovog nivoa Si=1. Ako je Si=0, podatak prolazi kroz i-ti nivo nepromenjen. Drugim rečima, ako želimo da
pomerimo podatak za B pozicija, gde je B binarni broj bm-1...b0, tada je potrebno postaviti Si=bi, za 0≤i≤m-1.
Na Sl. 4-35 je prikazano jedno moguće rešenje barel pomerača, kod koga je, u cilju pojednostavljenja, broj
funkcija sveden samo na jednu, rotiranje na desno. Kao što se može videti, ovaj 8-bitni barel rotator realizovan
je sa tri nivoa multipleksera 2-u-1, koji se kontrolišu sa tri selekcione linije, S0, S1 i S0, na sledeći način: kada je
S0=1, prvi nivo obavlja rotiranje za jednu bitsku poziciju; kada je S1=1 drugi nivo obavlja rotiranje za dve, a
kada je S2=1 treći nivo obavlja rotiranje za četiri bitske pozicije.
Za konstrukciju složenijih pomerača/rotatora, koji mogu obavljati veći broj različitih operacija, koristi se u
suštini isti postupak, s tim da je neophodan veći broj multipleksera sa većim brojem ulaza za podatke.

(a)

(b)
Sl. 4-35 8-bitni barel rotator na desno: (a) tabela istinitosti; (b) struktura.

165
4.2 Aritmetička kola
Ovo poglavlje je posvećeno digitalnim kolima koja obavljaju aritmetičke operacije. Biće razmatrana digitalna
kola za sabiranje, oduzimanje i množenje.

4.2.1 Sabirač sa rednim prenosom

Potpuni sabirač (*)
Binarno sabiranje obavlja se na sličan način kao decimalno sabiranje, s tom razlikom što pojedinačne cifre mogu
biti samo 0 ili 1. Sabiranje dva jedno-bitna broja, u opštem slučaju, daje dvo-bitni rezultat, kao što je to
ilustrovano na Sl. 4-36(a). Ako su oba sabirka 0, tada će i njihov zbir biti 0, tj. (00) 2. Ako je jedan sabirak 0, a
drugi 1, zbir je 1, tj. (01) 2. Ako su oba sabirka 1, zbir je 2, tj. (10) 2. Bit manje težine ovog zbira zove se bit sume,
ili sum, tj. s. Bit veće težine zove se bit prenosa ili carry, tj. c. Na Sl. 4-36(b) prikazana je tabela istinitosti koja
definiše operaciju sabiranja dva bita. Lako se može uočiti da je bit sume AND, a bit prenosa XOR funkcija
sabiraka. Na Sl. 4-36(c) je prikazana logička mreža koja realizuje funkcije s i c. Kolo koje obavlja sabiranje dva
bita zove se polu-sabirač (half-adder - HA). Za predstavljanje polu-sabirača koristićemo grafički simbol sa Sl.
4-36(d).

Prenos Suma
x y cx21 sx20
0 0 0 0
0 1 0 1
1 0 0 1
1 1 1 0
(a) (b) (c) (d)
Sl. 4-36 Polu-sabirač: (a) sabiranje dva bita; (b) tabela istinitosti; (c) kolo; (d) grafički simbol.
Polu-sabirač, razmatran kao izolovano kolo, nema neki veći praktični značaj. Od mnogo većeg interesa su kola
koja obavljaju sabiranje više-bitnih brojeva. Prilikom sabiranja više-bitnih brojeva, kao i kod sabiranja više-
cifarskih decimalnih brojeva, potrebno je sabrati svaki par bitova (cifara), ali za svaku bitsku poziciju i dodatno
je potrebno uračunati i prenos koji potiče iz prethodne pozicije, i-1. Na Sl. 4-37 je dat primer sabiranja dva 5-
bitna broja X=(01111)2=(15)10 i Y=(01010) 2=(10)10. Sa pet bita moguće je predstaviti cele brojeve iz opsega 0 do
31. Pošto u konkretnom slučaju važi S=X+Y=(25)10, pet bita biće dovoljna i za predstavljanje zbira. Uočimo da
su na Sl. 4-37, sabirci simbolički označeni sa X=x4x3x2x1x0 i Y=y4y3y2y1y0. Na ovoj slici su takođe prikazani
prenosi koji se generišu u toku sabiranja. Na primer, prilikom sabiranja bitova x0=1 i y0=0 dobija se suma s0=1 i
prenos c0=0; prilikom sabiranja bitova x1=1 i y1=1 dobija se suma s1=0 i prenos c1=1 i tako dalje. Za ci kažemo
da predstavlja izlazni prenos (carry-out) iz pozicije i, odnosno ulazni prenos (carry-in) na poziciju i+1.

Sl. 4-37 Sabiranje višebitnih binarnih brojeva.

Standardni način za projektovanje digitalnih kola polazi od tabele istinitosti. Međutim, ovakav pristup nije
praktičan za projektovanje sabirača koji treba da sabira dva 5-bitna broja. 5-bitni sabirač ima 10 ulaza, pa bi za
opis njegovog ponašanja bilo potrebno formirati tabelu istinitosti od 2 10=1024 vrsta! S toga, bolji pristup je
nezavisno razmatrati sabiranje svakog para bita xi i yi.
Za poziciju i=0 ne postoji ulazni prenos i s toga se sabiranje obavlja na isti način kao na Sl. 4-36(a). Na svakoj
od preostalih poziciju i=1,..., n-1, i-ti bitovi sabiraka, xi i yi, se sabiraju zajedno sa ulaznim prenosom ci. Tako,
sada sabiranje na nivou svake bitske pozicije obuhvata tri bita, xi, yi i ci. Kako najveći zbir tri bita iznosi (11) 2, to
su za njegovo predstavljanje, kao i kod sabiranja dva jednobitna broja, potrebna dva bita: suma si, kao bit manje
težine, i izlazni prenos ci+1, kao bit veće težine. Bit sume si predstavlja i-ti bit konačnog rezultata, dok se bit
prenosa ci+1 pridodaje poziciji i+1 kao ulazni prenos. Funkcije sume i izlaznog prenosa definisane su tabelom
istinitosti sa Sl. 4-38(a). Bit sume si je zbir po modulu 2 bitova xi, yi i ci. Drugim rečima, bit sume je jednak 1 ako
neparan broj sabiraka ima vrednost 1, odnosno, 0 ako paran broj sabiraka ima vrednost 1. Izlazni prenos ci+1

166
jednak je 1 ako je zbir bitova xi, yi i ci veći od 1. Karnoove mape za funkcije si i ci+1 prikazane su na Sl. 4-38(a).
Na osnovu Karnoovih mapa u mogućnosti smo da izvedemo optimalne izraze oblika zbir-proizvoda za funkcije
ci+1 i si:
ci+1 = xiyi + xici + yici
si = xi’yici’+xiyi’ci’+xi’yi’ci+xiyici
Efikasnija realizacija funkcija si i ci+1 može se postići korišćenjem XOR kola. XOR funkcija dve promenljive
definisana je izrazom x1 ⊕ x2 = x1x2’ + x1’x2. Primenom algebarskih manipulacija, izraz za bit sume može se
svesti na formu koja sadrži samo XOR kola, na sledeći način:
si = (xi’yi+xiyi’)ci’+( xi’yi’+xiyi)ci
= (xi’yi+xiyi’)ci’+( xi’yi+xiyi’)’ci
= (xi ⊕ yi)ci’+(xi ⊕ yi)’ci
= (xi ⊕ yi) ⊕ ci
U suštini, si predstavlja XOR funkcija tri promenljive. Napomenimo, da je za XOR funkciju karakterističan
naizmeničan raspored jedinica u Karnoovoj mapi, koji je takav da onemogućava sažimanje minterma (Sl.
4-38(b)).
Izraz za funkciju ci+1, takođe, možemo preurediti na način da koristi XOR funkciju. Pri tome, treba poći od
izraza oblika zbir-minterma:
ci+1 = cixi’yi + cixiyi + cixiyi’ + ci’xiyi
= (ci +ci’)xiyi + ci(xi’yi + cixiyi’)
= xiyi + ci(xi ⊕ yi)

Uočimo da se član (xi ⊕ yi) javlja u izrazima za obe funkcije si i ci+1. Ova činjenica omogućava da se prilikom
realizacije funkcija si i ci+1 za izračunavanje člana (xi ⊕ yi) koristi jedinstveno XOR kolo. Kombinaciona mreža
koja realizuje funkcije si i ci+1 prikazana je na Sl. 4-38(c). Ovo kolo se zove potpuni-sabirač (full-adder - FA).
Grafički simbol potpunog sabirača prikazan je na Sl. 4-38(d).

(a) (b) (c) (d)

Sl. 4-38 Potpuni sabirač: (a) tabela istinitosti; (b) Karnoove mape; (c) kolo; (d) grafički simbol.
Imajući u vidu imena kola, polu- i potpuni-sabirač, mogli bi smo naslutiti da je potpuni-sabirač moguće
konstruisati pomoću dva polu-sabirača. Zaista, ako pažljivo pogledamo kombinacionu mrežu potpunog sabirača
sa Sl. 4-38(c), možemo učiti da se u njoj kriju dva polu-sabirača, uz dodatak jednog OR kola preko kojeg se
formira izlaz ci+1, kao što je to naznačeno na Sl. 4-72(a). Na Sl. 4-72(b) je prikazana blok šema potpunog sabirača
realizovanog pomoću polu-sabirača.

167
 (a) (b)
Sl. 4-39 Realizacija potpunog sabirača na bazi polu-sabirača: (a) identifikacija polu-sabirača; (b) blok dijagram
Sabirač sa rednim prenosom
Kao što dobro znamo, ručno sabiranje se obavlja tako što se krene od cifre najmanje težine i redom sabiraju
parovi cifara, sve do cifre najveće težine. Ako se na poziciji i javi prenos, tada se on dodaje ciframa na poziciji
i+1. Identičan postupak se može primeniti i za konstrukciju digitalnog kola koje će obavljati sabiranje binarnih
brojeva. Binarni sabirač se formira rednim povezivanjem potpunih sabirača, tako što izlazni prenos svakog
potpunog sabirača služi kao ulazni prenos za potpuni sabirač koji zauzima prvu narednu bitsku poziciju veće
težine. Ovakva vrsta sabirača se zove sabirač sa rednim prenosom ili RCA, prema engleskom nazivu Ripple-
Carry Adder. Struktura n-to bitnog sabirača sa rednim prenosom prikazana je na Sl. 4-40(a). Ova struktura se
predstavlja grafičkim simbolom sa Sl. 4-40(b).
U opštem slučaju, zbir dva neoznačena n-to bitna broja ima n+1 bita. Kod binarnog sabirača, ovaj dodatni
(n+1)-vi bit je predstavljen bitom izlaznog prenosa iz pozicije najveće težine, cn, tako da važi:
(cnsn-1…s1s0) = (xn-1…x1x0) + (yn-1…y1y0) + c0.

(a) (b)
Sl. 4-40 n-bitni sabirač sa rednim prenosom: (a) unutrašnja struktura; (b) grafički simbol.
U strukturi sa Sl. 4-40(a), proces izračunavanja počinje onog trenutka kada se na ulaze sabirača postavi novi par
operanada X i Y. Međutim, s obzirom da svako logičko kolo u svakom potpunom sabiraču unosi izvesno
kašnjenje, korektna vrednost izlazne sume S se ne generiše istog tog trenutka, već tek nakon nekog vremena. Da
bi se u stepenu n-1 odredio bit sume sn-1 neophodna je informacija o prenosu iz stepena n-2, tj. cn-1; da bi se u
stepenu n-2 odredio izlazni prenos cn-1 potrebno je imati informaciju o vrednosti cn-2, i td. Neka kašnjenje
potpunog sabirača iznosi ∆t – vreme od postavljanja ulaza xi, yi, ci do generisanja korektnih izlaza ci+1 i si.
Izlazni prenos iz prvog stepena, c1, stiže do drugog stepena posle vremena ∆t nakon što su postavljeni x0 i y0.
Izlazni prenos iz drugog stepena, c2, stiže do ulaza trećeg sa kašnjenjem od 2∆t, i td. Signal cn-1 je važeći posle
kašnjenja od (n-1)∆t, a celokupna izlaza suma posle kašnjenja od n∆t.
Napomenimo da vreme sabiranja zavisi i od vrednosti operanada. Kašnjenje od n∆t odgovara slučaju kada je
jedan operand 11...11, a drugi 00...01. U ovom slučaju, prenos koji se javlja na poziciji 0, prenosi se kroz sve
potpune sabirače postavljajući bitove sume na 0. Za bilo koji drugi par vrednosti operanada, kašnjenje će biti
kraće. Na primer, sabiranje brojeva 00...00 i 00...01 traje samo ∆t. U opštem slučaju, vreme sabiranja određeno
je najvećim brojem uzastopnih pozicija na kojima oba operanda imaju vrednost 1. Međutim, kao se sabirači
koriste za sabiranje operanada proizvoljnih vrednosti, u radu sa sabiračem moramo računati sa maksimalnim
kašnjenjem, n∆t, kako bi smo bili sigurni da ćemo sa izlaza sabirača uvek očitati ispravan rezultat.

168
Znači, brzina rada sabirača sa rednim prenosom određena je vremenom prostiranja signala prenosa kroz potpune
sabirače. Što je broj bita koji se sabira veći, to je brzina rada manja. Ako se radi sa brojevima velike dužine, 32
ili 64 bita, vreme sabiranja može biti neprihvatljivo dugo. Napomenimo da je sabirač sa rednim prenosom samo
jednu od većeg broja različitih konstrukcija sabiračkih kola, koje se razlikuju po složenosti (ukupan broj
gejtova) i brzini rada. Sabirač sa rednim prenosom je najjednostavnija, ali ujedno i najsporija varijanta.
Konstrukcija brzih sabiračkih kola biće tema odeljka X.
Binarni sabirači sa rednim prenosom se lako sprežu kako bi se formirale sabiračke mreže za veći broj bitova. Na
Sl. 4-41 je pokazano kako se sa dva n-bitna sabirača formira 2n-bitni sabirač.

Sl. 4-41 Sprezanje binarnih sabirača.

Pr. 4-7 Projektovati kolo za množenje neozna čenog 8-bitnog broja konstantom 3.
Neka je A=a7a6…a1a0 i P=3A. Za predstavljanje broja P potrebna su 10 bita: P=p9p8…p1p0. Pošto važi
3A=A+A+A, za realizaciju kola možemo upotrebiti binarne sabirače. Na Sl. 4-42(a) je prikazano rešenje koje
koristi dva sabirača. Pri sabirač generiše A+A=2A. Njegov rezultat je predstavljen sa 9 bita: 8 bita sume i izlazni
prenos sa pozicije najveće težine. Drugi sabirač računa 2A+A=3A. Ovaj sabirač je 9-to bitni, iz razlog što jedan
od njegovih operanada, 2A, ima 9 bita. Uočimo da je ulaz x8 drugog sabirača povezan je na konstantu 0, s
obzirom da A ima 8-bita.
Na Sl. 4-42(b) je prikazano efikasnije rešenje, koje koristi samo jedan 9-bitni sabirač. Uočimo da je 8-bitni
sabirač u rešenju sa Sl. 4-42(a) nepotreban, s obzirom da se 2A može dobiti prostim pomeranjem bitova broja A
za jednu poziciju ulevo, što daje: 2A=a7a6…a1a00. Za obavljanje ovog pomeranja nije potrebno nikakvo kolo,
već je dovoljno dopisati jednu nulu sa desne strane broja, što upravo odgovara načinu na koji je operand A
povezan sa Y ulazom sabirača.
Uočimo, sada, da je u rešenju sa Sl. 4-42(b), ulaz najmanje težine sabirača x0 fiksno postavljen na x0=0. To znači
da će bit sume s0 uvek imati vrednost s0=a0. Ovo zapažanje nam omogućava da dodatno pojednostavimo rešenje,
tako što ćemo 9-bitni sabirač zameniti 8-bitnim, kao na Sl. 4-42(c).

(a) (b) (c)

Sl. 4-42 Kolo koje množi 8-bitni neoznačeni broj sa 3: (a) polazno rešenje; (b) poboljšano rešenje; (c) konačno
rešenje.
Predstavljanje označenih brojeva (*)
U decimalnom brojnom sistemu, znak broja se označava simbolom + ili – levo od cifre najveće težine. U
binarnom brojnom sistemu, znak broja se označava dodatnim bitom koji u zapisu broja zauzima krajnju levu
poziciju. Za pozitivne brojeve, ovaj bit jednak je 0, a za negativne 1. Znači, kod označenih brojeva, krajnji levi

169
bit ukazuje na znak broja, dok se preostalih n-1 bita predstavlja maginitudu ili apsolutnu vrednost broja, kao što
je prikazano na Sl. 4-43. Važno je zapaziti poziciju bita najveće težine (MSB). Kod neoznačenih brojeva svih n
bita predstavljaju magnitudu broja – kaže se da su svi bitvi značajni, a MSB se nalazi poziciji n-1. Kod
označenih brojeva, značajni su n-1 bita, MSB bit se nalazi na poziciji n-2, dok bit na poziciji n-1 ukazuje na
znak broja.

(a) (b)
Sl. 4-43 Formati predstavljana celih brojeva: (a) neoznačeni broj; (b) označeni broj.
Za razliku od pozitivnih brojeva koji se predstavljaju uvek na isti način, korišćenjem pozicionog brojnog
sistema, za predstavljanje negativnih brojeva u upotrebi su tri reprezentacije: znak-magnituda, jedinični
komplement i dvojični komplement.
Znak magnituda
Kod decimalnog brojnog sistema, magnituda pozitivnih i negativnih brojeva predstavlja se na isti način, a znak
je taj koji ukazuje da li se radi o pozitivnom ili negativnom broju. Ovakav način predstavljanja označenih
brojeva zove se znak-magnituda, ili znak-apsolutna vrednost. Ista reprezentacija se može primeniti i na binarne
brojeve, a razlika je samo u načinu kodiranja znaka: umesto + i – koristimo 0 i 1, respektivno. Na primer, +5 =
0101, a -5=1101.
Brojni sistem koji koristi reprezentaciju znak-magnituda sadrži isti broj pozitivnih i negativnih brojeva, a nula
ima dvojnu reprezentaciju. Najveći pozitivni broj koji se u ovom sistemu može iskazati sa n bita je +(2n-1) =
011…11; najmanji negativni broj je –(2 n-1) = 111…11, dok se nula predstavlja sa 000…00 ili 100…00.
Jedinični komplement
U formatu jediničnog komplementa, n-bitna reprezentacija negativnog broja K se dobija oduzimanjem njemu
odgovarajućeg pozitivnog broja P od 2n-1, tj. K=(2n-1)-P. Na primer, ako je n=4, tada je K = (24-1)-P = (15)10-P
= (1111)2-P. Ako +5 konvertujemo u negativan broj, dobićemo -5 = 1111 – 0101 = 1010. Slično, +3=0011, a -3
= 1111 – 0011 = 1100. Jasno se uočava da se jedinični komplement datog binarnog broja dobija
komplementiranjem svakog pojedinačnog bita, uključujući i bit znaka.
Najveći pozitivni broj koji se može predstaviti u jediničnom komplementu sa n bita je 011…11 = 2 n-1, najmanji
negativni broj je 100…00 = -(011…11) 2 = -(2n-1), dok nula ima dvojnu reprezentaciju: 000…00 ili 111…11.
Jedinični komplement se lako izvodi, ali ispoljava izvesne nedostatke kada se koristi u aritmetičkim
operacijama.
Dvojični komplement
U formatu dvojičnog komplementa, n-bitna reprezentacija negativnog broja K se dobija oduzimanjem njemu
odgovarajućeg pozitivnog broja P od 2n, tj. K = 2n - P. Na primer, ako je n = 4, tada je K = 24 - P = (16)10 - P =
(10000)2 - P. Da bi smo odredili dvojični komplement broja 5, treba obaviti oduzimanje 10000 – 0101, što daje -
5 = 1011. Ili -3 = 10000 – 0011 = 1101. Nalaženje dvoji čnog komplementa na ovaj način je naporno jer zahteva
da se obavi operacija oduzimanja. Međutim, ako je K1 jedinični, a K2 dvojični komplement broja P tada važi:
K1 = (2n-1) – P
K2 = 2n – P
Odakle sledi K2 = K1 + 1. Dakle, jednostavniji način za nalaženje dvojičnog komplementa sastoji se u tome da se
na jedinični komplement doda jedinica. Ovo je upravo način na koji se u digitalnoj tehnici dobija dvojični
komplement.
Za ručno izvođenje postoji još jedan lakši način za nalaženje dvojičnog komplementa. Neka je dat broj B=bn-1bn-
2 ... b1b0. Dvojični komplement broja B, K=kn-1kn-2 ... k1k0, može se odrediti na sledeći način: krećemo od bita
najmanje težine ulevo i prepisujemo bitove broja B sve dok ne naiđemo na prvu jedinicu, zatim prepisujemo i
ovu jedinicu, a preostale bitove komplementiramo. Na primer, ako je B=0110, tada prepisujemo k0=b0=0 i
k1=b1=1, i komplementiramo preostale bitove, k2=b2`=0 i k3=b3`=1. Znači, K=1010. Ili, na složenijem primeru,
ako je B=101101000, tada je K= 010011000.

170
U brojnom sistemu koji koristi dvojični komplement, nula se tretira kao pozitivan broj, i predstavlja na
jedinstveni način: 000...00. Iz tog razloga broj pozitivnih brojeva je za jedan manji od broja negativnih. Naime,
najveći pozitivni broj koji se može predstaviti sa n bita u formatu dvojičnog komplementa je 011...11 = 2 n-1,
dok je najmanji negativan broj 10000000 = -(011...11 + 1) 2 = -(100...00)2 = -2n.
Sabiranje i oduzimanje označenih brojeva (*)
U prethodnom odeljku opisana su tri standardna načina za binarnu reprezentaciju brojeva. Međutim, nisu svi ovi
načini podjednako pogodni za primenu u digitalnim sistemima. Osnovni kriterijum za izbor reprezentacije
brojeva je lakoća sa kojom se nad brojevima u konkretnoj reprezentaciji obavljaju osnovne računske operacije,
kao što su sabiranje i oduzimanje. U ovom odeljku, na konkretnim primerima, ukazaćemo na dobre i loše strane
svake od tri reprezentacije.
Sabiranje pozitivnih brojeva se obavlja na isti način u sve tri reprezentacije, tj. na isti način kao sabiranje
neoznačenih brojeva. Međutim, kada se u računicu uvedu i negativni brojevi, između različitih reprezentacija
ispoljavaju se značajne razlike.
Sabiranje brojeva u formatu znak-magnituda
Ako oba sabirka imaju isti znak, sabiranje brojeva u formatu znak-magnituda je jednostavno. Magnitude se
saberu, a zbiru se dodeli znak sabiraka. Međutim, ako su sabirci različitog znaka, sabiranje postaje složenije. U
tom slučaju, operacija sabiranja se svodi na oduzimanje manjeg broja od većeg. To znači da je za obavljanje
operacije sabiranja neophodno digitalno kolo koje će ispitati znake sabiraka, uporediti njihove magnitude i biti u
mogućnosti da u zavisnosti od ishoda poređenja obavi sabiranje ili oduzimanje. Složenost takvog kola je
značajno veća od odgovarajućih kola koja barataju brojevima u komplementarnim reprezentacijama. Iz tog
razloga reprezentacija znak-magnituda se ne koristi kod digitalnih sistema.
Sabiranje brojeva u jediničnom komplementu
Očigledna prednost jediničnog u odnosu na dvojični komplement je u tome što se negativni broj lako određuje
prostim komplementiranjem svih bitova odgovarajućeg pozitivnog broja. Na Sl. 4-44 je prikazano šta se dešava
prilikom sabiranja dva broja predstavljena u jediničnom komplementu. Navedena su četiri slučaja, pri čemu
svaki slučaj odgovara jednoj konkretnoj kombinaciji znakova sabiraka. Kao što se može videti na gornjoj
polovini slike, izračunavanja 5 + 2 = 7 i (-5) + 2 = (-3) su trivijalna; prostim binarnim sabiranjem operanada,
uključujući pri tome i bit znaka, dobija se ispravan rezultat. Međutim, to nije slučaj kod preostala dva primera.
Izračunavanje 5 + (-2) = 3 daje bit vektor 10010. Prvo, rezultat ima pet, a ne četiri bita. Dodatni peti bit je
posledica izlaznog prenosa iz pozicije znaka. Drugo, preostala četiri bita predstavljaju broj 2, a ne 3, što je
očigledno pogrešan rezultat. Međutim, ako uzmemo izlazni prenos sa pozicije znaka i dodamo ga rezultatu na
poziciji najmanje težine, novi rezultat biće ispravna suma, tj. 3. Slična situacija se javlja kod sabiranja (-5) + (-2)
= (-7). Nakon inicijalnog sabiranja, rezultat je pogrešan, zato što su četiri bita sume 0111, što predstavlja +7, a
ne -7. Ali, ponovo, tu je izlazni prenos iz pozicije bita znaka koji može biti iskorišćen za korekciju rezultata, na
način kako je prikazano na Sl. 4-44.

Sl. 4-44 Primeri sabiranja u jediničnom komplementu.

Zaključak koji se nameće na osnovu razmatranih primera je da sabiranje brojeva u jediničnom komplementu u
nekim slučajevima jednostavno, a u nekima nije. Ako je potrebna korekcija, neophodno je dodatno vreme kako
bi se obavilo sabiranje inicijalnog rezultata i izlaznog prenosa. Tako, ukupno vreme sabiranja može biti i
dvostruko duže od vremena sabiranja dva neoznačena broja.
Sabiranje brojeva u dvojičnom komplementu
Razmotrimo istu kombinaciju brojeva koju smo koristili u primerima za jedinični komplement. Na Sl. 4-45 je
ilustrovano kako se obavlja sabiranje brojeva predstavljenih u dvojičnom komplementu. Sabiranja 5 + 2 = 7 i (-
5) + 2 = (-3) su trivijalna. Izračunavanje 5 + (-2) = 3 daje ispravna četiri bita rezultata, 0011. Pri tome, izlazni
prenos iz pozicije bita znaka, koji u ovom slučaju postoji, možemo, prosto, ignorisati. Četvrti slučaj je (-5) + (-2)
= (-7). Ponovo, četiri bita rezultata, 1001, odgovaraju ispravnoj sumi (-7). I u ovom slučaju, izlazni prenos iz
pozicije bita znaka se može ignorisati.

171
 Sl. 4-45 Primeri sabiranja u dvojičnom komplementu.
Prethodni primeri pokazuju da je sabiranje brojeva u dvojičnom komplementu veoma jednostavno. Brojevi se
sabiranju zajedno sa bitom znaka, a rezultat je uvek ispravan. Eventualni izlazni prenos iz pozicije bita znaka se
jednostavno ignoriše. Znači, procedura sabiranja je uvek ista, nezavisno od znaka operanada, i može se obaviti
binarnim sabiračem, kao što je onaj sa Sl. 4-40. Zbog svega toga, reprezentacija brojeva u dvojičnom
komplementu je veoma pogodna za primenu u digitalnim sistemima.
Oduzimanje u dvojičnom komplementu
Najlakši način da se obavi oduzimanje je da se najpre umanjiocu promeni znak, a da se onda dobijena vrednost
sabere sa umanjenikom. Promeni znaka umanjioca odgovara nalaženje njegovog dvojičnog komplementa. Na Sl.
4-46 je na nekoliko karakterističnih primera ilustrovan ovaj postupak. Operacija 5 – (+2) = 3 uključuje nalaženje
dvojičnog komplementa broja +2, što daje 1110. Kada se ovaj broj sabere sa 0101 = (+5), dobija se rezultat
0011 = (+3) uz generisanje prenosa iz pozicije bita znaka. Ako ignorišemo prenos, rezultat je tačan. Slična
situacija postoji za (-5) + (+2) = (-7). U preostala dva slučaja, izlazni prenos ne postoji i rezultat je tačan.

Sl. 4-46 Primeri oduzimanja u dvojičnom komplementu.

Sl. 4-47 predstavlja jednu vizuelnu ilustraciju procesa sabiranja i oduzimanja 4-bitnih brojeva u dvojičnom
komplementu. Slika prikazuje brojčanik po čijem obodu su raspoređene svih 16 4-bitnih kombinacija. Ako bi
smo ove binarne kombinacije interpretirali kao neoznačene cele brojeve, tada bi one predstavljale brojeve od 0
do 15. Ako ih tretiramo kao brojeve u dvojičnom komplementu, tada njima odgovara opseg celih označenih
brojeva od -8 do 7, kao što je naznačeno po unutrašnjem obodu brojčanika. Kazaljku brojčanika možemo
podesiti na bilo koji broj, a zatim na taj broj možemo dodati broj +n tako što ćemo odbrojati n puta unapred, tj.
okrenuti kazaljku za n koraka u smeru kretanja kazaljke na časovniku. Jasno je da okretanjem kazaljke za n
koraka u suprotnom smeru, od polaznog broja oduzimamo broj n. Naravno, rezultat ovog postupka će biti tačan
samo ako je n dovoljno malo da kazaljka prilikom okretanje ne pređe granicu između +7 i -8.

Sl. 4-47 Grafička reprezentacija 4-bitnih brojeva u dvojičnom komplementu.

Interesantno je uočiti još i sledeće. Krajnja pozicija kazaljke biće ista bilo da se ona okrene za n koraka u
jednom smeru ili za 16-n koraka u suprotnom smeru. Dakle, umesto da radimo sa brojčanikom čija kazaljka
može da se okreće u oba smera, možemo koristiti brojčanik sa kazaljkom koja se okreće samo u smeru kretanja
kazaljke na časovniku (odgovara sabiranju), a da u slučajevima kada želimo da obavimo oduzimanje, prethodno
preračunamo broj koraka po formuli 16-n. Uočimo da 16-n predstavlja upravo dvojični komplement broja n, a

172
da ova grafička interpretacija potvrđuje naše ranije tvrđenje da se oduzimanje brojeva u dvojičnom
komplementu može obaviti sabiranjem umanjenika i dvojičnog komplementa umanjioca.
Sabirač/oduzimač
Jedina razlika između sabiranja i oduzimanja je u tome što je kod oduzimanja potrebno koristiti dvojični
komplement jednog od operanada. Neka su X i Y dva broja, koja treba sabrati ili oduzeti i neka je Y broj koji
prilikom oduzimanja služi kao umanjilac, tj. neka je S=X±Y. Kao što znamo, dvojični komplement operanda Y
se može dobiti dodavanjem jedinice na njegov jedinični komplement. Dodavanje jedinice na poziciju najmanje
težine može se postići postavljanjem bita ulaznog prenosa c0 na 1. Jedinični komplement datog broja se dobija
komplementiranjem svih njegovih bitova. Komplementiranje broja se može obaviti pomoću NOT gejtova.
Međutim, za ovu namenu biće nam potrebno fleksibilnije kolo, kako bi smo mogli da u zavisnosti od željene
operacije koristimo pravu ili komplementiranu vrednost operanda Y. Takvo kolo je XOR gejt. Interesantna
osobina XOR kola je da jedan od njegovih ulaza možemo koristiti kao upravljačku promenljivu pomoću koje
ćemo birati da li će se na izlazu kola generisati prava ili komplementarna vrednost drugog ulaza. Ovo je jasno na
osnovu definicije XOR operacije:
z=x ⊗ y = x’y + xy’
Neka je x upravljački ulaz. Za x=0, izlaz će biti identičan ulazu y, tj. z= 0’·y + 0·y’=1·y+0· y’= y. Ali, ako je x=1,
izlaz će biti jednak komplementu ulaza y, tj. z= 1’·y + 1·y’=0·y+1· y’= y’. Drugim rečima, za x=1 XOR gejt
funkcioniše kao invertor, dok za x=0, jednostavno prenosi vrednost sa ulaza y na izlaz.
Kolo za sabiranje/oduzimanje možemo konstruisati na sledeći način. Pretpostavimo da postoji upravljački signal
koji određuje da li treba obaviti sabiranje ili oduzimanje. Neka se ovaj signal zove Add / Sub (prema engleskim
nazivima za sabiranje i oduzimanje: addition i subtraction). Takođe, neka vrednost 0 ovog signala bira
sabiranje, a 1 oduzimanje. Crta iznad Add upravo ukazuje na ovu činjenicu. Napomenimo da je ovo često
korišćena konvencija, tj. da crta iznad imena upravljačkog signala ukazuje da se akcija specificirana tim imenom
obavlja kada signal ima vrednost 0. Neka je svaki bit operanda Y povezan na jedan ulaz jednog od XOR gejtova,
a da su drugi ulazi svih XOR gejtova povezani na signal Add / Sub . Izlazi XOR gejtova predstavljaju Y, ako je
Add / Sub =0, odnosno Y’, ako je Add / Sub =1. Tako dolazimo do kola sa Sl. 4-48. Glavni deo ovog kola je n-to
bitni sabirač, koji može biti realizovan korišćenjem strukture sabirača sa rednim prenosom sa Sl. 4-40(a).
Uočimo da je upravljački ulaz Add / Sub povezan i na ulaz c0 sabirača. Na ovaj način, biće c0=1 kada se obavlja
oduzimanje, što dodaje jedinicu koja je neophodna da bi se formirao dvojični komplement operanda Y. Kada se
obavlja operacija sabiranja, c0 će biti 0 i neće uticati na rezultat.

Sl. 4-48 Sabirač/oduzimač.

Kombinovano kolo za sabiranje i oduzimanje je dobar primer jednog važnog koncepta koji se primenjuje u
projektovanju digitalnih sistema. Korisno je projektovati kola koja će biti što je moguće više fleksibilna i na taj
način iskoristiti zajedničke delove kola za što više različitih zadataka. Ovakvim pristupom minimizuje se broj
gejtova potrebnih za realizaciju sistema. Takođe, značajno se smanjuje složenost povezivanja komponenti
sistema.
Aritmetičko prekoračenje
Ako operacija sabiranja ili oduzimanja generiše rezultat koji premašuje opseg brojnog sistema kažemo da je
došlo do aritmetičkog prekoračenja. Drugim rečima, aritmetičko prekoračenje se javlja u situacijama kada je
rezultat pozitivan i suviše veliki ili negativan i suviše mali tako da ga nije moguće predstaviti raspoloživim
značajnim bitovima. Ako za predstavljanje označenih brojeva koristimo n bita, tada rezultat mora biti u opsegu
od -2n-1 do (2n-1-1). Kada su sabirci različitog znaka, do aritmetičkog prekoračenja nikada neće doći, zato što će
rezultat uvek biti manji od pozitivnog i veći od negativnog sabirka. Međutim, ako su sabirci istog znaka, može

173
se desiti da rezultat bude veći od 2n-1-1, ako su oba sabirka pozitivna, odnosno, manji od -2 n-1, ako su sabirci
negativni. Da bi se osigurao ispravan rad aritmetičkog kola, neophodno je biti u mogućnosti detektovati pojavu
aritmetičkog prekoračenja.

Sl. 4-49 Primeri za određivanje uslova prekoračenja.

Na Sl. 4-49 su prikazana četiri slučaja sabiranja brojeva u dvojičnom komplementu čije su magnitude 7 i 2. S
obzirom da u ovom primeru za predstavljanje brojeva koristimo 4 bita, broj značajnih bitova je tri, b0-2. Kao što
se vidi sa Sl. 4-49, kada su sabirci različitog znaka rezultat je tačan, tj. nema prekoračenja. Međutim, ako oba
broja imaju isti znak, magnituda rezultata je 9 i ne može biti predstavljena sa samo tri značajna bita, tj. dolazi do
prekoračenja. Ključ za detekciju pojave prekoračenja su dva prenosa: c3 – izlazni prenos iz pozicije najveće
težine i c4 izlazni prenos iz pozicije znaka. Na osnovu primera sa Sl. 4-49, može se zaključiti da se prekoračenje
javlja kada ova dva bita imaju različite vrednosti, a da je rezultat ispravan ako su njihove vrednosti iste. Izražen
u obliku logičkog izraza, uslov prekoračenja glasi:
Prekoračenje = c3c4’ + c3’c4
= c3 ⊗ c4
Ili, u opštem slučaju, za n bitne brojeve, imamo:
Prekoračenje = cn-1 ⊗ cn
Na Sl. 4-50(a) je prikazana struktura sabirača/oduzimača sa kolom za detekciju prekoračenja koje ispituje izlazne
prenose.
Drugi način za detekciju aritmetičkog prekoračenja upoređuje bitove znaka sabiraka i rezultata. Neka su X=xn-
1xn-2…x0 i Y=yn-1yn-2…y0 binarni brojevi u dvojičnom komplementu, i S=sn-1sn-2…s0 rezultat njihovog sabiranja.
Bitovi xn-1, yn-1 i sn-1 su bitovi znaka ova tri broja. Aritmetičko prekoračenje postoji ako smo sabiranjem
pozitivnih brojeva dobili negativan rezultat ili ako smo sabiranjem negativnih brojeva dobili pozitivan rezultat,
tj.:
Prekoračenje = xn-1yn-1sn-1’ + xn-1’yn-1’sn-1
Isto tvrđenje, kazano drugim rečima, glasi: do prekoračenja je došlo ako se rezultat razlikuje po znaku od oba
sabirka, tj.:
Prekoračenje = (xn-1 ⊗ sn-1) (yn-1 ⊗ sn-1)
Kolo sabirača/oduzimača kod koga je detekcija prekoračenja realizovana shodno gornjem izrazu prikazano je na
Sl. 4-50(b). Uočimo da je prvi način za detekciju prekoračenja, Sl. 4-50(a), jednostavniji, jer zahteva sam još
jedno dodatno XOR kolo, za razliku od drugog kod koga je potrebno ugraditi dodatna tri gejta. Međutim, prvo
rešenje podrazumeva da je signal izlaznog prenosa cn-1 dostupan, što ne mora biti slučaj ako raspolažemo
sabiračem koji se realizovan kao monolitna komponenta. U tom smislu, drugo rešenja je pogodnije jer koristi
samo spoljašnje signale sabirača/oduzimača.

174
 yn-1 yn-2 y1 y0

Add/Sub

xn-1 xn-2 x1 x0

cn-1 cn-2 c2 c1
Prekoračenje cn
FA FA
... FA FA
c0

sn-1 sn-2 s1 s0
Pozicija MSB LSB
znaka pozicija pozicija

(a)

(b)
Sl. 4-50 Dva načina za detekciju aritmetičkog prekoračenja: (a) na osnovu izlaznih prenosa; (b) na osnovu znaka
sabiraka i rezultata.
Napomenimo da su dva pravila za detekciju aritmetičkog prekoračenja, u suštini, ekvivalentna. Potpuni sabirač
na poziciji bita znaka obavlja sledeće izračunavanje: (cn, sn-1) = (xn-1 + yn-1 + cn-1). Ako su oba sabirka pozitivna,
xn-1=yn-1=0, izlazni prenos iz pozicije znaka biće cn=0, bez obzira na vrednost cn-1. Za cn-1=0, bit znaka rezultata
biće sn-1=0, što ukazuje da je rezultat pozitivan i da zbog toga prekoračenja nema. Međutim, ako je cn-1=1, bit
znaka dobija vrednost sn-1=1, što ukazuje na negativan rezultat, tj. na pojavu prekoračenja. Slično, ako su oba
sabirka negativna, xn-1=yn-1=1, izlazni prenos iz pozicije znaka biće cn=1, bez obzira na vrednost cn-1. Međutim,
za cn-1=0, bit znaka dobija vrednost sn-1=0, što ukazuje na pozitivan rezultat, odnosno na prekoračenje. Dakle, u
oba slučaja važi da prekoračenje postoji ako je cn≠cn-1.
Performanse sabirača sa rednim prenosom
Sabiranje i oduzimanje brojeva su bazične operacije koje se često obavljaju u računarskim sistemima. Brzina
izvršenja ovih operacija ima veliki uticaj na ukupne performanse računara. Iz tog razloga, razmotrimo brzinu
rada kola za sabiranje i oduzimanje. Brzina rada ovog kola određena je kašnjenjem od trenutka kada se na ulaze
kola postave operandi X i Y do trenutka kada se na izlazu kola generišu korektne vrednosti svih bitova sume S i
izlaznog prenosa cn. Najveći deo ovog kašnjenja potiče od n-bitnog sabirača. Pretpostavimo da je sabirač
realizovan korišćenjem strukture sa rednim prenosom (Sl. 4-40), kod koje su potpuni sabirači realizovani kao na
Sl. 4-38. Kao što se lako može zaključiti sa Sl. 4-38, kod ove realizacije potpunog sabirača, kašnjenje izlaznog
prenosa, ∆t, jednako je kašnjenju kroz dva gejta, tj. ∆t=2tg, gde je tg kašnjenje kroz jedan gejt. Ukupno kašnjenje
sabirača sa rednim prenosom iznosi n∆t, što je ekvivalentno kašnjenju kroz 2n gejta. Pored kašnjenja koje je
posledica prostiranja signala prenosa kroz sabirač, na ukupno kašnjenje kola za sabiranje i oduzimanje dodatno
utiču i ulazna XOR kola. Ako pretpostavimo da je kašnjenje kroz XOR kolo jednako tg, dolazimo do zaključka
da kolo za sabiranje i oduzimanje unosi kašnjenje ekvivalentno kašnjenju kroz 2n+1 gejt. Za veće n, npr. n=32
ili n=64, iznos kašnjenja može biti toliko veliki da značajno degradira performanse celog sistema. Zato je bitno
ispitati mogućnost alternativne realizacije binarnog sabirača, koja će se odlikovati većom brzinom rada.
Brzina rada bilo kog digitalnog kola ograničena je najvećim kašnjenje duž neke od putanja kroz kolo. U slučaju
kola sa Sl. 4-48, najduže kašnjenje se javlja duž putanje koja kreće od ulaza yi, prolazi kroz XOR gejt, a zatim
kroz kola za generisanje prenosa svih potpunih sabirača. Najduže kašnjenje se zove kašnjenje kritičnog puta, a
putanja koja uslovljava ovo kašnjenje kritična putanja.

175
4.2.2 Brzi sabirači
Sabirač sa ubrzanim prenosom
Kašnjenje uzrokovano propagacijom signala prenosa kroz sabirač sa rednim prenosom može se smanjiti ako
promenimo strukturu sabirača na način da svaki stepen i, umesto da čeka da od stepena i-1 dobije ulazni prenos
ci, pre nego što generiše svoj bit sume si, samostalno pokuša da odredi da li će vrednost ulaznog prenosa biti 0 ili
1. Da bi ukupne performanse sabirača bile poboljšanje, potrebo je da korektna procena vrednosti ulaznog
prenosa bude obavljena za što je moguće kraće vreme.
Pođimo od izraza za funkciju izlaznog prenosa i-tog stepena sabirača:
ci+1 = xiyi + xici + yici
Ako ovaj izraz rastavimo na sledeći način:
ci+1 = xiyi + (xi + yi)ci
funkciju ci+1 možemo napisati u obliku:
ci+1 = gi + pici (4.1)
gde je:
gi = xiyi
p i = xi + yi
Jednačinu (4.1) možemo protumačiti na sledeći način. Kada je gi=1, tj. xi=yi=1, stepen i generiše izlazni prenos,
ci+1=1, bez obzira na vrednost ulaznog prenosa ci. Zato se g zove funkcija generisanog prenosa. Funkcija pi
jednaka je 1 ako je barem jedan od ulaza xi i yi jednak 1. U ovom slučaju, ci=1 uslovljava generisanje izlaznog
prenosa ci+1, tj. efekat je kao da se ulazni prenos preneo na izlaz. Zbog toga se funkcija p zove funkcija
propagiranog prenosa. Dakle, stepen i generiše prenos ako su oba njegova sabirka jednaka 1, a propagira prenos
ako je jedan od sabiraka jednak 1.
Jednačina (5.3) nam omogućava da rekurzivnom zamenom člana ci eliminišemo propagaciju prenosa kroz
sabirač. Naime, kao što je ci+1 = gi + pici, tako je i ci = gi-1 + pi-1ci-1. Dakle,
ci+1 = gi + pi(gi-1 + pi-1ci-1)
= gi + pigi-1 + pipi-1ci-1
Nastavljajući sa smenama, sve do c0, dolazimo do izraza za ci+1 sledećeg oblika:
ci+1 = gi + pigi-1 + pipi-1gi-2 + ... + pipi-1... p2p1g0 + pipi-1...p1p0c0 (4.2)
Dobijeni izraz se može realizovati u vidu tronivovske AND-OR mreže. U prvom nivou računaju se funkcije
generisanog i propagiranog prenosa, gi i pi. U drugom nivou, izračunavaju se produktni članovi, koji se, potom,
sumiraju u trećem nivou. S obzirom na mali broj nivoa, ci+1 se izračunava veoma brzo. Šta više, kašnjenje u
izračunavanju izlaznih prenosa ci+1 je fiksno i ne zavisi od i, što znači da ni ukupno kašnjenje sabirača ne zavisi
od obima operanada, tj. n. Binarni sabirač zasnovan na izrazu (4.2) zove se sabirač sa ubrzanim prenosom ili
CLA sabirač, prema engleskom nazivu Carry-Lookahead Adder.
Da bi smo bolje razumeli fizičko značenje izraza (4.2) uporedićemo konstrukcije sabirača sa ubrzanim i sabirača
sa rednim prenosom. U tom cilju, analizaćemo detaljnu strukturu dva stepena najmanje težine oba sabirača.
Sl. 4-51 prikazuje prva dva stepena sabirača sa rednim prenosom kod koga su funkcije izlaznog prenosa
realizovane shodno izrazu (4.1). Mala brzina rada sabirača sa rednim prenosom posledica je dugačke putanje
duž koje se prostire signal prenosa. Kao što je posebno naznačeno na Sl. 4-51, kritični put polazi od ulaza x0 i y0 i
proteže se do izlaza c2, prolazeći kroz 5 gejta: 3 gejta u stepenu 0 i 2 u stepenu 1. Za sabirač sa n stepena,
kritični put se nastavlja dalje sve do izlaza cn, prolazeći kroz svaki sledeći stepen na isti način kao kroz stepen 1.
Dakle, kašnjenje kritičnog puta sabirača sa rednim prenosom iznosi 2n+1.

176
 Sl. 4-51 Detaljna struktura sabirača sa rednim prenosom.
Na Sl. 4-52 je prikazana detaljna struktura prva dva stepena sabirača sa ubrzanim prenosom. Sada su funkcije
izlaznog prenosa realizovane shodno izrazu (4.2), tj.:
c1 = g0 + p0c0
c2 = g1 + p1g0 + p1p0c0
Kao što se može uočiti sa Sl. 4-52, u svakom stepenu sabirača sa rednim prenosom generišu se funkcije
generisanog i propagiranog prenosa. Lokalno, ove funkcije se koriste, zajedno sa funkcijama g i p svih
prethodnih stepena, za generisanje izlaznog prenosa tog stepene, ali i prosleđuju dalje ka svim narednim
stepenima gde se koriste za određivanje njihovih izlaznih prenosa. Kritični put za određivanje izlaznog prenosa
c2 naznačen je na Sl. 4-52. U ovom kolu, c2 se određuje jednako brzo kao i c1, tj. nakon vremena koje je jednako
kašnjenju kroz tri gejta, tj. 3tg. Čak iako ovu strukturu proširimo na n bita, konačni izlazni prenos cn generisaće
se sa kašnjenjem od 3tg. Naravno, što je i veće, tj. kako se krećemo ka pozicijama veće težine, to izrazi za
funkcije ci+1 postaju sve složeniji, što zahteva sve veći broj gejetova za njihovu realizaciju. Međutim, bez obzira
na složenost, broj nivoa logike za izračunavanje ci+1 ostaje isti, tj. tri.
Ukupno kašnjenje n-to bitnog sabirača sa ubrzanim prenosom isnosi 4tg. Vrednosti svih funkcija gi i pi određuju
se nakon vremena tg. Dodatno kašnjenje od 2tg potrebno je za određivanje svih signala prenosa. Konačno, treba
sačekati još dodatno vreme tg da bi se na izlazima svih XOR kola generisali bitovi sume.

Sl. 4-52 Prva dva stepena sabirača sa ubrzanim prenosom.

177
Izraz (4.2) se može realizovati pomoću brze, tri-nivolske AND-OR mreže. Međutim, za veliko i broj ulaza u
pojedine gejtove, koji su potrebni za realizaciju ove funkcije, postaje isuviše veliki. Kao što je poznato iz
poglavlja X, kod većine implementacionih tehnologija broj ulaza u gejtove, tj. fan-in faktor, ograničen je na
relativno mali broj. Zato je neophodno prilikom projektovanja sabirača sa ubrzanim prenosom uzeti u obzir i
ovu činjenicu. Da bi smo bliže ukazali na ovaj problem, razmotrimo izraze za prvih osam izlaznih prenosa:
c1 = g0 + p0c0
c2 = g1 + p1g0 + p1p0c0
...
c8 = g7 + p7g6 + p7p6g5 + p7p6p5g4 + p7p6p5p4g3 + p7p6p5p4p3g2 + p7p6p5p4p3p2g1
+ p7p6p5p4p3p2p1g0 + p7p6p5p4p3p2p1p0c0
Pretpostavimo da je fan-in raspoloživih gejtova ograničen na četiri ulaza. Očigledno, pomoću takvih gejtova nije
moguće realizovati sve prethodne izraze u obliku tri-nivolske AND-OR mreže. Nejveći problem je c8, gde se
čak zahteva jedno AND kolo sa 9 ulaza. Takođi, i za sumiranje produktnih članova potrebno je OR kolo sa 9
ulaza. Potreba za logičkim kolima sa velikim brojem ulaza potiče od produktnih i zbirnih članova sa velikim
brojem literala. Međutim, pravilnom faktorizacijom, moguće je smanjiti maksimalnu veličinu članova u
logičkom izrazu. Jedno moguće rešenje je sledeće:
c8 = (g7 + p7g6 + p7p6g5 + p7p6p5g4)+ [(p7p6p5p4)(g3 + p3g2 + p3p2g1 +p3p2p1g0)]
+ (p7p6p5p4)(p3p2p1p0)c0
Za realizaciju ovog izraza potrebna su 11 AND i tri OR gejta. Međutim, sada propagaciono kašnjenje iznosi ne
više 3tg već 5tg: jedno tg za određivanje gi i pi; 2tg za sumiranje produktnih članova u zagradama; jedno tg za
produktni član u velikim zagradama i još jedno tg za konačno sumiranje. Dakle, ograničenje u pogledu
maksimalnog broja ulaza u gejtove manifestuje se u povećanju broja nivoa AND-OR mreže, što neminovno
povećava propagaciono kašnjenje. Ovaj zaključak nije ograničen samo na konkretno kolo, već veži generalno za
bilo koju logičku mrežu.
Hijerarhijski sabirač sa ubrzanim prenosom
Projektovanje digitalnih sistema po pravilu zahteva nalaženje optimalnog kompromisa između brzine rada
sistema i njegove cene (složenosti). Težnja da se što više poveća brzina rada, obično ima za posledicu povećanje
cene sistema. Isto tako, složenost sistema obično nije moguće smanjiti, a da to nema za posledicu smanjenje
brzine rada. U kontekstu binarnog sabirača, struktura sa rednim prenosom predstavlja najjednostavnije, ali u isto
vreme i najsporije rešenje. Sa druge strane, sabirač sa ubrzanim prenosom predstavlja najbrže rešenje, ali zato za
neke primene, njegova složenost može biti isuviše velika. Međutim, mogu postojati primene kada ni jedna od
ove dve varijante sabirača ne zadovoljava postavljene zahteve – sabirač sa rednim prenosom može biti previše
spor, a sabirač sa ubrzanim prenosom previše složen. Zato je bitno raspolagati nekom fleksibilnom sabiračkom
strukturom koja će omogućiti lako nalaženje kompromisa između složenosti i brzine rada. Jedna takva struktura
je hijerarhijski sabirač sa ubrzanim prenosom.
Pretpostavimo da želimo da projektujemo 32-sabirač. Sabirač možemo podeliti na četiri 8-bitna bloka, tako da
bitovi b0-7 pripadaju bloku 0, bitovi b8-15 bloku 1, bitovi b16-23 bloku 2 i bitovi b24-32 bloku 3. Svaki blok možemo
realizovati kao 8-bitni sabirač sa ubrzanim prenosom. Signali izlaznog prenosa iz ovih blokova su c8, c16, c24 i
c32. Postoje dva načina kako 8-bitne blokove možemo povezati u jedinstveni 32-bitni sabirač. Jedno rešenje je da
blokove povežemo na isti način kao što bi smo povezali četiri stepena sabirača sa rednim prenosom (Sl. 4-53).
Znači, kod ovog rešenja unutar blokova koristimo tehniku ubrzanog prenosa, dok se između blokva prenos
prenosi redno.

Sl. 4-53 Hijerarhijski CLA sabirač sa rednim prenosom između blokova.

Brže kolo se može realizovati ako se i za generisanje prenosa između blokova, umesto rednog prenosa, koristi
tehnika ubrzanog prenosa. Na Sl. 4-66 je prikazana struktura hijerarhijskog sabirača sa ubrzanim prenosom kod
koga je iskorišćena ova tehnika. Svaki blok na gornjem delu Sl. 4-66 predstavlja jedan 8-bitni sabirač sa
ubrzanim prenosom. Unutar bloka, u svakom njegovom unutrašnjem stepenu generišu se signali generisanog i

178
propagiranog prenosa, gi i pi. Međutim, umesto da svaki blok generiše signal izlaznog prenosa iz svoje pozicije
naveće težine, kao u rešenju sa Sl. 4-53, sada svaki blok generiše signale generisanog i propagiranog prenosa za
celokupan blok. Neka su ovi signali označeni sa Gj i Pj. Signali Gj i Pj se koriste kao ulazi u kola za ubrzanje
prenosa drugog nivoa, prikazana u doljem delu Sl. 4-66, koja određuju prenose između blokova. Izraze za
funkcije Gj i Pj možemo odrediti na osnovu poznatog izraza za c8:
c8 = g7 + p7g6 + p7p6g5 + p7p6p5g4 + p7p6p5p4g3 + p7p6p5p4p3g2 + p7p6p5p4p3p2g1
+ p7p6p5p4p3p2p1g0 + p7p6p5p4p3p2p1p0c0
Poslednji član u ovom izrazu kazuje da ako su sve interne funkcije propagiranog prenosa, pi, i=1,..,7, jednake 1,
tada se signal ulaznog prenosa, c0, prenosi kroz celokupan blok. Dakle,
P0 = p7p6p5p4p3p2p1p0
Preostali članovi u izrazu za c8 ukazuju na sve ostale slučajeve kada blok generiše izlazni prenos. Dakle,
G0 = g7 + p7g6 + p7p6g5 + ... + p7p6p5p4p3p2g1 + p7p6p5p4p3p2p1g0
Konačno, izraz za c8 hijerarhijskog sabirača oblika je:
c8 = G0 + P0c0
Za blok 1, izrazi za G1 i P1 imaju istu formu, osim što indeks i treba zameniti indeksom i+8. Izrazi za G2, P2, G3
i P3, određuju se na isti način. Ako znamo funkcije generisanog i propagiranog prenosa na nivou blokova, tada
možemo odrediti i izraze za ulazne prenose u svaki pojedinačni blok:
c16 = G1 + P1c8
= G1 + P1G0 +P1P0 c0
Slično, izrazi za c24 i c32 su oblika:
c24 = G2 + P2G1 +P2P1G0 + P2P1P0c0
c32 = G3 + P3G2 +P3P2G1 + P3P2P1G0 + P3P2P1P0c0
Izračunavanje signala prenosa c8, c16, c24 i c32 na osnovu poznatih vrednosti Gj i Pj unosi dva dodatna nivoa
logike. Znači, pod pretpostavkom da je fan-in ograničen na 4 ulaza, vreme potrebno da se obavi sabiranje dva
32-bitna broja iznosi: 5tg za određivanje Gj i Pj (na osnovu prethodno sprovedene analize za c8), plus 3tg za
ubrzanje prenosa na drugom nivou (zato što dva gejta u izrazu za c32 zahtevaju 5 ulaza i zbog toga moraju biti
faktorizovani), plus jedno tg (XOR) za određivanje bitova sume, što u zbiru daje 9tg. Tačnije, konačna suma se
generiše posle 8tg zato što c32 ne utiče na bitove sume. Međutim, c32 se koristi za detekciju aritmetičkog
prekoračenja (Prekoračenje = c32 ⊗ c31). Dakle, trajanje operacije sabiranja, uključujući detekciju prekoračenja,
ekvivalentno je kašnjenju kroz 9 gejtova.

Sl. 4-54 Hijerarhijski sabirač sa ubrzanim prenosom.

Ranije smo utvrdili da sabiranje dva n-to bitna broja pomoću sabirača sa rednim prenosom traje (2n+1)tg, što za
n=32 iznosi 65tg. Očigledno, isti zadatak sabirač sa ubrzanim prenosom obavi za oko 7 puta brže. Ovo značajno
poboljšanje performansi ostvareno je na račun značajno veće složenosti sabirača sa ubrzanim prenosom.

179
Sabirači sa izborom prenosa
Na Sl. 4-55(a) je prikazan n-bitni sabirač formiran serijskim povezivanjem dva manja sabirača. Sabirač SL
obavlja sabiranje na nižim pozicijama (k-1, ..., 0), a SH na višim pozicijama (n-1, ..., k). Ukupno kašnjenje n-
bitnog sabirača iznosi tp=tL + tH, gde je tL kašnjenje kroz sabirač SL, a tH kašnjenje kroz sabirač SH. Iako se
sabirci istovremeno dovode na oba manja sabirača, sabirač SH nije u mogućnosti da odredi korektan zbir sve
dok od sabirača SL ne dobije informaciju od vrednosti prenosa ck. Međutim, uočimo da iako nepoznate
vrednosti, ck može biti samo 0 ili 1. Odnosno, zbir koji daje SH može biti
Xn-1, ..., k + Yn-1, ..., k (za ck=0) ili
Xn-1, ..., k + Yn-1, ..., k + 1 (za ck=1).
Ovo zapažanje nas dovodi do osnovne ideje sabirača sa izabranim prenosom (ili CSA – Carry Select Adder). (Sl.
4-55(b)). Umesto jednog koriste se dva sabirača za više pozicije, SH0 i SH1, koji rade paralelno nad istim
operandima, s tim da SH0 kao ulazni prenos ima konstantu 0, a SH1 konstantu 1. Na taj način, SH0 generiše Xn-1,
..., k + Yn-1, ..., k, a SH1 Xn-1, ..., k + Yn-1, ..., k + 1. Onog momenta kada tačna vrednost ulaznog prenosa ck postane
poznata, kroz multiplekser se na izlaz propušta jedan od dva alternativna rezultata.
Xn-1...k Yn-1...k Xn-1...k Yn-1...k Xk-1...0 Yk-1...0

SH1 1 SH0 0 SL
Xn-1...k Yn-1...k Xk-1...0 Yk-1...0
ck

ck 1 0
SH SL MUX S

Sn-1...k Sk-1...0 Sn-1...k Sk-1...0

(a) (b)
Sl. 4-55 (a) redna sprega sabirača (b) sabirač sa izborom prenosa.
Zanemarujući kašnjenje kroz multiplekser, kašnjenje n-bitnog sabirača je smanjeno na tp=max{tL,tH}. Veća
brzina rada postignuta je zahvaljujući obimnijem hardveru.

4.2.3 Logička jedinica

Uopšteno govoreći, logička jedinica nam omogućava da obavimo jednu od nekoliko logičkih funkcija nad dva
proizvoljna n-bitna operanda X=xn-1 … x0 i Y=yn-1 … y0. Binarne logičke operacije se primenjuju na više-bitne
operande tako što se logička operacije primeni na svaki par odgovarajućih bitova dva operanda. Na primer,
logička AND operacije primenjena na dva 4-bitna operanda 1010 i 1100, daje 4-bitni rezultat 1000. Drugim
rečima, uvek kada je izabrana funkcija fi, logička jedinica će izračunati rezultat:
S = fi(X,Y)=fi(xn-1,yn-1) … fi(x0,y0)
S obzirom da logička jedinica, koja je sposobna da izračuna svih 16 Bulovih funkcija koje koriste dva operanda,
i nije tako složena, iskoristićemo takvu jednu jedinicu kako bi smo demonstrirali opštu proceduru za
projektovanje bilo koje logičke jedinice.
Na Sl. 4-56(a) prikazano je svih 16 Bulovih funkcija koje koriste dve promenljive. Pošto je broj funkcija 16, za
izbor jedne od njih, potrebne su četiri binarne promenljive, S3, S2, S1 i S0. Kodiranje selekcionih ulaza je takvo
da je Si=1, 0≤i≤3, ako i samo ako je minterm mi u izabranoj funkcije jednak mi=1. Na primer, OR funkcija,
izražena kao logička suma minterma ima oblik f14=m3+m2+m1, što znači da je njen kod S3S2S1S0=1110. Uočimo
da selekcione promenljive interpretirane kao binarni broj imaju vrednost jednaku indeksu izabrane funkcije.
Drugim rečima, za funkciju f14 vrednost S3S2S1S0 je jednaka 1110 što odgovara binarnoj reprezentaciji broja 14.
Pošto svaka selekciona promenjiva kontroliše jedan minterm, logička funkcija koja odgovara logičkoj jedinici
za jednu bitsku poziciju je oblika:
si = S0m0+S1m1+S2m2+S3m3
= S0xi’yi’+S1xi’yi+S2xiyi’+S3xiyi
Struktura logičke jedinice za jednu bitsku poziciju prikazan je na Sl. 4-56(b), dok je na Sl. 4-56(c) prikazan
grafički simbol n-bitne logičke jedinice. U opštem slučaju, bilo koja n-bitna logička jedinica imaće n identičnih

180
segmenata, koji konkurentno obavljaju istu funkciju nad parovima odgovarajućih bitova dva n-bitna operanda.
Na Sl. 4-56(d) prikazan je primer 8-bitne logičke jedinice.

Sl. 4-56 Logička jedinica: (a) funkcije od dve promenljive; (b) realizacije logičke jedinice; (c) grafički simbol; (d) 8-
bitna logička jedinica.

4.2.4 Aritmetičko-logička jedinica

Aritmetičko-logička jedinica (ili ALU prema engleskom nazivu Arithmetic and Logic Unit) je više-funkcijsko,
kombinaciono kolo koje može da obavi bilo koju od više različitih aritmetičkih i logičkih operacija nad parom
b-bitnih operanada. Pri tome, jedna od raspoloživih operacija bira se preko skupa selekcionih ulaza. Broj i
složenost operacija podržanih od strane ALU modula su pitanje izbora projektanta i mogu značajno da variraju
od ALU do ALU modula. Tipične aritmetičke operacije, koje se sreću kod većine ALU modula, obično su
zasnovane na sabiranju, kao na primer, sabiranje, oduzimanje, inkrementriranje i dekrementiranje.
Inkrementiranje je operacija sabiranja sa 1, a dekrementiranje oduzimanja za 1. Međutim, postoje i ALU moduli
koji su u stanju da obavljaju i složenje aritmetičke operacije, kao što su množenje, deljenje, stepenovanje,
pomeranje, poređenje i dr. Tipične logičke operacije su AND, OR, komplement, XOR.
Postoje dva glavna razloga za projektovanje ALU jedinica u obliku standardnih modula. Prvo, dostupnost
univerzalnih aritmetičkih modula omogućava da se isti modul koristi u mnogim različitim primenama, čime se
smanjuje broj različitih modula koji se koriste u projektovanju. Drugo, ALU moduli se mogu efikasno koristiti u
sistemima, kao što je procesor, kod kojih operacija koju treba obaviti u datom trenutku bira dinamički, od strane
upravljačke jedinice procesora.
U ovom odeljku biće izložen postupak projektovanje jedne konkretne 4-bitne ALU jedinice. S obzirom da su
aritmetičke operacija zasnovane na sabiranju, ALU se može projektovati tako što će se modifikovati ulazi
binarnog sabirača. Logika koja obavlja ovu modifikciju, a tiče se aritmetičkih operacija, zove se aritmetički
ekspander (AE), dok se ona koja se koristi za logičke operacije zove logički ekspander (LE). Ekspanderi su
povezani su na ulaz sabirača, na način kako je to prikazano na Sl. 4-57. U nastavku će biti izložena procedura
projektovanja ekspandera AE i LE na primeru ALU jedinice koja obavlja četiri aritmetičke i četiri logičke
operacije.

181
 a3 b3 a2 b2 a1 b1 a0 b0

LE AE LE AE LE AE LE AE

x3 y3 x2 y2 x1 y1 x0 y0

c3 c2 c1
c4 FA FA FA FA c0

f3 f2 f1 f0

Sl. 4-57 4-bitni sabirač u spoju sa aritmetičkim (AE) i logičkim (LE) ekspanderima.
Najpre, neophodan je ulaz za izbor režima rada, M, koji će birati aritmetičke ili logičke operacije, tako da pri
M=1, ALU obavlja aritmetičke, a pri M=0 logičke operacije. Takođe, potrebne su dve promenljive za izbor
operacije, S1 i S0, koje će, u zavisnosti od vrednosti ulaza M, birati jednu od četiri aritmetičkih ili četiri logičkih
operacija, na način kako je to definisano funcijskom tabelom sa Sl. 4-58(a), za aritmetičke, i tabelom sa Sl.
4-59(a), za logičke operacije.
M S1 S0 bi yi
1 0 0 0 1
1 0 0 1 1
1 0 1 0 0
1 0 1 1 1
M S1 S0 Ime funkcije F X Y c0 1 1 0 0 1
1 0 0 Dekrement A-1 A sve jedinice 0 1 1 0 1 0
1 0 1 Sabiranje A+B A B 0 1 1 1 0 0
1 1 0 Oduzimanje A+B'+1 A B' 1 1 1 1 1 0
1 1 1 Inkrement A+1 A sve nule 1 0 X X X 0
(a) (b)

(c) (d)
Sl. 4-58 Aritmetički ekspander: (a) funkcionalna tabela; (b) tabela istinitosti; (c) Karnoova mapa; (d) struktura.
U funkcionalnnoj tabeli sa Sl. 4-58(a), za svaku aritmetičku operaciju, navedene su vrednost izlaza ALU
jedinice, F, kao i vrednosti ulaza sabirača, X i Y, i ulaznog prenosa c0 koje su neophodne da bi se dobila
odgovarajuća vrednost F. Shodno ovoj tabeli, na ulaz X sabirača uvek se dovodi operand A, dok su na ulazu Y u
zavisnosti od izabrane operacije prisutne: sve jedinice, operand B, komplement operanda B, ili sve nule.
Vrednosti ulaza Y se generišu uz pomoć AE ekspandera, čija je tabela istinitosti prikazan na Sl. 4-58(b). Ova
tabela je dobijena na osnovu funkcionalne tabele sa Sl. 4-58(a) tako što je kolona Y zamenjena kolonama bi i yi.
Na Sl. 4-58(c) prikazana je Karnoova mapa AE ekspandera, na osnovu koje sledi izlaz: yi=MS1’bi+MS0’bi'.
Konačno, struktura AE ekspandera prikazana je na Sl. 4-58(a).
Projektovanje logičkog ekspandera, takođe, započinje funkcionalnom tabelom koja definiše logičke operacije, a
koja je prikazana na Sl. 4-59(a). Kao što se može zaključiti analizom ove tabele, za bilo koju logičku operaciju,
ulazi Y i c0 sabirača su uvek postavljeni na vrednost 0, dok se na ulaz X postavlja rezultat logičke jednačine koja

182
odgovara izabranoj logičkoj operaciji. Na osnovu funkcionalne tabele sa Sl. 4-59(a), u mogućnosti smo da
formiramo tabelu istinitosti logičkog ekspandera, koja je prikazana na Sl. 4-59(b). Na osnovu odgovarajuće
Karnoove mape Sl. 4-59(c), sledi logički izraz za jednu bitsku poziciju logičkog ekspandera:
xi=M’S1’S0’ai` +M’S1S0bi+S0aibi+S1ai+Mai
Kombinaciona mreža logičkog ekspandera koja sledi na osnovu dobijenog izraza prikazana je na Sl. 4-59(d).
M S1 S0 Ime funkcije F X Y c0 M S1 S0 xi
0 0 0 Komplement A' A' 0 0 0 0 0 a i'
0 0 1 AND A AND B A AND B 0 0 0 0 1 a ibi
0 1 0 Identitet A A 0 0 0 1 0 ai
0 1 1 OR A OR B A OR B 0 0 0 1 1 a i+bi
1 X X ai
(a) (b)

(c) (d)
Sl. 4-59 Logički ekspander: (a) funkcionalna tabela; (b) tabela istinitosti; (c) Karnoova mapa; (d) struktura.
Nakon obavljenog projektovanja aritmetičkog i logičkog ekspandera, ALU jedinica formira se povezivanjem
AE i LE ekspandera sa binarnim sabiračem, na način kao što je prikazano na Sl. 4-60(a). Uočimo da se kod ALU
jedinice, logičke operacije obavljaju u logičkim ekspanderima, a da potpuni sabirači (FA) propuštaju na izlaz F
rezultat LE ekspandera bez ikakve promene. Drugim rečima, prilikom obavljanja logičkih operacija potpuni
sabirači se koriste kao veze sa fiksnim propagacionim kašnjenjem.
Uočimo, takođe, da prlikom izvršenja aritmetičkih operacija nad neoznečenim brojnim vrednostima, signal
izlaznog prenosa iz pozicije najveće težine ukazuje na prekoračenje. Za slučaj aritmetičkih operacija nad
označenim brojevima (predstavljenim u obliku dvojičnog komplementa), uslov prekoračenja je drugačiji i
formira se kao XOR operacija izlaznih prenosa iz dve bitske pozicije najveće težine. Ako je neophodno, 4-bitna
ALU jedinica sa slikaa se može proširiti na n-bitnu ALU jedinicu, korišćenjem n-bitnog sabirača u spoju sa n
aritmetičkih i n logičkih ekspandera. Grafički simbol ovakve ALU jedinice prikazan je na Sl. 4-60(b). Većina
ALU jedinica, koje se koriste u praksi, konstruišu se na opisani način, osim što se razlikuju po tipu i broju
aritmetičkih i logičkih operacija koje podržavaju.

183
 (a)

(b)
Sl. 4-60 ALU modul: (a) 4-bitna ALU; (b) grafički simbol.

4.2.5 Množači (*)

4.2.6 Specifični formati za predstavljanje brojeva

U prethodnim odeljcima bavili smo se isključivo celim binarnim brojevima predstavljenim u pozicionom
brojnom sistemu. Međutim, kod digitalnih sistema u upotrebi su i neki drugi, specifični formati za predstavljanje
brojeva. U ovom odeljku ukratko ćemo se upoznati sa tri takva formata: brojevi u fiksnom zarezu, brojevi u
pokretnom zarezu i binarno-kodirani decimalni brojevi.
Brojevi u fiksnom zarezu
Kod nekih aplikacija, zahteva se manipulacija brojevima koji nisu celobrojnog tipa. Jedno rešenje je korišćenje
brojeva u fiksnom zarezu. Broj u fiksnim zarezom, se sastoji iz celog i razlomljenog dela. Ovakav broj se
zapisuje u pozicionom brojnom sistemu na sledeći način:
B = bn-1bn-2...b1b0 . b-1b-2...b-k
Pozicije levo od tačke, definišu ceo, a desno od tačke razlomljni deo broja. Težine pozicija u razlomljenom delu
su negativni stepeni osnove brojnog sistema. U binarnom brojnom sistemu, vrednost broja B iznosi:
n −1
V ( B) = ∑b × 2
i=−k
i
i

Prevođenje razlomljenog binarnog broja u decimalni ekvivalent je trivijalno i obavlja se primenom prethodne
jednačine, pri čemu se sve operacije obavljaju u decimalnom brojnom sistemu. Na primer, decimalni ekvivalent
broja (1101.101)2 iznosi:
(1101.101)2 = (1 × 23 + 1 × 22 + 0 × 21 + 1 × 20 + 1 × 2-1 + 0 × 2-2 + 1 × 2-3)10
= (8 + 4 + 1 + 1/2 + 1/8) 10
= (13 + 0.5 + 0.125) 10
= (13.562)10

184
Prevođenje decimilanog broja sa tačkom u binarni broj obuhvata nezavnisno prevođenje celog i razlomljenog
dela. Celi deo se prevodi na poznati način, tj. uzastopnim deljenjem sa 2 i izdvajanjem ostatka. Slično,
razlomljeni deo se prevodi u binarni ekvivalent uzastopnim množenjem sa 2 i izdvajanjem celobrojnog dela iz
dobijenog proizvoda. Neka razlomljeni decimalni broj D=0.d-1d-2 ... d-m, vrednosti V, treba konvertovati u
binarni broj B=0.b-1b-2 ... b-k. Znači, treba odrediti bitove b-1, b-2, ..., b-k, tako da važi:
V = b-1 × 2-1 + b-2 × 2-2 + ... + b-k × 2-k
Ako V pomnožimo sa 2, dobićemo:
2 × V= b-1 × 20 + b-2 × 2-1 ... + b-k × 2-(k-1)
Celobrojni deo ovog množenja je b-1, a razlomljeni b-2 × 21 ... + b-k × 2-(k-1), tj. 0.b-2b-3...b-k. Znači, ako
množenjem polaznog decimalnog broja dobijemo kao celobrojni deo 0, važi b-1=0, a ako dobijemo 1, važi b-1=1.
Množenjem dobijenog razlomljenog broja sa 2, kao celobrojni deo dobićemo b-2, a novi razlomljeni broj biće je:
0.b-3b-4...b-k. Ako nastavimo da množimo novi razlomljeni broj sa 2 i određujemo po jedan bit u svakom koraku,
dobićemo sve bitove binarnog broja. Ovaj postupak se nastavlja sve dok razlomljeni broj ne postane jednak 0.
Pr. 4-8 Odrediti binarni ekvivalent decimalnog broja 14.703125.
Celobrojni deo zadatog decimalnog broja je (14) 10, a razlomljeni (0.703125) 10. Na poznati način nalazimo
binarni ekvivalent celog dela:
(14)10 = (1110)2
Da bi smo našli binarni broj koji odgovara razlomljenom delu, primenjujemo prethodno opisanu proceduru
konverzije:
0.703125 × 2 = 1.40625 ⇒ b-1=1
0.40625 × 2 = 0.8125 ⇒ b-2=0
0.8125 × 2 = 1.625 ⇒ b-3=1
0.625 × 2 = 1.25 ⇒ b-4=1
0.25 × 2 = 0.5 ⇒ b-5=0
0.5 × 2 = 1.0 ⇒ b-6=1
Dakle, (14.703125) 10 = (1110.101101) 2
Kao što znamo iz elementrane matematike, racionalan broj je onaj koji iza tačke ima konačan broj cifara. Broj
sa beskonačnim brojem cifara iza tačke je iracionalan. Prevođenjem racionalnog binarnog broja u decimalni
brojni sistem uvek se dobija racionalni decimalni broj. Međutim, prilikom obrunute konverzije, neki brojevi koji
su u decimalnom sistemu racionalni u binarnom sistemu postaju iracionalni.
Pr. 4-9 Odrediti binarni ekvivalent decimalnog broja 0.55.
0.55 × 2 = 1.1 ⇒ b-1=1
0.1 × 2 = 0.2 ⇒ b-2=0
0.2 × 2 = 0.4 ⇒ b-3=0
0.4 × 2 = 0.8 ⇒ b-4=0
0.8 × 2 = 1.6 ⇒ b-5=1
0.6 × 2 = 1.2 ⇒ b-6=1
0.2 × 2 = 0.4 ⇒ b-7=0
0.4 × 2 = 0.8 ⇒ b-8=0
...
Proces konverzije možemo nastaviti u nedgled, ali uslov kraja (razlomljeni deo jednak nuli), nikada neće biti
ispunjen. Pažljivim analizom procesa konverzije možemo uočiti da će se u nastavku konverzije neprekidno
ponavljati sekvenca razlomnjenih brojeva 0.2, 0.4, 0.8, 0.6. Dakle, (0.55) 10 = (0.10<0011>)2, gde uglaste
zagrade obuhvataju binarnu sekvencu koja se neprekidno ponavlja, do u beskonačnost.
Pošto digitalni sistemi mogu baratati samo brojevima ograničene dužine, konverzija mora biti prekinuta kada se
prekorači raspoloživi broj bitova, što naravno unosi grešku. Na primer, ako je u primeru Pr. 4-9 broj bitova za
predstavljanje razlomljenog dela ograničen na osam, decimalni broj 0.55 u digitalnom sistemu koji radi sa
brojevima u fiksnom zarezu, će biti predstavljen sa: (0.10001100) 2, što ustvari odgovara decimalnom broju
(0.546875)10.
Digitalna kola koja barataju brojevima u fiksnom zarezu su u suštini ista kao i ona koja se koriste za celobrojne
binarne brojeve, pa ih iz tog razloga nećem posebno razmatrati.

185
Brojevi u pokretnom zarezu
Opseg brojeva u fiksnom zarezu ograničen je brojem značajnih cifara koje se koriste za predstavljanje broja. Na
primer, ako za predstavljanje celih decimalnih brojeva koristimo 8 cifara i znak, opseg vrednosti koje se mogu
predstaviti je 0 do ±999999999. Ako osam cifara koristimo za predstavljanje razlomljenog dela, tada je opseg,
obuhvaćen ovakvom reprezentacijom, od 0.0000001 do ±0.99999999. Me đutim, kod mnogih tehničkih i
naučnih primena, često je neophodno baratati brojevima koji su ili veoma veliki ili veoma mali. Umesto da
koristimo reprezentaciju u fiksnom zarezu sa velikim brojem značajnih cifara, bolje rešenje je koristiti
reprezentaciju u pokretnom zarezu. Broj u pokretnom zarezu je predstavljen manitsom (M), koja sadrži značajne
cifre, i eksponentom (M) osnove R. Format ovog zapisa je sledeći:
M × RE (5.6)
Brojevi se obično normalizuju, tako da je tačka u mantisi uvek postavljena desno od prve nenulte cifre, kao na
primer, 5.341 × 1042 ili 3.982 × 10-31. Dakle, broj u formatu pokretnog zareza se predstavlja parom (matnisa,
eksponent), a pri tome se vrednost broja izračunava shodno izrazu (5.6).
Binarna reprezentacija brojeva u formatu pokretnog zareza standardizovana je od strane organizacije IEEE. Ovaj
standard definiše dva formata: obična (ili jednostruka) preciznost i dvostruka preciznost. Na Sl. 4-61 su
prikazani oblici oba formata.

(a) (b)
Sl. 4-61 IEEE formati brojeva u pokretnom zarezu: (a) jednostruka preciznost; (b) dvostruka preciznost.
Jednostruka preciznost
Format jednostruke preciznosti prikazan je na Sl. 4-61(a). Krajnji levi bit je bit znaka; 0 ukazuje na pozitivan, a 1
na negativan broj. 8-bitno polje E sadrži vrednost eksponenta, a 23-bitno polje M vrednost mantise. Osnova je
R=2. Uočimo da se osnova ne zapisuje, već se podrazumeva. Eksponent može biti kako pozitivan tako i
negativan. Umesto da se eksponent kodira kao 8-bitni označeni broj, što bi omogućilo predstavljanje vrednosti
eksponenta u opsegu -127 do +127, za kodiranje eksponenta, kod IEEE standarda se koristi format “višak-127”.
U ovom formatu, sadržaj polja E predstavlja zbir vrednosti stvarnog eksponenta i broja 127, tj. važi:
eksponent = E – 127.
Vrednost 127 se naziva uvećanjem, a E polarizovanim eksponentom. Kodiranje eksponenta u formatu “višak-
127” omogućava da se eksponenti mogu lako porediti. S obzirom da je E uvek pozitivan broj, poređenje dva
eksponenta se svodi na poređenje dva 8-bitni neoznačena cela brojeva. Dakle, opseg vrednosti polarizovanog
eksponenta je 0≤E≤255. Pri tome, krajne vrednosti 0 i 255 imaju posebno značenje. E=0 ukazuju na broj čija je
vrednost 0 (“čista nula”); dok E=255 ukazuje na beskonačno veliku vrednost. Izuzimajući ova dva specijalna
sučaja, normalni opseg eksponenta brojeva u jednostrukoj preciznosti je -126 do +127, što odgovara opsegu
vrednosti u polju E od 1 do 254.
Mantisa se predstavlja sa 23 bita. IEEE standard podrazumera normalizovanu mantisu, što znači da je bit
najveće težine mantise uvek jednak 1. Zbog toga, ovaj bit može biti izostavljen iz zapisa mantise. Na taj način se
efektivni broj bitava mantise povećava za jedan. Naime, ako je M binarna sekvenca u polju mantise, tada je
stvarna vrednost mantise |M| = 1.M, što odgovara 24-bitnoj mantisi. Shodno tome, u formatu sa Sl. 4-61(a)
moguće je predstaviti brojeve:
Vrednost = ±1.M × 2E-127
Dužina polja mantise od 23 bita omogućava predstavljanje brojeva sa preciznošću koja odgovara preciznosti od
oko 7 decimalnih cifara. Opseg eksponenta, 2 -126 do 2127, približno odgovara opsegu 10 ±38.
Dvostruka preciznost
Format za predstavljanje brojeva u pokretnom zarezu dvostruke preciznosti prikazan je na Sl. 4-61(b). Kao što se
može videti, format dvostuke preciznosti koristi 64 bita, a u odnosu na jednostruku tačnost prošireni su i
eksponent i mantisa. Time je pokriven daleko veći opseg i ostvarena veća preciznost brojeva. Polje za eksponent
ima 11 bita i sadrži vrednost eksponenta izraženu u formatu “višak-1023”, tako da važi:
eksponent = E – 1023

186
Opseg polarizovanog eksponent je 0≤E≤2047, pri čemu se, slično kao i kod jednostruke tačnosti, E=0 i E=2047
koriste za predstavljanje vrednosti nula i beskonačno, respektivno. Time je opseg eksponenta ograničen na od 1-
1023 = -1022 do 2046 – 1023 = 1023.
Mantisa ima 52 bita. Pošto se podrazumeva normalizovana mantisa, sadržaj ovog polja ukazuje na mantisu
oblika 1.M. Dakle, vrednost broja u pokretnom zarezu koje je predstavljen u formatu dvostruke tačnosti iznosi:
Vrednost = ±1.M × 2E-1023
Format dvostruke preciznosti omogućava predstavljanje brojeva koji imaju preciznost od oko 16 decimalnih
cifara i opseg od oko 10 ±308.
Sabiranje/oduzimanje brojeva u pokretnom zarezu
Mogu se sabirati/oduzimati samo brojevi u pokretnom zarezu koji imaju isti eksponent. Ako se eksponenti
razlikuju, njihova razlika se kompenzuje pomeranjem mantisa. Na primer, neka je potrebno sabrati brojeve
9.95 × 101 i 5 × 10-1. Najpre je potrebno izjednačiti eksponente. To se može uraditi tako što će se manji od dva
broja, 5 × 10-1, napisati u obliku 0.05 × 101, odnosno tako što će se mantisa ovog broja pomeriti za dve pozicije
udesno, a eksponent sabrati sa 2. Nakon sabiranja mantisa dobijamo rezultat 10 × 101. Konačno, rezultat se
normalizuje na oblik 1 × 102.
U opštem slučaju važi sledeće. Neka su X1=(M1, E1) i X2=(M2, E2) dva broja u pokertnom zarezu, gde su
Mi=Si|Mi| vrednosti mantisa, a Xi=(-1)Si |Mi|REi-uvećanje vrednosti brojeva Xi, i=1,2 i neka je: X=X1±X2 = (M, E).
Tada:
E = max{E1, E2},

M ± M 2 × R 1 2 , ako je E1 > E2

− E −E
M = 1 − E −E
 M 1 × R 2 1 ± M 2 , ako je E1 ≤ E2

Postupak sabiranja/oduzimanja brojeva u pokretnom zarezu čine sledeća tri koraka:

1. Operandi se svode na jednake eksponente tako što se manji od dva operanda pomera udesno. Broj
pozicija za pomeranje jednak je razlici dva eksponenta. Veći eksponent je ujedno i eksponent rezultata.
2. Sabiranje/oduzimanje mantisa (po pravilu za sabiranje/oduzimanje celih brojeva u formatu znak i
apsolutna vrednost).
3. Ako je neophodno, mantisa rezultata se normalizuje uz odgovarajuću korekciju eksponenta.
Pr. 4-10 Sabiranje/oduzimanje brojeva u pokretnom zarezu
Neka je R=2 i X1=(M1, E1) = (1001, 10), X2=(M2, E2) = (1100, 00). Odrediti X = X1 - X2.
X = (1001, 10) - (1100, 00)
1. X = (1001, 10) - (0011, 10)
2. X = (0110, 10)
3. X = (1100, 01)
Opisani postupak sabiranja/oduzimanja brojeva u pokretnom zarezu može se predstaviti dijagramom sa Sl. 4-62,
koji ukazuje na hardversku strukturu odgovarajućeg digitalnog kola.

187
 Sl. 4-62 Sabiranje/oduzimanje brojeva u pokretnom zarezu.
Množenje brojeva u pokretnom zarezu
Množenje brojeva predstavljenih u pokretnom zarezu se obavlja tako što se njihove mantise pomnože, a
eksponenti saberu. U opštem slučaju važi sledeće. Neka su X1=(M1, E1) i X2=(M2, E2) dva broja u pokertnom
zarezu, gde su Mi=Si|Mi| vrednosti mantisa, a Xi=(-1)Si |Mi|REi-uvećanje vrednosti brojeva Xi, i=1,2 i neka je:
X=X1 × X2 = (M, E). Tada:
M = M1 × M2
E =E1 + E2 - uvecanje
Oduzimanje uvećanja (127 kod IEEE formata) od zbira eksponenta je neophodno zato što su E1 i E2
polarizovani eksponenti, jednaki zbiru vrednosti pravog eksponenta (ei) i uvećanja, pa njihov zbir daje E1 + E2
= e1 + e2 + 2 × uvecanje.
Dakle, osnovni koraci postupka za množenje u pokretnom zarezu su:
1. Saberu se eksponenti i od dobijenog zbira oduzme uvećanje.
2. Pomnože se mantise brojeva (po pravilu za množenje celih brojeva u formatu znak i apsolutna
vrednost).
3. Dobijeni rezultat se normalizuje sličnim postupkom kao kod sabiranja.
4. Broj (binarnih) cifara proizvodu je dvostruko veći od broja cifara vrednost koje su množene; cifre koje
su višak se odbacuju u procesu zaokruživanja.
Pr. 4-11 Množenje brojeva u pokretnom zarezu
Neka je R=2 i X1=(M1, E1) = (1010, 01), X2=(M2, E2) = (1010, 10). Odrediti X = X1 × X2.
S obzirom da se eksponent predstavlja sa 2 bita, vrednost uve ćanja je 22-1-1 = 1.
X = (1010 × 1010, (01 + 10 - 1))
= (01100110, 10)
= (1100, 01) -- zaokruživanje + normalizacija
Opisani postupak sabiranja/oduzimanja brojeva u pokretnom zarezu može se predstaviti dijagramom sa Sl. 4-63,
koji ukazuje na hardversku strukturu odgovarajućeg digitalnog kola.

188
 Sl. 4-63 Množenje u pokretnom zarezu.
Deljenje brojeva u pokretnom zarezu
Deljenje brojeva predstavljenih u pokretnom zarezu se obavlja tako što se njihove mantise podele, a eksponenti
oduzmu. Neka su X1=(M1, E1) i X2=(M2, E2) dva broja u pokertnom zarezu, gde su Mi=Si|Mi| vrednosti mantisa, a
Xi=(-1)Si |Mi|REi-uvećanje vrednosti brojeva Xi, i=1,2 i neka je: X=X1 × X2 = (M, E). Tada:
M = M1 / M2
E =E1 - E2 + uvecanje
Dodavanje uvećanja na razliku eksponenata je neophodno jer su E1 i E2 polarizovani eksponenti, pa njihova
razlika daje E1 - E2 = e1 + uvećanje - (e2 + uvećanje) = e1 - e2, gde su ei prave vrednosti eksponenata.
Dakle, osnovni koraci postupka za deljenje u pokretnom zarezu su:
1. Oduzmu se vrednosti eksponenata i na dobijenu razliku doda uvećanje.
2. Podele se mantise brojeva (deljenje se vrši prema pravilima za deljenje celih brojeva u formatu znak i
apsolutne vrednosti).
3. Dobijeni rezultat se normalizuje sličnim postupkom kao kod sabiranja.
4. Dobijeni količnik se zaokružuje prema pravilima za zaokruživanje.
Pr. 4-12 Deljenje u pokretnom zarezu
Neka je R=2 i X1=(M1, E1) = (1010, 01), X2=(M2, E2) = (1010, 00). Odrediti X = X1 / X2.
S obzirom da se eksponent predstavlja sa 2 bita, vrednost uve ćanja je 22-1-1 = 1.
X = (1010 / 1010, (01 - 00 + 1))
= (1 0000, 10)
= (1000, 11) -- zaokruživanje + normalizacija
Opisani postupak sabiranja/oduzimanja brojeva u pokretnom zarezu može se predstaviti dijagramom sa Sl. 4-64,
koji ukazuje na hardversku strukturu odgovarajućeg digitalnog kola.
M1 E1 M2 E2

Oduzimanje
eksponenta i
deljenje
mantisa

prekoracenje potkoracenje

Detekcija
vodećih nula Postnormalizacija
i pomerač

M E

Sl. 4-64 Deljenje u pokretnom zarezu.

189
4.3 Sekvencijalne komponente
Kombinaciona kola, koja su razmatrana u prethodnoj sekciji, imaju osobinu da vrednost svakog njihovog izlaza
zavisi isključivo od vrednosti signala prisutnih na njihovim ulazima. Osim kombinacionih, postoji još jedna
široka klasa digitalnih kola, kod kojih vrednosti izlaza zavise ne samo od trenutnih vrednosti ulaza, već i od
ranijeg ponašanja kola. Ovakva kola sadrže memorijske elemente koji zadržavaju, pamte odnosno memorišu
vrednosti logičkih signala. Kaže se da ukupni sadržaj svih memorijskih elemenata u jednom kolu predstavlja
stanje tog kola. Kada se promene vrednosti ulaza, kolo ili ostane u istom (tj. tekućem) stanju, ili promeni svoje
stanje. Vremenom, kao posledica promena ulaza, kolo prolazi kroz sekvencu stanja. Kolo koja se ponašaju na
ovaj način zovu se sekvencijalna kola.
Sekvencijalna kola mogu biti sinhrona ili asinhrona. Asinhrona sekvencijalna kola menjaju svoje stanje uvek
kada se desi promena ulaznih vrednosti, dok sinhrona sekvencijalna kola menjaju svoje stanje i izlazne
vrednosti samo u fiksnim vremenskim trenucima, koji su određeni rastućom ili opadajućom ivicom taktnog
signala. Lečevi su primer asinhronih kola, a flip-flopovi, registarske komponente i konačni automati sinhronih
sekvencijalnih kola.
U ovoj sekciji biće razmatrana sinhrona sekvencijalna kola. Najpre će biti opisani različiti tipovi flip-flopova, a
zatim i tipične registarske komponente koje se konstruišu pomoću flip-flopova i kombinacionih struktura.

4.3.1 Flip-flopovi (*)

Postoji više tipova flip-flopova koji se razlikuju po funkciji i načinu konstrukcije. Opšte karakteristike svih flip-
flopova su sledeće: (a) flip-flop menja stanje sa rastućom ili opadajućom ivicom taktnog signala; (b) ulazi
podataka moraju biti stabilni u vremenu tsetup pre i vremenu thold nakon aktivne ivice taktnog signala.
U primeni su četiri osnovna tipa flip-flopova: SR, JK, D i T, koji se razlikuju po broju ulaza i načinu na koji
flip-flop reaguje na vrednosti koje su postavljene na njegovim ulazima. Flip-flop se opisuje grafičkim
simbolom, tabelom prelaza, prenosnom funkcijom i tabelom pobude. Tabela sa Sl. 4-65 sadrži definicije četiri
tipa flip-flopova. Grafički simbol pokazuje broj i tipove ulaza i izlaza. Svi flip-flopovi imaju izlazne signale Q i
Q’. Vrednost na izlazu Q (pravi izlaz flip-flopa) ukazuje na tekuće stanje flip-flopa. Na izlazu Q’ je uvek
prisutna komplementarna vrednost izlaza Q. Takođe, svi flip-flopovi poseduju ulaz za taktni signal. Trougao na
ulazu na takt ukazuje da se flip-flop taktuje rastućom ivicom taktnog signala. Suprotno, kružić na ulazu za takt
ukazuje na taktnovanje opadajućom ivicom.
Tip flip-flopa Simbol Tabela prelaza Prenosna funkcija Tabela pobude
S R Q(next) Q Q(next) S R
S Q
0 0 Q Q(next) = S + R’Q 0 0 0 X
SR 0 1 0 0 1 1 0
sa ograničenjem SR=0
R Q’ 1 0 1 1 0 0 1
1 1 ND 1 1 X 0

J K Q(next) Q Q(next) J K
J Q
0 0 Q 0 0 0 X
JK 0 1 0 Q(next) = JQ + K’Q 0 1 1 X
K Q’ 1 0 1 1 0 X 1
1 1 Q’ 1 1 X 0

D Q D Q(next)
D 0 0 Q(next) = D
Q’ 1 1

T Q T Q(next)
T 0 Q Q(next) = TQ’ + T’Q
Q’ 1 Q’

Sl. 4-65 Tipovi flip-flopova.

190
Svaki flip-flop ima jedan ili dva ulaza podataka. SR flip-flop ima dva ulaza, S (Set) i R (Reset) koji, kada su
aktivni, setuju, odnosno resetuju flip-flop. Drugim rečima, pri S=1 i R=0, izlaz flip-flopa Q se postavlja na 1, a
pri S=0 i R=1 na 0. Slično SR flip-flopu, JK flip-flop, takođe, ima dva ulaza, J i K, koji, kada su aktivni, setuju
ili resetuju flip-flop. Dodatno, kada su oba ulaza J i K aktivna u isto vreme, JK flip-flop menja (tj.
komplementira) svoje stanje. D flip-flop ima jedan ulaz, D (Data), koji setuje flip-flop ako je 1, odnosno
resetuje flip-flop ako je 0. T flip-flop ima jedan ulaz T, koji, kada je aktivan, menja (tj. komplementira) stanje
flip-flopa.
U drugoj koloni tabele sa Sl. 4-65 date su tabele prelaza, koje predstavljaju skraćenu formu tabele istinitosti. U
tabeli prelaza, za svaku kombinaciju ulaznih vrednosti i svako tekuće stanje flip-flopa, tj. stanje pre rastuće ivice
taktnog signala, navedeno je sledeće stanje flip-flopa, tj. stanje u koje flip-flop prelazi nakon rastuće ivice
taktnog signala. Tekuće stanje flip-flopa označeno je sa Q, a sledeće sa Q(next). Tabela prelaza se koristi
prilikom analize sekvencijalnog kola, kada su vrednosni ulaza u flip-flop poznate, a mi želimo da odredimo
stanje flip-flopa nakon rastuće ivice taktnog signala. Na bazi tabele prelaza mogu se izvesti prenosne funkcije
flip-flopova, koje su prikazane u trećoj koloni tabele sa Sl. 4-65.
U četvrtoj koloni tabele sa Sl. 4-65 prikazane su tabele pobude koje se koriste prilikom sinteze sekvencijalnih
kola. Tabela pobude je inverzna tabeli prelaza i definiše ulaze flip-flopa koji su potrebni da bi flip-flop iz datog
tekućeg stanja, nakon rastuće ivice taktnog signala, prešao u željeno sledeće stanje.
Tip flip-flopa Dijagram stanja

SR

JK

Sl. 4-66 Dijagrami stanja različitih tipova flip-flopova.

Pored grafičkih simbola, tabela i funkcija, flip-flopovi se mogu jednoznačno opisati i dijagramom prelaza ili
grafom stanja, kod koga je svako stanje prikazano krugom, a prelaz između stanja linijom (tj. granom) koja ima
strelicu na strani odredišnog stanja. Ovakav način opisa fili-flopova prikazan je u tabeli sa Sl. 4-66. Uočimo da
su svakoj grani u grafu stanja pridružene vrednosti ulaznih signala koji uslovljavaju prelaz iz jednog u drugo
stanje. Takođe, treba uočiti da isto stanje može biti i izvor i odredište prelaza. Pošto se prelazi dešavaju u
trenutku delovanja ivice taktnog signala, svako stanje može se tretirati kao vremenski interval između dve
rastuće ivice taktnog signala.
Iz tabele sa Sl. 4-66 vidimo da dijagrami stanja svih flip-flopova imaju isti broj stanja i isti broj prelaza. Flip-flop
je u stanju set kada je Q=1, odnosno, u stanju reset kada je Q=0. Uz to, svaki flip-flop može da pređe iz jednog u
drugo stanje ili da ostane u istom stanju. Jedina razlika između četiri tipa flip-flopova je u vrednostima ulaznih
signala koji iniciraju prelaze. Dijagrami stanja se veoma često koriste za vizuelni prikaz rada flip-flopova, kao i
drugih, mnogo složenijih sekvencijalnih kola.
Svaki flip-flop je obično dostupan u dve varijante: sa ili bez ulaza za direktno, ili asinhrono postavljanje, koji se
koriste za setovanje (ulaz SET) i resetovanje (ulaz CLR) flip-flopa nezavisno od ostalih ulaza. Ovi ulazi se
koriste za postavljanje flip-flopa u poznato početno (ili inicijalno) stanje. Na primer, stanje u koje će se flip-flop
spontano postaviti nakon što je uključeno napajanje ne može se predvideti. Zato je neophodno da se pre početka
normalnog, sinhronog rada, flip-flop, posredstvom asinhronih ulaza, postaviti u odgovarajuće početno stanje.
Ulazi SET i CLR se zovu asinhroni zato što ne zavise od taktnog signala i zbog toga imaju prioritet nad svim

191
ostalim sinhronim ulazima. Drugim rečima, dok je asinhroni ulaz aktivan, vrednosti ostalih ulaza flip-flopa se
ignorišu. Dejstvo asinhronog ulaza počinje onog trenutka kada se na ulaz dovede aktivan naponski nivo (0 ili 1),
i traje sve dok se ulaz ne deaktivira. Ako flip-flop poseduje oba asinhrona ulaza, SET i CLR, njihovo
istovremeno dejstvo nije dozvoljeno. Na Sl. 4-67 su prikazani grafički simboli flip-flopova sa ulazima za
direktno postavljanje sa aktivnim niskom naponskim nivoom, što je naznačeno kružićima na odgovarajućim
ulazima. Kod asinhronih ulaza sa aktivnim visokim naponskim nivoom, kružići su izostavljeni.

Sl. 4-67 Simboli flip-flopova sa asinhronim ulazima.

4.3.2 Registarske komponente

Osnovna namena registarskih komponenti je čuvanje podataka i obavljanje jednostavnih transformacija
podataka, kao što su brojanje i pomeranje memorisanog sadržaja. U sekciji biće definisani i projektovani
različiti tipovi registarskih komponenti: prihvatni, pomerački i brojački registri i nešto složenije registarske
strukture: registarski fajl, stek i FIFO memorija.

4.3.2.1 Prihvatni registar

Registar je memorijska komponenta koja se sastoji od n flip-flopova sa zajedničkim taktnim signalom.
Sinhronizovano sa rastućom ivicom taktnog signala, u svaki flip-flop upisuje se jedan bit informacije. U svom
osnovnom obliku, pored taktnog signala, registar ima n ulaza i n izlaza. Na Sl. 4-68 prikazan je primer 4-bitnog
registra. Grafički simbol 4-bitnog registra dat je na Sl. 4-68(a), dok je na Sl. 4-68(b) prikazana njegova unutrašnja
struktura, koju čine četiri paralelno povezana D flip-flopa.
I3 I2 I0

D3 Q3 D2 Q2 D1 Q1 D0 Q0

I3 I2 I1 I0
Registar
Clk
Q3 Q2 Q1 Q0

Q3 Q2 Q1 Q0

(a) (b)
Sl. 4-68 4-bitni registar: (a) grafički simbol; (b) unutrašnja struktura.
Funkcionalnost osnovne varijante registra, prikazane na Sl. 4-68, može se proširiti dodavanjem različitih
upravljačkih signala. Na primer, ako registar treba biti resetovan ili setovan nezavisno od taktnog signala, bilo
pri uključenju napajanja, bilo pri pojavi nekih specifičnih događaja, mogu se dodati signali za asinhrono
resetovanje i setovanje. Takvo jedno proširenje se postiže zamenom jednostavnih flip-flopova sa Sl. 4-68(b),
flip-flopovima sa ulazima za direktno postavljanje, kao što je prikazano na Sl. 4-69.
Kao što se vidi na Sl. 4-69, kratkotrajnim aktiviranjem signala Clear sadržaj registra se briše ili resetuje, tj.
postavlja na “sve nule”. Slično, registar se setuje, tj. njegov sadržaj postaviti na “sve jedinice”, kratkotrajnim
aktiviranjem signala Set. (S obzirom da je aktivni nivo signala Clear i Set nizak, aktiviranje jednog od ova dva
signala znači postavljanje 0 na odgovarajući ulaz). Ulazi Clear i Set su nezavisni od taktnog signala i imaju
prioritet nad njim. To znači da ako je u trenutku pojave rastuće ivice taktnog signala, Set ili Clear jednak 0, ulaz
I se ignoriše, a registar se setuje, odnosno resetuje.

192
 (a) (b)
Sl. 4-69 4-bitni registar sa asinhronim resetovanjem i setovanjem: (a) grafički simbol; (b) unutrašnja struktura.
Kod obe varijante registra, prikazane na Sl. 4-68 i Sl. 4-69, novi podatak se automatski upisuje u registar sa
svakom rastućom ivicom takta. Međutim, kod mnogih digitalnih sistema, podatak koji je upisan u registar ostaje
u registru nekoliko taktnih ciklusa pre nego što se upiše novi podatak. Iz tog razloga, mogućnost kontrole upisa
predstavlja korisnu funkciju registra. Kontrola upisa se postiže korišćenjem upravljačkog signala Load (ili
Enable) koji kada je 1 dozvoljava upis novog podatka u registar. Ovakav tip registra se zove registar sa
dozvolom.
Na Sl. 4-70 su prikazani grafički simbol, tabela operacija i unutrašnja struktura registar sa dozvolom. Registar
sadrži multipleksere 2-u-1 koji omogućavaju izbor između ulaznog podatka ili podatka koje je već u registru.
Signal Load upravlja multiplekserima na takav način da kada je Load=1, u registar se upisuje novi, tj. ulazni
podatak. Sa druge strane, ako je Load=0, podatak koji je prethodno upisan u registar se vraća na ulaze flip-
flopova i sa sledećom rastućom ivicom takta ponovo upisuje u registar.

(a) (b)

(c)
Sl. 4-70 Registar sa dozvolom: (a) grafički simbol; (b) tabela operacija; (c) unutrašnja struktura.

4.3.2.2 Pomerački registar

U prethodnoj sekciji pokazano je kako se postavljanjem multipleksera ispred ulaza flip-flopova može
kontrolisati upis u registar. Sledeći sličnu logiku, multiplekseri se mogu iskoristiti i za pomeranje podatka
zapamćenog u registru. Ovakav tip registra se zove pomerački registar i omogućava pomeranje upisanog
sadržaja za jednu bitsku poziciju. U osnovnoj varijanti, pomerački registar poseduje upravljački signal Shift koji
kada je jednak 1 postavlja registar u režim pomeranja. Na Sl. 4-71 je prikazan primer 4-bitnog pomeračkog
registra. Serijski ulaz, IL, se koristi za unos novog 1-bitnog podatka u krajnji levi flip-flop registara. Pomerački
registar, kao što je registar sa Sl. 4-71, tipično se koristi za konverziju informacije iz serijskog u paralelni oblik.

193
Iz tog razloga, ovakav registar se zove i pomerački registar sa serijskim ulazom i paralelnim izlazom (SIPO –
Serial-In, Parallel-Out).

(a) (b)

(c)
Sl. 4-71 Četvorobitni pomerački registar sa serijskim ulazom i paralelnim izlazom: (a) grafički simbol; (b) tabela
operacija; (c) unutrašnja struktura.
Korišćenjem multpleksera 4-u-1, umesto multipleksera 2-u-1, moguće je kombinovati funkcije pomeranja i
paralelnog upisa. Na primer, pomerački registar sa Sl. 4-72 ima mogućnost kako pomeranja memorisanog
sadržaja tako i upisa novog podatka. Takođe, registar sa Sl. 4-72 može da obavlja pomeranje u oba smera. Pri
pomeranju na levo 1-bitni podatak sa ulaza IR (serijski ulaz sa desne strane) se upisuje na krajnju desnu
poziciju, dok se pri pomeranju na desno, na krajnju levu poziciju se upisuje 1-bitni podatak sa ulaza IL (serijski
ulaz sa leve strane). Na Sl. 4-72 (a) i (b) su prikazani grafički simbol i tabela operacija, dok se na Sl. 4-72 (c)
može videti unutrašnja struktura ovog multi-funkcijskog registra.
Registar sa Sl. 4-72 čine četiri razreda, gde svaki razred odgovara jednoj bitskoj poziciji i sastoji se od jednog
flip-flopa i multipleksera 4-u-1. Postoje tri tipa razreda, koji se neznatno razlikuju u strukturi: krajnji levi, krajnji
desni i srednji. Srednji razredi se obično projektuju prvi, pošto je njihova funkcija najočiglednija. Na primer,
jednačine ulaza flip-flopova za svaki od tri tipa razreda, dobijene na osnovu tabele operacija sa Sl. 4-72(c) imaju
sledeći oblik:
D0=S1’S0’Q0+S1’S0’I0+S1S0’IR+S1S0Q1
D1=S1’Si’Q0+S1’S0’Ii+S1S0’Qi-1+S1S0Qi+1, 1≤i≤2
D2=S1’S0’Q3+S1’S0’I3+S1S0’Q2+S1S0IL
Pomerački registar sa paralelnim upisom može se koristiti za konverziju informacija iz serijskog u paralelni
oblik i obrnuto, sa opcijom da prilikom paralelno-serijske konverzije prvo generiše bit najmanje ili bit najveće
težine. Registri ovog tipa, često se koriste za konverziju računarskih podataka u serijski oblik pogodan za
komunikaciju i rekonstrukciju serijski prenetih podataka u cilju obrade unutar računara.
Sledeće stanje
Operacija
S1 S0 Q3 Q2 Q1 Q0
S0 IL I3 I2 I1 I0 IR
0 0 Bez promene Q3 Q2 Q1 Q0
S1 Pomerački registar
0 1 Par. upis I3 I2 I1 I0
Q 3 Q2 Q1 Q0
1 0 Pomeranje na levo Q2 Q1 Q0 IR
1 1 Pomeranje na desno IL Q 3 Q2 Q1

(a) (b)

194
 (c)
Sl. 4-72 4-bitni pomerački registar sa paralelnim upisom: (a) grafički simbol; (b) tabela operacija; (c) unutrašnja
struktura.

4.3.2.3 Brojač
Brojač je posebna vrsta registara koji sadrži inkrementer, što omogućava brojanja naviše ili naniže. Na primer,
na Sl. 4-73 je prikazan brojač naviše koji ima dva upravljačka signala: signal dozvole (E), koji kada je 1
omogućava brojanje i signal Clear koji resetuje brojač, tj. postavlja ga u stanje 0. Grafički simbol 4-bitnog
binarnog brojača naviše prikazan je na Sl. 4-73(a), a tabela operacija na Sl. 4-73(b). Shodno Sl. 4-73(d)
inkrementer se sastoji od niza polu-sabirača (half-adder – HA) raspoređenih tako da su dva ulaza polu-sabirača
na bitskoj poziciji i povezani na izlaz i-tog flip-flopa Qi i izlazni prenos polu-sabirača sa pozicije i-1, Ci. Uočimo
da će nova vrednost flip-flopa Di biti 1 ako je bilo Qi bilo Ci, ali ne oba, jednako 1. Suprotno tome, izlaz Ci+1
biće jednak 1 samo ako su Qi i Ci oba jednaki 1. Tabela istinitosti polu-sabirača data je na Sl. 4-73(c). Polazeći
od ove tabele dolazimo do sledećih jednačine za Di i Ci+1:
Di = Qi ⊕ Ci
Ci+1= QiCi
Sve dok je signal E jednak 1, brojač će brojati naviše po modulu 16, dodajući 1 na svoj tekući sadržaj sa
svakom rastućom ivicom taktnog signala.

(a) (b) (c)

(c)
Sl. 4-73 4-bitni binarni brojač: (a) grafički simbol; (b) tabela operacija; (c) tabela istinitosti polu-sabirača; (d)
unutrašnja struktura.

195
Obostrani brojač, tj. brojač koji može brojati i naviše i naniže, konstruiše se tako što se u brojaču naviše polu-
sabirači zamene polu-sabiračima/oduzimačima (half-adder/substractor – HAS). HAS moduli, pod kontrolom
signala za izbor smera brojanja, obavljaju inkrementiranje ili dekrementiranje. Na primer, na Sl. 4-74 prikazan je
obostrani brojač koji u najvećem delu nalikuje brojaču naviše sa Sl. 4-73 s tom razlikom što poseduje dodatni
upravljački ulaz, D. Kao što je ukazano tabelom operacija sa Sl. 4-74(b), svrha ovog dodatnog ulaza je
postavljanje brojača u režim brojanja naviše, kada je njegova vrednost 0, odnosno u režim brojanja naniže, kada
je njegova vrednost 1. Na osnovu tabela istinitosti polu-sabiračima/oduzimačima sa Sl. 4-74(c) možemo izvesti
sledeće jednačine za Di i Ci+1:
Di = Qi ⊕ Ci
Ci+1= D’QiCi+ DQi’Ci
Kao što vidimo na Sl. 4-74(d), svaki polu-sabirač/oduzimač se sastoji od jednog XOR kola povezanog na ulaz
flip-flopa, kao i dva AND i jednog OR kola koja se koriste za propagaciju izlaznog prenosa.
Važno je uočiti da obostrani brojač sa Sl. 4-74 uvek počinje brojanje od 0. Međutim, u mnogim primenama
korisno je imati mogućnost postavljanja brojača na vrednost različitu od nule, a zatim nastaviti sa brojanjem,
naviše ili naniže. Ovakav tip brojača se zove brojač sa paralelnim upisom, a konstruiše se kombinovanjem
inkrementera/dekrementera i registra sa dozvolom. Kao što je prikazano na Sl. 4-75, brojač sa paralelnim upisom
ima tri upravljačka signala: E, D i Load. Signal E omogućava brojanje u smeru koji je određen signalom D, dok
signal Load, uvek kada je 1, zabranjuje brojanje i upisuje u registar podatak sa ulaza I. Sa druge strana, ako je
Load=0, brojač se ponaša na identičan način kao obostrani brojač sa Sl. 4-75. Tabela operacija i unutrašnja
struktura brojača sa paralelnim upisom prikazani su na Sl. 4-75(b) i (c).
E D Qi Ci Ci+1 Di

1 0 0 0 0 0
1 0 0 1 0 1
1 0 1 0 0 1
D 1 0 1 1 1 0
E Obostrani brojač E D Operacija
1 1 0 0 0 0
Clear Q3 Q2 Q1 Q0 0 X Bez promene 1 1 0 1 1 1
1 0 Brojanje naviše 1 1 1 0 0 1
1 1 Brojanje naniže 1 1 1 1 0 0

(a) (b) (c)

(c)
Sl. 4-74 4-bitni obostrani brojač: (a) grafički simbol; (b) tabela operacija; (c) tabela istinitosti polu-
sabirača/oduzimača; (d) unutračnja struktura.
Load E D Operacija
D
E Obostrani brojač 0 0 X Bez promene
0 1 0 Brojanje naviše
Load Q3 Q2 Q1 Q0
0 1 1 Brojanje naniže
1 X X Paralelni upis

(a) (b)

196
 I3 I2 I1 I0

D
E

HAS HAS HAS HAS

1 0 1 0 1 0 1 0
mux mux mux mux

Load

D3 Q3 D2 Q2 D1 Q1 D0 Q0

Q3' Q 2' Q1' Q0'

Clk

Izlazni Q3 Q2 Q1 Q0
prenos

(c)
Sl. 4-75 4-bitni obostrani brojač sa pralelenim upisom: (a) grafički simbol; (b) tabela operacija; (c) unutrašnja
struktura.

4.3.2.4 Registarski fajl

U prethodnim odeljcima opisani su različiti tipovi registara i brojača, od kojih se svaki sastoji od m flip-flopova
i dodatne kombinacione logike. Međutim, takođe je moguće rasporediti flip-flopove u dvo-dimenzionalno polje
koje će sadržati 2n vrsta od po m flip-flopova. Svaka vrsta u jednoj takvoj dvo-dimenzionalnoj strukturi, koja se
zove registarski fajl, može se smatrati jednim registrom. U opštem slučaju, registarski fajl memoriše istu
količinu informacije kao i 2n m-bitnih registara. Međutim, s obzirom na regularnost strukture, registarski fajl
zahteva manji broj internih veza, a time i manju površinu na mikročipu, u odnosu na odgovarajući broj
nezavisnih registara. Uz to, flip-flopovi registarskog fajla se mogu realizovati sa manjim brojem tranzistora.
Takođe, uvek se pristupa samo jednom flip-flopu u svakoj koloni.
Registarski fajl čine: dvo-dimenzonalno polje ćelija registarskog fajla (register-file cells – RFC), dekoderi za
čitanje i upis i izlazna baferska logika. Kao što je prikazano na Sl. 4-76(a), tipičnu ćeliju registarskog fajla čine
jedan D flip-flop i dva logička kola. Osim taktnog signala, ćelija ima tri ulaza i jedan izlaz: Write_select,
Read_select, Input i Output. Pri Write_select=1, D flip-flop pamti vrednost signala Input. Kada je
Read_select=1, sadržaj D flip-flopa se kroz tro-statički bafer prenosi na izlaz Output.
Na Sl. 4-76(b) prikazan je blok dijagram registarskog fajla kapaciteta 2nxm, dok je na Sl. 4-76(c) prikazana
unutrašnja organizacija registarskog fajla kapaciteta 4x4. (Iz razloga jednostavnijeg prikaza, na Sl. 4-76(c) je
izostavljen taktni signala.) Registarski fajl kapaciteta 2nxm ima m ulaza Im-1, …, I0, m izlaza Om-1, …, O0 i 2n
vrsta flip-flopova, kao što je prikazano na Sl. 4-76(c). Dekodera za upis služi za izbor vrste u koju će, u trenutku
delovanja rastuće ivice taktnog signala, biti smeštena ulazna vrednost. Ulaz dekodera za upis se sastoji od n
adresnih linija, WAn-1, …, WA0 i signala za dozvolu upisa, WE. Ako je WE=0, ulazna vrednost se ne upisuje u
registarski fajl.
Slično dekoderu za upis, dekoder za čitanja bira vrstu čiji sadržaj se prenosi na izlazu registarskog fajla.
Dekoder za čitanje ima n adresnih linija, RAn-1, …, RA0 i signal dozvole čitanja, RE. Pri RE=1, na izlazu
registarskog fajla javlja se, nakon manjeg kašnjenja kroz izlazne bafere, sadržaj izabrane vrste. Sa druge strane,
ako je RE=0, izlazni signali registarskog fajla su u stanju visoke impedanse.

197
 (a) (b)

(c)
Sl. 4-76 Registarski fajl sa jednim portom za upis i jednim portom za čitanje: (a) ćelija registarskog fajla; (b) grafički
simbol; (c) unutrašnja struktura.
Glavno ograničenje registarskog fajla sastoj se u činjenici da on omogućava ograničen pristup registrima iz fajla
– tj. uvek se može upisivati samo u jedan registar (vrstu) i čitati iz samo jednog registara (vrste). Ovakva
situacija može se donekle popraviti konstrukcijom registarskog fajla sa više od jednog porta za čitanje ili upis.
Nažalost, cena registarskog fajla raste srazmerno broju portova. Iz tog razloga, većina popularnih tipova
registarskih fajlova ima jedan ili dva porta za upis i dva porta za čitanje. Glavno opravdanje za dva porta za
čitanje jeste da su većina aritmetičkih i logičkih operacija binarne i da stoga, u isto vreme, zahtevaju dva
operanda. Sa dva porta za čitanje i jednim za upis, moguće je, u toku istog taktnog ciklusa, iz registaraskog fajla
pribaviti dva operanda i smestiti rezultat nazad u registarski fajl. Sa druge strane, opravdanje za korišćenje dva
porta za upis leži u brzini konzumiranja operanada: U svakom taktnom ciklusu koristimo dva operanda da bi
smo dobili jedan rezultat. Shodno tome, ako nam je cilj da obavljamo jednu operaciju po taktnom ciklusu, mora
postojati mogućnost da se u svakom taktnog ciklusu, pored rezultata koji se vraća u registarski fajl u registarski
fajl unese i jedan novi podatak.

(a) (b)

198
 WA1 WA0 WE I3 I2 I1 I0 RAB1 RAB0 REB RAA1 RAA0 REA

Dekoder za Dekoder za
čitanje čitanje
0
2-u-4 2-u-4

RFC RFC RFC RFC

0 0
1

RFC RFC RFC RFC

1
2 1

RFC RFC RFC RFC

2
3 2

RFC RFC RFC RFC

Dekoder
za upis 3
3
2-u-4

B3 A3 B2 A2 B1 A1 B0 A0

(c)
Sl. 4-77 Registarski fajl sa jednim upisnim portom i dva porta čitanje: (a) ćelija registarskog fajla; (b) grafički
simbol; (c) unutrašnja struktura.
Na Sl. 4-77 prikazan je primer registarskog fajla sa jednim portom za upis i dva porta za čitanje. Kao što se vidi
na Sl. 4-77(a), ćelija registarskog fajla je modifikovana u odnosu na Sl. 4-77(a) kako bi se obezbedila podrška za
dva porta za čitanje. Grafički simbol registarskog fajla prikazan je na Sl. 4-77(b). Na Sl. 4-77(c) prikazana je
unutrašnja struktura registarskog fajla kapaciteta 4x4. Uočimo da je dijagram sa Sl. 4-77(c) sličan strukturi
registarskog fajla sa Sl. 4-77(c), osim što nova verzija ima dodatni dekoder za čitanje, koji, sa svoje strane, unosi
po jednu dodatnu vezu ka svakoj vrsti i koloni. Uz pomoć ovih veza omogućen je prenos sadržaja do drugog
porta za čitanje.
Registarski fajlovi spadaju u brze memorijske komponente, zahvaljujući činjenici da su memorijske ćelije
realizovane na bazi flip-flopova ili leč kola. Međutim, s obzirom da svaki flip-flop sadrži barem 6 tranzistora,
registarski fajl je skupa memorija. Iz tog razloga, registarski fajlovi se tipično koriste kao privremena memorija
malog kapaciteta kod aplikacija koje zahtevaju veliku brzinu obrade podataka.

4.3.2.5 FIFO
FIFO red je struktura koja se često koristi kada treba uravnotežiti zahteve za nekom obradom. Zamislimo, na
primer, ljude kako stoje ispred šaltera u banci ili kako ulaze u autobus, koji moraju čekati u redu dok ne stignu
na red da budu opsluženi. Slična situacija se javlja kod različitih procesora, ASIC kola ili bilo kog uređaja koji
šalje podatke nekom drugom uređaju radi dalje obrade, u smislu da onda kada u jednom trenutku brzina
generisanja podataka nadmaši brzinu kojom se podaci obrađuju, neophodno je između proizvođača i potrošača
umetnuti red čekanja, tj. FIFO red. Naravno, u takvim situacijama, brzina kojom proizvođač generiše podatke ne
može u nedogled biti veća od brzine kojom potrošač može da prihvata podatke, jer bi to zahtevalo red čekanja
beskonačne dužine. U svakom slučaju, u proseku, obe brzine moraju biti iste, a veličina reda čekanja određuje
koliko dugo se može tolerisati neujednačenost između zahteva za obradom i brzine obrade.
Svrha FIFO reda je da sačuva podatke upućene potrošaču, koje on trenutno nije u stanju da prihvati, ali koje će u
dogledno vreme preuzeti i to u redosledu u kome su oni poslati. Znači, podatak koji je prvi upisan u FIFO, prvi
se i čita, i td., kao što je ilustrovano na Sl. 4-78. Na Sl. 4-78(a) je prikazan red čekanja nakon što su brojevi 23 i
34 upisani, ali pre nego što je stigao broj 45. Na Sl. 4-78(b) možemo videti sadržaj FIFO reda nakon upisa broja
45. Uočimo da je nakon čitanja FIFO reda, broj 23 odbačene i da je sadržaj reda pomeren za jednu poziciju na
dole. Sadržaj reda čekanja nakon pomeranja prikazan je na Sl. 4-78(c).

199
 (a) (b) (c)
Sl. 4-78 Princip rada FIFO reda: (a) sadržaj reda pre upisa broja 45; (b) sadržaj reda posle upis broja 45; (c) sadržaj
reda nakon čitanja broja 23.
Na Sl. 4-79 je prikazan blok dijagram FIFO reda. U opštem slučaju, FIFO red ima m ulaznih linija INi i m
izlaznih linija OUTi, gde je 0≤i≤m-1. Na izlazu OUT prisutan je podatak sa početka reda, tj. podatak koji je
najduže u redu čekanja. Na ulaz IN postavlja se podatak koji treba upisati u red. Takođe, FIFO red ima tri
upravljačka signala: R/W, Enable i Reset. Signal R/W služi za izbor operacije, upis ili čitanje. Za R/W=0, a pod
dejstvom taktnog signala clk, u FIFO se upisuje podatak prisutan na ulazu IN i smešta na kraj reda čekanja. Za
R/W=1, takođe pod dejstvom taktnog signala clk, iz FIFO reda se uklanja podatak sa početka reda (tj. podatak
koji je najduže u redu čekanja). Signal Enable se koristi kao dozvola upisa/čitanja. Upis/čitanje je dozvoljeno
ako je Enable=1. U suprotnom, Enable=0 onemogućava dejstvo taktni signal (sadržaj FIFO reda ostaje
neizmenjen). Signal Reset služi za resetovanje (pražnjenje) FIFO reda. Tipična realizacija FIFO reda ima još dva
statusna signala, Full i Empty, koji se koriste za kontrolu proizvođača i potrošača. Kada je red pun, signal Full
ima vrednost 1, što predstavlja upozorenje proizvođaču da će svaki naredni poslati podatak biti odbačen. Kada
se red isprazan, signal Empty postaje 1, što predstavlja upozorenje potrošaču da novi podaci još uvek nisu stigli.

Sl. 4-79 Blok dijagram FIFO reda.

Imajući u vidu da je unutar reda čekanja redosled pristizanja podataka očuvan, FIFO red možemo konstruisati uz
pomoć pomeračkih registara u kombinaciji sa brojačem koji će brojati važeće podatke u redu. Takva jedna
realizacija FIFO reda prikazana je na Sl. 4-80(c), a tabela operacija na Sl. 4-80(a). Rešenje koristi m 4-bitnih
pomeračkih registara, što znači da je kapacitet reda četiri m bitnih reči. Svaki bit ulaznog m-bitnog podatka se
upisuje u odgovarajući pomerački registar. Kraj reda je uvek na poziciji Q0 pomeračkih registara, dok se početak
reda pomera za jednu poziciju udesno, pri svakom upisu novog podatka. Pri upisu, pomerački registri pomeraju
svoj sadržaj za jednu poziciju udesno (upravljački ulaz pomeračkog registra S ima vrednost S=1), podatak se
upisuje na poziciju Q0, a brojač se inkrementira (D=0) tako da njegov sadržaj ponovo ukazuje na prvi upisani
podatak. Sa druge strane, pri svakom čitanju podatka iz reda, uz pomoć multipleksera se bira podatak sa početka
reda i prenosi na izlaz, a brojač se dekrementira (D=1). Uočimo da se pročitani podatak ne uništava, već samo
postaje nevažeći, time što je brojač dekrementiran. Na Sl. 4-80(b) prikazana je tabela upravljanja koja sadrži
vrednosti internih upravljačkih signala u zavisnosti od izabrane operacije. U toku operacije čitanja, sadržaj
pomeračkih registara se ne menja, a brojač broji za 1 unazad. Međutim, u toku operacije upisa, pomerački
registri će obaviti pomeranje za jednu poziciju udesno, a brojač će odbrojati za 1 unapred. Brojač, takođe,
upravlja izborom podatka prilikom operacije čitanja. U toku inicijalizacije, brojač se postavlja na 1111, tako da
njegovo stanje pri upisu prvog podatka u red postaje 0000. Ovakva inicijalizacija brojača je neophodna kako bi
se ostvarila pravilno upravljanje multiplekserima, koji zahtevaju vrednosti 00, 01, 10 i 11 na svojim selekcionim
ulazima da bi izabrali jedan od izlaza pomeračkih registara.
Na osnovu tabele upravljanja možemo odrediti jednačine preostalih upravljačkih signala:
S = (R/W)Enable
D = (R/W)’Enable
E = Enable

200
Svrha izlazne logike je generisanje signala Full i Empty. Red čekanja je prazan (Empty=1) ako je stanje brojača
111, a pun (Full=1) ako je stanje brojača 011. U svim ostalim stanjima brojača, oba signala, Full i Empty, imaju
vrednost 0. Dakle:
Full = Q2’Q1Q0
Empty = Q2Q1Q0
Na Sl. 4-80 (c) dat je šematski prikaz FIFO reda dužine 4.
Read/
Enable Operacija R/W Enable S D E
write
X 0 Bez promene X 0 0 X 0
0 1 Čitanje 0 1 0 1 1
1 1 Upis 1 1 1 0 1
(a) (b)

(c)
Sl. 4-80 FIFO red dužine 4 reči: (a) tabela operacija; (b) tabela upravljanja; (c) šematski prikaz.
Redovi čekanja veće dužine, obično, umesto pomeračkih registara, za smeštanje podataka koriste RAM
memoriju i sadrže dva brojača koji ukazuju na početak i kraj reda. Takva jedna struktura poznata je pod
nazivom kružni bafer. Simbolička predstava kružnog bafera prikazana je na Sl. 4-81(a). Uočimo da struktura sa
Sl. 4-81(a) koristi RAM memoriju kapaciteta 1K reči i dva brojača, označena kao Početak i Kraj. Brojač Početak
sadrži adresu najranije upisanog podatka. Uvek kada se zahteva operacija čitanja, podatak se čita sa adrese na
koju ukazuje brojač Početak i postavlja na U/I magistralu, a brojač Početak se inkrementira. Brojač Kraj sadrži
adresu prve prazne lokacije u redu. Prilikom operacije upisa, podatak se upisuje na lokaciju na koju ukazuje
brojač Kraj, a brojač Kraj se inkrementira. Ukoliko se podaci iz reda češće čitaju nego upisuju, desiće se
situacija da bajač Početak ukazuje na istu lokaciju kao i brojač Kraj, što znači da je red prazan. Sa druge strane,
ako se u rad podaci češće upisuju nego što se čitaju, brojač Kraj koji se inkrementira po modulu 1024, u jednom
trenutku ukazivaće na istu lokaciju kao i brojač Početak, što, međutim, sada znači da je red pun. Da bi se izbegla
dvosmislenost u značenju uslova Početak=Kraj, umesto 10-bitnih možemo koristiti 11-bitne (po modulu 2048)
brojače. Kod ovakve realizacije, red čekanja je prazan ako su sadržaji oba brojača identični, dok je red pun ako
se sadržaji brojača razlikuju samo na bitu najveće težine.

201
 Na Sl. 4-81 prikazana je realizacija FIFO reda koja koristi 1K RAM i dva brojača. Takođe, FIFO sadrži
multiplekser preko koga se bira jedan od brojača kao izvor adrese za RAM i komparator koji poredi sadržaje
brojača. Tabela operacija je prikazana na Sl. 4-81(b), tabela upravljanja na Sl. 4-81 (c), dok je na Sl. 4-81(d) dat
konačni šematski izgled FIFO reda zasnovanog na RAM memoriji.
0 prazno

1 podatak Početak

2 podatak

Read/ Read/ E E
... Enable Operacija Enable S CS RWS
write write (Početak) (Kraj)
1021 podatak Bez
X 0 X 0 X 0 X 0 0
promene
1022 prazno Kraj
0 1 Čitanje 0 1 1 1 0 1 0
1023 prazno
1 1 Upis 1 1 0 1 1 0 1
(a) (b) (c)

(d)
Sl. 4-81 FIFO red realizovan na bazi 1K RAM memorije: (a) princip rada; (b) Tabela operacija; (c) Tabela
upravljanja; (d) šematski prikaz.

4.3.2.6 Stek
Stek (stack) je memorijska struktura koja se često koristi kako u softveru tako i u hardveru. Po definiciji, stek je
memorija sa ograničenim pristupom. Za razliku od RAM memorije gde se bilo kom zapamćenom podatku može
pristupati u bilo kom vremenu, podacima zapamćenim u steku pristupa se samo preko jedne lokacije: vrh steka.
Drugim rečima, kada se podatak upisuje u stek, ili stavlja na stek (operacije push), on se smešta na vrh steka i
pri tome se svi prethodno upisani podaci spuštaju za jednu poziciju niz stek. Suprotno tome, kada se podatak
čita iz steka ili uzima sa steka (operacija pop), on se sklanja sa vrha steka i pri tome se svi ostali podaci podižu
za jednu poziciju naviše uz stek. Na Sl. 4-82(a) je prikazan stek dubine 4 (tj. kapaciteta 4 reči) koji inicijalno
sadrži dva broja: 34 na lokaciji Top i 23 na lokaciji Top-1. Na Sl. 4-82(b) može se videti da stavljanje broja 45 na
stek zahteva da brojevi 34 i 23 budu premešteni na lokacije Top-1 i Top-2. Sa druge strane, kada se broj 45
uzima sa steka, brojevi 34 i 23 se pomeraju naviše tako da ponovo zauzimaju lokacije Top i Top-1 (Sl. 4-82(c)).
U ovom konkretnom slučaju, na stek se može staviti najviše četiri broja, pre nego što se stek napuni. Nakon
toga, svaki novi upis u stek znači gubitak podatka sa dna steka.

202
 (a) (b) (c)
Sl. 4-82 Princip rada steka: (a) sadržaj steka pre upisa broja 45; (b) sadržaj steka nakon upisa broj 45; (c) sadržaj
steka nakon čitanja broja 45.
Prilikom projektovanja steka, važno je uočiti da se prilikom operacija upisa i čitanja, zapamćeni podaci
pomeraju za jednu poziciju naniže, odnosno naviše. Na osnovu ovog zapažanja zaključujemo da za realizaciju
steka treba koristiti pomeračke registre u kombinaciji sa obostranim brojačem za detekciju praznog, odnosno
punog steka. Ove komponente su korišćene za realizaciju m-bitnog steka dubine 4 koji je prikazan na Sl. 4-83.
Uočimo da ovaj stek ima m ulaznih linija INi i m izlaznih linija OUTi, gde je 0≤i≤m-1. Takođe, stek ima tri
upravljačka signala, Push/pop, Enable i Reset.
Signal Push/pop upravlja upisom i čitanjem iz steka. Kada je Push/pop=0, podatak se upisuje u stek; kada je
Push/pop=1, podatak se čita iz steka. Signal Enable omogućava (dozvoljava) rad steka, dok signal Reset, uvek
kada je 0, briše sadržaj pomeračkih registara i resetuje obostrani brojač. Rad steka je opisan tabelom operacija sa
Sl. 4-83(a). Uočimo da stek ima dva izlazna signala, Empty i Full, koji ukazuju na status steka, na sledeći način:
kada Empty ima vrednost 1, stek je prazan; sa druge strane, kada Full ima vrednost 1, stek je pun.
Izlazi
brojača
Push/ Enable Operacija Kontrola
pop Kontrola Q2 Q1 Q0 Empty Full
pom.
X 0 Bez Push/ brojača 0 0 0 1 0
registra
promene pop Enable S1 S0 D E 0 0 1 0 0
0 1 Upis X 0 0 0 X 0 0 1 0 0 0
(push)
1 1 Čitanje 0 1 1 1 0 1 0 1 1 0 0
(pop) 1 1 1 0 1 1 1 0 0 0 1
(a) (b) (c)

(d)
Sl. 4-83 Stek dubine 4. (a) tabela operacija; (b) tabela izlaza; (c) tabela upravljanja; (d) struktura steka.

203
Na Sl. 4-83(d) se može videti da se stek sastoji od m 4-bitnih pomeračkih registara sa paralelnim upisom tako da
svakom ulazu odgovara jedan pomerački registar. Pri svakom upisu u stek, svi pomerački registri obavljaju
operaciju pomeranja na desno. Slično, pri svakom čitanju iz steka, svi pomerački registri obavljaju operaciju
pomeranja na levo. Svaki novi podatak koji se stavlja na stek preko ulaza IL pomeračkog registra i upisuje se na
poziciju Q3, koja predstavlja vrh steka. Stanje brojača ukazuje na broj podataka u steku. Sinhronizovano sa
svakom rastućom ivicom taktnog signala, pomerački registri obavljaju pomeranje na desno, a brojač broji
unapred za 1 (Push/pop=0 i Enable=1), odnosno pomeranje na levo i brojanje unazad (Push/pop=1 i Enable=1).
Vrednosti upravljačkih signala pomeračkih registara i brojača mogu se izvesti na osnovu tabele upravljanja koja
je prikazana na Sl. 4-83(b). Na osnovu ove tabele možemo izvesti sledeće jednačine:
S1 = Enable
S0 = (Push/pop)’Enable
D = (Push/pop)Enable
E = Enable
Realizacija ovih jednačina predstavlja upravljačku logiku steka.
Na osnovu tabele izlaza sa Sl. 4-83(c), vidi se da izlazna logika dekoduje stanja brojača 000 i 100. Uvek kada je
stanje brojača 000, signal Empty biće 1; u bilo kom drugom stanju Empty je 0. Suprotno, uvek kada je stanje
brojača 100, signal Full biće 1; u bilo kom drugom stanju Full je 0. Na osnovu toga, možemo izvesti sledeće
Bulove jednačine za izlaznu logiku:
Empty = Q2’Q1’Q0’
Full = Q2Q1’Q0’
Radi preglednosti, na Sl. 4-83(d) je izostavljen taktni signal koji pobuđuje pomeračke registre i brojač.
Glavna slabost rešenja steka sa Sl. 4-83 ogleda se u činjenici da je za realizaciju steka veće dubine potreban
veliki broj ¨skupih¨ pomeračkih registara. Iz tog razloga, za realizaciju steka većeg kapaciteta koristi se RAM
memorija. Sa druge strane, pošto RAM memorija nema mogućnost pomeranja memorisanog sadržaja, push i
pop operacije moraju biti realizovane na nešto drugačiji način – promenom tekuće lokacije vrha steka. Drugim
rečima, kada se podaci stavljaju na stek, adresa vrha steka biće uvećana za jedan pri svakom upisu novog
podatka. Suprotno, kada se podaci uzimaju sa steka, adresa vrha steka biće smanjena za jedan pri svakom
čitanju podatka. Neka je, na primer, stek prazan: vrh steka je na adresi 0. Pri svakom upisu podatka, podatak se
upisuje na vrh steka, a adresa vrha se uvećava za jedan, tako da vrh steka uvek ukazuje na praznu lokaciju u
koju će biti upisan sledeći podatak. Sa druge strane, pri svakom čitanju podatka, podatak se uzima iz lokacije
koja se nalazi odmah ispod vrha steka, na adresi za jedan manje od adrese vrha steka. Sledeći ovu logiku, znamo
da je za RAM memoriju kapaciteta 2n reči stek prazan ako je vrh steka na adresi 0, a pun ako je vrh na adresi 2n-
1. Uočimo da se lokacija sa adresom 2n-1 nikada ne koristi za smeštanje podatka, već samo za određivanje da li
je stek prazan. Iako se na ovaj način gubi jedna od 2n raspoloživih reči RAM memorije, opisani pristup značajno
pojednostavljuje izlaznu logiku.
Na Sl. 4-84 je prikazana realizacija steka koja koristi RAM memoriju kapaciteta 1K (2 10) i dva brojača koji
ukazuju na vrh steka i prvu lokaciju ispod vrha. Uočimo da su ulazi i izlazi i operacije steka identične kao na Sl.
4-83. Kao što se vidi sa Sl. 4-84(d), stek čine: dva 10-bitna brojača, jedan 10-bitni multiplekser 2-u-1, 1K RAM,
upravljačka i izlazna logika. Dva brojača, nazvana Top i Top-1, razlikuju se za 1, i oba se uvećavaju za jedan pri
svakoj push operaciji, a umanjuju za jedan pri pop operaciji. Pri operaciji push, adresa RAM-a je sadržaj brojača
Top, dok pri operaciji pop, adresa RAM-a je sadržaj brojača Top-1.
Polazeći od prethodnog razmatranja, u mogućnosti smo da konstruišemo tabelu upravljanja koja je prikazana na
Sl. 4-84(c) koja sadrži vrednosti svih internih signala koji upravljaju brojačima, multiplekserom i RAM
memorijom kako pri push i tako i pri pop operaciji. Na osnovu ove tabele, možemo izvesti sledeće Bulove
jednačine za upravljačku logiku:
E = CS = Enable
S = RWS = (Push/pop)’Enable
D = (Push/pop)Enable
Izlaznu logiku čine dva gejta koja ukazuju kada je stek pun, odnosno prazan. Pošto je stek prazan uvek kada je
sadržaj brojača Top jedak 0, da bi se detektovao uslov Empty koristi se 10-ulazno NOR kolo čiji ulazi su
povezani na izlaze brojača Top. Slično, stek je pun uvek kada brojač Top sadrži sve jedinice, što se detektuje 10-
ulaznim AND. Šematski prikaz strukture steka zasnovanog na RAM memoriji prikazan je na Sl. 4-84(d).

204
 Push/
pop Enable Operacija Kontrola Kontrola Kontrola
X 0 Bez Push/ mux-a mem. broj.
promene pop Enable S CS RWS D E
0 1 Upis
X 0 X 0 0 X 0
(push)
1 1 Čitanje 0 1 1 1 1 0 1
(pop) 1 1 0 1 0 1 1

(a) (b) (c)

(d)
Sl. 4-84 Realizacija steka na bazi RAM memorije: (a) Simboličko rešenje; (b) Tabela operacija; (c) Tabela
upravljanja; (d) šematski prikaz.

205