A R H I T E K T U R A M I K R O S I S T E M Aes.elfak.ni.ac.rs/am/Materijal/Predavanja/AMS07.pdf · osnovu digitalnog projektovanja čini Bulova algebra i teorija konačnih automata,

A R H I T E K T U R A M I K R O S I S T E M A

- Materijal za pripremu ispita - SMER: Elektoronska kola i sistemi, IV semestar

Godina: 2006

2

S A D R Ž A J

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

3

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

4

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,

5

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

6

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.

7

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:

8

Nivo apstrakcije Bihejvioralna reprezentacija

Strukturne komponente Fizički objekti

Tranzistorski nivo Diferencijalne jednačine, U-I dijagrami

Tranzistori, otpornici, kondenzatori

Analogne i digitalne ćelije

Nivo gejtova Logičke funkcije, konačni automati

Logička kola, flip-flopovi Moduli, funkcionalne jedinice

Registarski nivo (RTL)

Algoritmi, dijagrami toka, ASM dijagrami

Sabirači, komparatori, registri, brojači, multiplekseri

Čipovi

Sistemski nivo Izvršna specifikacija, programi

Procesori, kontroleri, memorije, ASIC kola

Štampane ploče, 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

9

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

10

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.

11

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.

12

RTLopis Testbenč

Sinteza Simulacija

Netlista Datotekakašnjenja

Raspoređivanje i povezivanje

Konfiguracionifajl

Datotekakašnjenja

Programiranjekomponente

Simulacija

Simulacija/Vremenska

analiza

Sinteza Fizičko projektovanje Verifikacija

FPGAčip

1

3

1

2

5

4

6

7

8

Proces DatotekaLegenda:

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

13

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.

14

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.

15

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.

16

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

17

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:

18

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

19

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.

20

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

21

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

22


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

23

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)

24

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

25

˝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 -1038 do +1038. (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;

26

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

27

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

28

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

29

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

30

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.

31

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΄

32

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

33

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

34

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

35

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.

36

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.

37

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

00 0001 01 0010 10 0100

1

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

38

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

39

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;

40

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

NOR, XOR, XNOR STD_LOGIC, STD_ULOGIC, STD_LOGIC_VECTOR, STD_ULOGIC_VECTOR, INTEGER, SIGNED, UNSIGNED

Aritmetičke operacije

+, -, *, /, ** (mod, rem, abs)●

Svi prethodni

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

d΄HIGH d΄LEFT d΄RIGHT d΄LENGTH d΄RANGE d΄REVERSE_RANGE

najmanji indeks vektora najveći indeks vektora krajnji levi indeks vektora krajnji desni indeks vektora veličinu (dužinu) vektora opseg vektora opseg vektora u obrnutom redosledu

Za nabrojive podatke d΄VAL(pos) ● d΄POS(pos) ● d΄LEFTOF(vrednost) ● d΄VAL(vrsta, kolona) ●

vrednost sa navedene pozicije pozicija navedene vrednosti vrednost sa pozicije levo od navedene vrednosti vrednost sa navedene pozicije

Za signale s΄EVENT s΄STABLE s΄ACTIVE ●

TRUE ako se na signalu desio događaj TRUE ako se na signalu nije desio događaj TRUE ako je s = ΄1΄

41

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.

a

b

c

d

MUX y

s1 s0

y

a

b

c

d

s1

s0

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

42

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

43

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

44

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.

Dekoder2-u-4

e

d0 y0

y1

y2

y3

d1

e d1 d0 y3 y2 y1 y0

1 0 0 0 0 0 11 0 1 0 0 1 01 1 0 0 1 0 01 1 1 1 0 0 00 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;

45

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


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.

a

b

c

d

Dekoder3 2 1 0

sel(1:0)

y

00011011

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

46

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


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;

47

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.


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.

48

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

49

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

Aritmetička

1000 y <= NOT a Komplement a 1001 y <= NOT b Komplement b 1010 y <= a AND b I 1011 y <= a OR b ILI 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

Logička

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

50

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

51

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

52

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.

53

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

54

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

55

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 FF D FF D FF D FFd

clk

q

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

56

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.

57

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;

58

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.

BR

OJA

C

clk

cifra2

cifra1

ab

cd

e

f g

7-seg. displej

a b c d e f g

rst Sl. 2-30 Sprega 2-cifarskog BCD brojača i 7-segmentnog displeja.

59

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:

60

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

61

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)

+

a

b

cin cout

s

FA

a7 b7

s7

FA

a1 b1

s1

c7 c2 c1FA

a0 b0

s0

c0c8

(cin)(cout). . .

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

62

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

mux

inp(6)

mux

inp(5)

mux

inp(4)

mux mux

inp(2)

mux

inp(1)

mux

inp(0)

mux

inp(3) ‘0’inp(7)

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

shift

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

63

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:

64

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

sel x y sel x y sel x y 00 a 0 00 a 0 00 a 0 01 b 1 01 b 1 01 b 1 10 c 10 c y 10 c X 11 d 11 d y 11 d X

a

b

c

dy

sel(1:0)

x

y

sel(1)sel(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

65

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


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.

66

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

67

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.

68

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

raspoloživa sve do završetka procesa, funkcije ili procedure)

Promena vrednosti je trenutna (nova vrednost se može koristiti sledećoj naredbi)

Koristi se u Paketu, entitetu i arhitekturi. U entitetu, svi portovi su signali.

Isključivo u sekvencijalnom kôdu.

69

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 FF

d q

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.

70

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ÉVENT …˝ 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.

D FF

D FF

out1

out2

out3

clk

a

b

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

PROCESS(clk,a) BEGIN IF(clk’EVENT AND clk=’1’)THEN out1 <= v; out2 <= a; END IF; out3 <= a; END PROCESS;

71

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 FF

D FF

q

not_q

clk

d

D FF

q

not_q

d

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;

72

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.

73

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

74

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;

75

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

S0

S1 S2

0/1

1/1

1/0

0/1

0/1

1/01/0

Kombinaciona logika

Sekvencijalna logika

(flip-flopovi)

ulaz izlaz

pr_state nx_state

rstclk

FSM

izlazulaz

stanje

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

76

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 Nn 2log= .

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.

77

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

78

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

79

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;

80

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

81

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

82

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

S0

D5D10 / K=0, V=0

S5

D5D10 / K=0, V=0

S10

D5D10 / K=0, V=0

D10 / K=1, V=0

D5 / K=0, V=0D5 / K=0, V=0

D5 / K

=1, V=0

D10 / K

=1, V

=1

FSM

clk rst

D5

D10

K

V

rst

D5 / K

=0, V

=0

(a) (b)

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

83

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 105DD 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;

84

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

85

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

86

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

87

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


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 Nn 2log= . (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.

88

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

89

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.

90

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.

BJstart

a b

clk

rst kraj

regB <- 0regA <- a

S0

start

regA <- regA >> 1

regA=0

regA(0)

regB <- regB + 1

Kraj

S1 S2

0

1

0

1

da

ne

(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

91

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;

92

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.

93

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.

94

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.

95

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.

96

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:

97

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

98

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;

99

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.

x

y

ab

cd

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

100

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

101

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

102

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)

103

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.

104

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

Aritmetička

1000 y <= NOT a Komplement a 1001 y <= NOT b Komplement b 1010 y <= a AND b I 1011 y <= a OR b ILI 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

Logicka

(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",

105

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

106

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-

107

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

108

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;

109

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:

110

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

111

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;

112

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

113

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.

114

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;

115

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;

116

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

117

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.

118

3 RTL projektovanje

3.1 Projektovanje odozgo-naniže Postoje dva osnovna pristupa rešavanju problema: ödozdo-naviše¨ (bottom-up) i ödozgo-naniže¨ (top-down). Kod pristupa ödozdo-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 ödozgo-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 ü 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 ödozgo-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 ödozgo-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 ödozgo-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)

119

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.

DIGITALNI SISTEM

...

...

...

...

statusni/upravljacki

ulazi

ulazipodataka

statusni/upravljacki

izlazi

izlazipodataka

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. ízrač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

10

Blokovi stanja, grananja i uslovnog izlaza koji

realizuju izracunavanje kolicnika. (ova stanja ne

postavljaju signal rdySEKVENCIJALNI

DELITELJ

start

x

rdy

qy

rdy

start

(a) (b)

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

120

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, öblak¨ 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 öblaku¨ 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)

121

..

..

..

..

..

..

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

122

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.

123

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:

124

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

125

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.

PASIVNOr1 <- xr2 <- 0

rdy

start10

r1 >= y1

0 r1 <- r1 - y

C1

r1 >= y

r3 <- 0

0 1

N3

r3 <- r2

C3

r2 <- r2 + 1

C2

PASIVNOr1 <- xr2 <- 0

rdy

start10

r1 >= y1

0 r1 <- r1 - y

C1

r1 >= y

r3 <- 0

0 1

N3

r2 <- r2 + 1r3 <- r2

C23

(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

126

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.

127

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.

128

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.

BRZINA=3

ZELENO

ZUTO

CRVENO

STOPBRZINA=1

BROJAC<-BROJAC+1

STOPBROJAC<-BROJAC+2

BROJAC /= 0

0

1

NAPUSTI

OSTANI

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

129

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.

130

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.

131

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.

132

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

133

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.

(-)r1

y12

12

12 ldr1

r2

clrr2 incr2

r3

ldr3

x/y12 12

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.

ALUr1y

1212

12 ldr1

r2

clrr2 incr2

r3

ldr3

x/y12 12

0

112

12x

muxctrl

4aluctrl

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

134

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

135

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


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

ldr1aluctrl = 'PROPUŠTANJEmuxctrl = 0SPREMAN

start10

clrr2

ldr1aluctrl = 'ODUZIMANJEmuxctrl = 1

INIT

TEST

incr2

C1r1gey

1

0

C2

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


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

136

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 üpravljač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

137

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

138

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;

139

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

140

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

141

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

A B Q140 : 9 = 15 9---- 50- 9---- 5 <- R

A B Q10001100 : 1001 = 1111-1001----- 10001-1001----- 10000-1001-----

01110-1001

------ 0101 <- R

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

5) 00010001 00000000-00001001 <- B--------

00001000 00000000 00000011

6) 00010000 00000000-00001001 <- B--------

00000111 00000000 00000111

7) 00001110 00000000-00001001 <- B--------

00000101 00000000 00001111 (a) (b) (c) R = 0; for C = 0 to N-1 do (R,A) = (R,A) << 1; if(R ≥ B) then QC = 1; R = R - B; else QC = 0; end if; end for;

R = 0; for C = 0 to N-1 do (R,A) = (R,A) << 1; if(R ≥ B) then Q = (Q << 1)1; R = R - B; else Q = (Q << 1)0; end if; end for;

R = 0; C = N-1; do (R,A) = (R,A) << 1; if(R ≥ B) then Q = (Q << 1)1; R = R - B; else Q = (Q << 1)0; 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.

142

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.

143

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

144

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

rdyeb; la; ea; lc; ec

start

lr; er

er; ea

ec

cout

eqeq; rsel; lr; er

z

SHRA

INCR

1 0

0 1

1

0

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

145

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

146

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

147

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.

148

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

PASIVNO

rdyeb; lb; eq; lq; ec; lc;

start

er; lr;

ec;r0sel

cout

eq; er; rsel;lr;

z

AKTIVNO

1 0

0 1

1

0

eq;er;

PASIVNO

rdyeb; lb; lq; lc;

start

er; lr;

ec;r0sel;

er;

cout

rsel;lr;

z

AKTIVNO

1 0

0 1

1

0

eq=ec=1

(a) (b)

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

149

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

150

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

151

Na primer, razmotrimo funkciju f zadatu skupom decimalnih indeksa ∑ )5,3,2,0( . 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 ∑ )5,3,2,0( : (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 = 24 ×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.

152

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.

153

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 (212 – 1)/(24 – 1) = 273.

154

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)

s

w0

w1

f

s

w0

w1 f

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

155

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.

mux

2xm

-u-m

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.

156

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

157

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

158

4.1.4 Koderi Binarni koder 2n-u-n (Sl. 4-19) kodira (transformiše) informaciju od 2n 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.

159

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.

Prioritetni koder 2n-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 = ii wwww nn'

1'

22'

12 −−−K , 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.

160

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

161

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×24 + 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:

162

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.

n-bitni sabirač

y1 y0

c0c4 1

y3 y2x1 x0x3 x2

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.

163

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:

>

=inace

lgjeakoG

01

=

=inace

lgjeakoE

01

<

=inace

lgjeakoL

01

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.

K3

4X(3)

4Y(3)

G E L

K2

4X(2)

4Y(2)

K1

4 4

K0

4 4X(1) Y(1) X(0) Y(0)

K4

G E LG E LG E L

g3 g2 g1 g0 l0l1l2l3

4 4

x y

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-

164

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.

165

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.

166

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

x y Prenos

cx21 Suma 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 210=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

167

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.

168

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

169

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

170

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 –(2n-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 = 2n-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.

171

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 = 2n-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.

172

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

173

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 SubAdd / (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 SubAdd / . Izlazi XOR gejtova predstavljaju Y, ako je

SubAdd / =0, odnosno Y’, ako je SubAdd / =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 SubAdd / 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

174

se desiti da rezultat bude veći od 2n-1-1, ako su oba sabirka pozitivna, odnosno, manji od -2n-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.

175

FA

xn-1

yn-1

sn-1

cn

FA

x1

y1

s1

c2

FA

x0

y0

s0

c1c0

cn-1 . . .

MSBpozicija

LSB pozicija

FA

xn-2

yn-2

sn-2

cn-2

Pozicijaznaka

Prekoračenje

Add/Sub

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

176

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

177

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.

178

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

179

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.

180

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.

SH SLck

Xn-1...k Yn-1...k Xk-1...0 Yk-1...0

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

SH1 SH0 SL

Xn-1...k Yn-1...k Xn-1...k Yn-1...k Xk-1...0 Yk-1...0

MUX

01

01S

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

ck

(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

181

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.

182

AE

x3 y3

FA

f3 f2

c3

f1 f0

LE

a3 b3

x2 y2

FAc2

a2 b2

x1 y1

FAc1

a1 b1

x0 y0

FA c0

a0 b0

c4

AELE AELE AELE

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

183

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

184

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

∑−

−=

×=1

2)(n

ki

iibBV

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

185

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.

186

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

187

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

≤±×>×±=

−−

−−

2121

2121

,,

12

21

EEjeakoMRMEEjeakoRMMM EE

EE

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.

188

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


189

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


Detekcija vodećih nula

i pomerač

M E

M1 M2 E2E1

potkoracenjeprekoracenje

Oduzimanje eksponenta i deljenje mantisa

Postnormalizacija

Sl. 4-64 Deljenje u pokretnom zarezu.

190

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

SR

S Q

R Q’

S R Q(next)

0 0 Q0 1 01 0 11 1 ND

Q(next) = S + R’Q sa ograničenjem SR=0

Q Q(next) S R

0 0 0 X 0 1 1 0 1 0 0 1 1 1 X 0

JK

J Q

K Q’

J K Q(next)

0 0 Q0 1 01 0 11 1 Q’

Q(next) = JQ + K’Q

Q Q(next) J K

0 0 0 X 0 1 1 X 1 0 X 1 1 1 X 0

D

D Q

Q’

D Q(next)

0 01 1

Q(next) = D

T

T Q

Q’

T Q(next)

0 Q1 Q’

Q(next) = TQ’ + T’Q

Sl. 4-65 Tipovi flip-flopova.

191

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

D

T

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

192

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

Registar

Q3 Q2 Q1 Q0

D3 Q3 D2 Q2 D1 Q1 D0 Q0

Q3 Q2 Q1 Q0

Clk

I3 I2 I0

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

193

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

194

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.

S0 IL I3 I2 I1 I0 IR

S1 Pomerački registar

Q3 Q2 Q1 Q0

Sledeće stanje

S1 S0 Q3 Q2 Q1 Q0

0 0 Bez promene

IL Q3 Q2 Q1

0 1

1 0

1 1

Operacija

Par. upis

Pomeranje na levoPomeranje na desno

Q3 Q2 Q1 Q0

I3 I2 I1 I0

Q2 Q1 Q0 IR

(a) (b)

195

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

196

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

DE Obostrani brojač

Clear Q3 Q2 Q1 Q0 0 X Bez promene1 0 Brojanje naviše1 1 Brojanje naniže

E D Operacija

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

DE Obostrani brojač

Load Q3 Q2 Q1 Q0

0 0 X Bez promene0 1 0 Brojanje naviše0 1 1 Brojanje naniže1 X X Paralelni upis

Load E D Operacija

(a) (b)

197

HAS

1 0 mux

D3 Q3

Q3'

HAS

1 0 mux

D2 Q2

Q2'

HAS

1 0 mux

D1 Q1

Q1'

HAS

1 0 mux

D0 Q0

Q0'

Clk

Load

E

D

Q3 Q2 Q1 Q0Izlazni prenos

I3 I2 I1 I0

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

198

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

199

RFC RFC RFC RFC

RFC RFC RFC RFC

RFC RFC RFC RFC

RFC RFC RFC RFC

Dekoderza upis2-u-4

Dekoder za čitanje2-u-4

I3 I2 I1 I0

B3 A3

WA1 WA0 WE

0

1

2

3

0

1

2

3

RAB1 REB

Dekoder za čitanje2-u-4

0

1

2

3

RAB0 RAA1 REARAA0

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

200

(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

201

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/ write Enable Operacija R/W Enable S D E

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.

202

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.

Read/ write Enable Operacija Read/

write Enable S CS RWS E

(Početak) E

(Kraj)

X 0 Bez promene X 0 X 0 X 0 0

0 1 Čitanje 0 1 1 1 0 1 0

prazno

podatak

podatak

podatak

prazno

prazno

. . .

0

1

2

1021

1022

1023

Početak

Kraj

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.

203

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

Push/ pop

Enable Operacija

X 0 Bez promene

0 1 Upis (push)

1 1 Čitanje (pop)

Kontrola pom.

registra

Kontrola brojača Push/

pop Enable S1 S0 D E X 0 0 0 X 0 0 1 1 1 0 1 1 1 1 0 1 1

Izlazi brojača

Q2 Q1 Q0 Empty Full 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 1 0 0 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.

204

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

205

Push/ pop Enable Operacija

X 0 Bez promene

0 1 Upis (push)

1 1 Čitanje (pop)

Kontrola

mem. Kontrola

broj. Push/ pop Enable

Kontrola mux-a

S CS RWS D E X 0 X 0 0 X 0 0 1 1 1 1 0 1 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.

Documents

A R H I T E K T U R A M I K R O S I S T E M Aes.elfak.ni.ac.rs/am/Materijal/Predavanja/AMS07.pdf · osnovu digitalnog projektovanja čini Bulova algebra i teorija konačnih automata,