Hovedoppgave av Jan Jakobsen

Hovedoppgave
av Jan Jakobsen
Institutt for Fysikk
Universitetet i Oslo

Innholdsfortegnelse
Innledning ................................................................................................................................ 4
Problemstilling.................................................................................................................... 4
Nummer representasjon .................................................................................................... 4
Filterbeskrivelser................................................................................................................. 5
Ulike typer design ................................................................................................................... 8
Bitparallell aritmetikk ........................................................................................................ 8
Bit seriell aritmetikk ........................................................................................................... 8
Fordeler og ulemper........................................................................................................... 8
Om digitale filtre ................................................................................................................... 10
Design av filtre .................................................................................................................. 10
Spesifisering.................................................................................................................. 10
Aproksimering ............................................................................................................. 10
Ulike filterstrukturer/realisering .............................................................................. 10
Direkte form 1.......................................................................................................... 10
Direkte form 2.......................................................................................................... 11
Kaskadeform............................................................................................................ 12
FIR Lattice................................................................................................................. 13
IIR-filtre................................................................................................................................... 14
Standard Z-transformering ............................................................................................. 15
Billineær Z-transformering.............................................................................................. 15
Stabilitet.............................................................................................................................. 16
FIR-filtre.................................................................................................................................. 18
Vindu metoden ................................................................................................................. 19
Frekvensvinduer............................................................................................................... 21
Minimax ............................................................................................................................. 21
Bitserielt bibliotek.................................................................................................................. 22
Seriell arkitektur. .............................................................................................................. 22
Tallrepresentasjon............................................................................................................. 22
ABSOLUTT........................................................................................................................ 23
ADDER............................................................................................................................... 25
SUBTRAKT........................................................................................................................ 28
DSHIFT............................................................................................................................... 30
MSHIFT.............................................................................................................................. 32
ORDER ............................................................................................................................... 33
FORMAT1TO2 .................................................................................................................. 37
FORMAT 3TO1. ................................................................................................................ 38
LIMIT.................................................................................................................................. 40
MULTIPLY......................................................................................................................... 43
Usignert multiplikasjon .............................................................................................. 43
Multiplikasjon med signert koeffisient ..................................................................... 44
Multiplikasjon med signert data og koeffisient. ...................................................... 49
Avrundingsmultiplikator ........................................................................................... 51
Seriell/seriell multiplikator........................................................................................ 52
2

Dobbelpresisjonsmultiplikator. ................................................................................. 56
Implementering. .................................................................................................................... 61
IIR filter. ............................................................................................................................. 61
FIR filtre. ............................................................................................................................ 63
Multiplekset FIR filter. ..................................................................................................... 66
Test av filtere . ................................................................................................................... 69
Konklusjon.............................................................................................................................. 73
Litteratur................................................................................................................................. 74
3

Innledning
Problemstilling
Lage ett sett med kretser basert på bitseriell arkitektur. Kretsene skal modelleres i
maskinvaremodelleringsspråket verilog. Verilog modulene skal være parametriserbare og med
et veldefinert grensesnitt. Modulene utgjør de mest brukte funksjonene i digital
signalbehandling. Målet med å lage dette funksjonsbiblioteket er å forenkle arbeidet med å
lage vilkårlige bitserielle kretser. Funksjonene skal kunne brukes i ett
maskinvaremodelleringsspråk omtrent som funksjoner i for eksempel C .
Stadig raskere digitale kretser vil i mange tilfeller muliggjøre en filter-realisering med
bitseriell arkitektur. Denne arkitekturen er mindre arealkrevende enn en vanlig parallell
arkitektur og større funksjonalitet kan derfor legges inn på en enkelt brikke. Med minkende
transistorer får også parallelle kretser problemer med kommunikasjon internt i brikken og
mellom brikken og omverdenen 1 .Tidligere var bitseriell arkitektur vanligere pga. høy pris på
maskinvare og liten plass på brikkene. I dag er prisen på maskinvare lav og parallelle
arkitektur dominerer. I programmerbare kretser, FPGA, er plassen liten og en seriell arkitektur
vil være ypperlig å bruke i disse 2 .
Størstedelen av arbeidet med denne oppgaven er lagt i å utvikle ett sett med bitserielle kretser
som utfører de vanligste operasjonene i ett digitalt filter design og å simulere noen filtre som
er realisert med disse. Denne oppgaven er dermed to-delt. I den første delen drøfter jeg
generell teori om digitale filtre frem til implementeringen av filtrene. I den andre delen tar jeg
for meg bitseriell design, med hovedvekt på utviklingen og simuleringen av det bitserielle
biblioteket. Disse delene knyttes tilslutt sammen i implementeringen av noen filtre.
Den første delen av oppgaven er delt opp i fire avsnitt:
-Definerer og klargjør noen begreper.
-FIR-filtre.
-IIR-filtre.
-Ulike filterstrukturer.
Jeg har valgt å skrive om FIR og IIR hver for seg fordi de er veldig forskjellige, både i hvilke
egenskaper de har og hvordan de utvikles.
Nummer representasjon
For binærkodet aritmetikk er det flere mulige nummerrepresentasjoner, 'signed magnitude' og
1' komplement er mulige, men de har ikke en unik definisjon av null og dette vil komplisere
operasjoner som addisjon og subtraksjon 3 . Det vanligste er å bruke 2'komplement
representasjon. Dette har ett unikt nullpunkt og signert addisjon og subtraksjon kan behandles
likt som usignert addisjon og subtraksjon. En annen viktig egenskap med denne
representasjonen er at den er tolerant for overflyt i addisjon og subtraksjon, så lenge det
endelige resultatet ligger innenfor det tillate dynamiske
området 4 .

Ett tall representert i 2'komplement er definert til å ligge mellom -1 og 1.
n1 X x x0
i
1
Der n er antall bit som skal brukes i representasjonen.
X0 kalles heretter fortegnsbiten eller MSB 'Most Signifficant Bit', x(n-1) kalles LSB 'Least
Signifficant Bit'.
Den mest signifikante bit'en har negativt fortegn mens de resterende er positive.
En ulempe med denne representasjonen er at en total konvertering (positiv til negativ) blir
mer komplisert. 5 Alle bitene må inverteres og en må legges til på LSB. Dette kan gjøres med
SUB-kretsen, som jeg skal vise senere.
Filterbeskrivelser
xi 2 i
De filtrene jeg skal beskrive her er alle tidsinvariante og linære. Det finnes mange måter å
beskrive slike filtre, det vanligste er ved impulsresponsen h(t). Det kan vises at
impulsresponsen til ett filter, beskriver filteret fullstendig. Hvis impulsresponsen først er
kjent, kan responsen til ett vilkårlig signal u(t) finnes ved konvulsjon 6 :
Y( t)
u( T)
m m(
t T)
dT
Y(t) = Int[u(tt) m(t-tt)] , for det kontinuerlige tilfellet.
Y( n)
u( m)
h h(
n m)
m
Y(n) = Sum[u(n) h(m-n)], for det diskrete tilfellet.
Ofte skrives konvulsjon bare som y = h*u.
Konvulsjon er en vanskelig prosess å utføre, derfor foretrekkes en beskrivelse av filteret i
frekvensdomenet. En konvulsjon i tidsdomene er en enkel multiplikasjon i frekvensdomenet:
5

L[y] =L[h*u] = H(s)U(s).
H(z) kalles systemets overføringsfunksjon og den gir en enkel sammenheng mellom
utgangssignal Y(z) og inngangssignal U(z) til filteret:
Y(z) = H(z) U(z).
Med en beskrivelse av filteret på formen H(w) eller H(z) er det enkelt trekke ut opplysninger
om frekvensresponsen til filteret. Mesteparten av metodikken i signalbehandling er derfor
konsentrert om denne beskrivelsen.
Beregninger på filtre gjøres altså i frekvenssdomenet og den klassiske overgangen mellom
tids og frekvensdomenet er fourieranalyse. Det er to typer fourieranalyse, DFT, diskret
fouriertransformering for diskrete signaler (digitale) og CFT, kontinuerlig
fouriertransformering, for kontinuerlige (analoge) signaler. Det kan vises at
Laplacetransformasjon er en generalisering av CFT og Z-transformasjon er en generalisering
av DFT. Digitale filtre vil jeg altså beskrive i Z-domenet, i denne oppgaven. Filtere i sdomene
kommer jeg bare til å drøfte i forbindelse men IIR-filtre.
Digitale filtre beskrives, på generell form, i tidsdomenet med det som kalles standard
differenslikningen:
y(k)+a1y(k-1)++any(k-1) = b0u(k)+b1y(k-1)++bnu(k-n).
I z-domenet kan dette skrives som:
H(z) = sum[ajz^-j]/(1+sum[bjz^-j]).
Alternativt kan vi skrive det ut som:
H(z) = Y(z)/U(z)
Y(z) = U(z)sum[aj^-j] - Y(z)sum[bjz^-j].
Hvis minst en ai og en bi er ulik null, er filteret ikke bare avhengig av nåværende og tidligere
inngangsdata U(), men også av tidligere utgangsdata Y(). Dette er ett rekursivt filter eller IIR.
IIR 'Infinite Impulse Respons' betyr at ett signal, i teorien, aldri vil dø ut i filteret. Denne
tilbakeføringen er det som kan gi ustabilitet i filteret og dette må tas hensyn til i design av
denne type filtre.
Hvis derimot alle bi er null, er filteret ikke-rekursivt eller FIR. Utgangen er bare avhengig av
nåværende og N tidligere inngangsdata. FIR 'Finite Impulse Respons' betyr at ett signal i
filteret tilslutt vil dø ut, da det ikke er noen tilbakeføring.
FIR og IIR er de to hovedklassene av filtere. IIR kan sees på som en digital ekvivalent til
6

analoge filtre og i design av IIR brukes vanligvis ett analogt filter som utgangspunkt. Som for
analoge filtre har H(z) til ett IIR-filter poler og det er derfor viktig å passe på å velge filter
koeffisientene ai og bi, slik at filteret blir stabilt. FIR-filteret har ikke noen analog ekvivalent,
overføringsfunksjonen H(z) har ingen poler og er derfor garantert stabilt. FIR-filtre har som
oftest gode fase-egenskaper. Ulempen med FIR-filtre er at det trengs ett stort antall ledd for å
få en skarp frekvensrespons.
7

Ulike typer design
Kretser kan realiseres på ulik måte, bitseriell, digitseriell og parallell. Bitseriell arkitektur
prosesserer en bit hver klokke syklus, digitseriell prosesserer ett bestemt antall biter av et ord
per klokke syklus og parallell arkitektur prosesserer hele ordet i en klokke-sykel.
Bitparallell aritmetikk
Inngangene og utgangene er busser ett ord brede, og i teorien skal alle bitene prosesseres
samtidig og alle bitene kommer til utgangen samtidig 7 .
Siden alle bit-ene prosesseres samtidig må prosesserings elementene gjøre mye arbeid per
klokke syklus og klokkehastigheten begrenses. I praksis må bitene ofte prosesseres
sekvensielt likevel, for eksempel i ett addisjonselement hvor resultat biten avhenger av
resultatet av biter med lik eller mindre signifikans. Dette gir opphav til en forsinkelse som i
sin tur begrenser klokke hastigheten. Det er mulig å bruke ulike teknikker for å minske dette
problemet, for eksempel med 'carry look ahead', 'carry save' logikk osv. Felles for disse er at
de krever mer logikk og dermed større areal. En addisjon i parallell logikk må realiseres med
en rekke 'full addere' FA, like mange som det er bit i ordet og med en mente logikk som
forbinder dem. Parallell multiplikasjon gjøres på samme måte som når man multipliserer for
hånd, et array av addere og AND porter danner de partielle produktene og legger dem
sammen. For å danne produktet A*B, trengs det en diagonal med FA og en AND port for hver
ny bit av A og en ny rekke FA for hver ny bit av B. For en m-bit *n-bit multiplikator trengs
det (m-1)n FA. Multiplikasjons tiden avhenger av tiden menten bruker ti å bevege seg
gjennom arrayet.
Bit seriell aritmetikk
Inngangene og utgangene et en bit bred. Signalene går altså på enkelt ledninger. En bit
prosesseres av gangen, vanligvis LSB først 8 . Alle bitene passerer gjennom den samme
logikken og dette sparer enormt mye plass. Etterfølgende ord vil vanligvis komme rett etter
hverandre uten pause. Bit seriell arkitektur krever kontroll signaler c1, for å markere
ankomsten av LSB gjennom alle aritmetiske operasjoner.
Operasjonene er ukompliserte fordi det er få bit som skal prosesseres per klokke syklus og
den kombinatoriske veien er kort. Dette tillater en veldig høy bitrate. Det er denne høye
bitraten som gjør at den totale beregningstiden er sammenlignbar med beregningstiden i
parallelle strukturer.
En seriell addisjonskrets adderer to bit av gangen av tar vare på menten for å bruke den i neste
klokke syklus. En klokke for å markere begynnelsen på ett nytt ord c1, trengs for å nullstille
DFF hvor menten lagres. Se fig.10. En seriell multiplikasjonskrets er mer komplisert fordi alle
bitene i A må multipliseres med alle bitene i B. I denne oppgaven har jeg sett på flere ulike
typer multiplikatorer. Seriell-seriell, hvor begge tallene kommer seriellt til multiplikatoren og
parallell-seriell, hvor det ene ordet kommer serielt og det andre i parallell form, noe som er
nyttig i flere typer filtre.
Disse serielle multiplikatorene kan ikke behandle 2' komplementære tall direkte, slik som en
parallel Booth multiplikator, men det er måter å få dette til på som jeg skal vise senere.
Fordeler og ulemper
Parallell og seriell arkitektur er på mange områder fundamentalt forskjellig og dette viser seg i
deres respektive fordeler og ulemper.
8

-Arealbruk
Bitseriell arkitektur kan gi større funksjonalitet på ett begrenset areal. En tilsvarende
funksjonalitet utført med paralell logikk vil ta mye større plass.
-Klokkehastighet
Klokkehastigheten for seriell arkitektur vil være mye høyere enn for parallell. Dette fordi
seriell arkitektur muliggjør mindre logikk per operasjon og ingen bruk av mentegjennomstrømnings
logikk.
-Gjennomstrømning (Throughtput)
Der serielle operasjoner krever WL (word lenght) klokkesykluser for å utføre en operasjon,
gjør en parallell operasjon det samme med en klokkesyklus. De bitserielle elementene
arbeider likt på hver bit i ordet, bare underlagt et kontrollsignal c1. De kan derfor lett
'pipelines', for å muliggjøre en høy klokkefrekvens og dermed stor gjennomstrømning.
-Ord lengde
Bitserielle systemer har en fastsatt ord lengde, det er heller ikke lett å operere med flere
ordlengder for intern representasjon. Dette er mye enklere å få til i kretser med en parallell
arkitektur.
-Tilgjengelighet
Verktøy for simulering og konstruksjon er lettere tilgjengelig for paralell logikk enn for
seriell. Det finnes mye mer litteratur om parallell logikk.
-Kommunikasjon
Intern og ekstern kommunikasjon er enklere i ett seriellt system enn for ett parallelt. Dataene
kommer på enkelt ledninger i stedet for på busser, dette gjør det enklere å rute på
brikken og kommunikasjonen med utenverden er ikke begrenset av antallet pinner på
brikken. Man får også en mer effektiv bruk av ledningene/banene ved å kjøre brikken på
høyest mulig hastighet.
-Effekt forbruk
Effektforbruket i en bitseriell arkitektur er høyere enn for en parallelle arkitektur, grunnene
til dette er raskere bevegelse av data. Maskinvaren utnyttes mer effektivt.
-FPGA
En parallell arkitektur innebærer brede busser på brikken, noe som legger beslag på mange
celler i en FPGA. Seriell arkitektur har overvekt av lokale forbindelser, og dette gjør den
ideell til bruk i FPGA kretser.
9

Om digitale filtre
I dette kapitlet skal jeg drøfte ulike typer digitale filtre og matematikken rundt disse. 6 Jeg
begynner med å beskrive ulike typer filtre, fordeler ulemper osv. Deretter klargjør jeg en del
begreper, for så å drøfte problematikken rundt det å realisere ett filter. Denne gjennomgangen
av filterteori er uavhengig av hvilken arkitektur som velges i implementeringen.
Digitale filtre skiller seg fra analoge filtre ved at:
Nøyaktigheten er helt bestemt av ord lengden og er ikke begrenset av usikkerheten i
komponentverdier.
-De er mer holdbare, komponentverdier i analoge filtre endres over tid.
-De er mere forutsigbare, FIR-filtre er for eksempel alltid BIBO stabile.
-De er 100% reproduserbare.
-De kan være programmerbare, for eksempel ved å laste ned nye filter koeffisienter.
Ulempen digitale filtre har over analoge, er forsinkelser i signalgangen, spesielt kan FIR-filtre
ha så store forsinkelser at de ikke egner seg til sanntidssignalbehandling.
Design av filtre
Arbeidet med å lage ett filter kan deles opp i fire deler:
-Spesifisering av en ideell overføringsfunksjon Hid(z).
-Aproksimering av en realiserbar overføringsfunksjon Hre(z) til H(ideel)(z).
-Realisering/valg av struktur.
-Implementering.
Spesifisering
Bestemmelse av filterets ideelle frekvensrespons, faserespons og andre spesifikasjoner som
største tillatte 'ripple' og 'overshot'.
Aproksimering
Aproksimerer den ideelle overføringsfunksjonen Hi(z), med en realiserbar H(z). H(z) må
tilfredsstille alle krav som er gitt i spesifikasjonen til filteret. Her er først steget å bestemme
seg for å bruke enten ett FIR-filter eller ett IIR-filter. Når filtertype er valgt, er neste steg å
approksimere det realiserbare til det ideele. Det finnes flere ulike approksimasjonsmetoder.
Aproksimasjonsmetodene går i praksis ut på a finne koeffisientene ai og bi i H(z).
Ulike filterstrukturer/realisering
Ett filter med overføringsfunksjon H(z) kan realiseres på mange forskjellige måter, jeg skal
her skissere noen 6 .
Direkte form 1
Uttrykkes H(z) som en differenslikning:
Y(n) = biX(n-i) - ai Y(n-i) ,
kan formen taes direkte fra likningen:
10

Fig 1.
Denne strukturen består av to halvdeler hvor resultatet legges sammen.
Direkte form 2
Uttrykkes H(z) som ett produkt av to overføringsfunksjoner H1(z) og H2(z):
H(z) = H1(z) H2(z) = [1/(1+biX(n-i))] [ai(n-i)]
H1(z) = W(z)/X(z) , H2(z) = Y(z)/W(z)
Uttrykt ved diff:
W(n) = X(n) -ai W(n-i) ,Y(n) = bi W(n-i)
Dette gir en struktur hvor de to halvdelene i som utgjør Direkte-Form I er byttet om. De to
grenene kan nå dele forsinkelseselementer og ett filter på denne formen utnytter derfor
maskinvaren mer effektivt.
Filteret kan nå realiseres direkte som i fig 2:
11

Fig 2.
Begge disse løsningene er enkle å implementere fordi filterets form kan finnes direkte av
diffrensiallikningen, og koeffisientene i multiplikatorene er identisk med koeffisientene i
likningene H(z).
Kaskadeform
IIR-filtre blir, som jeg skal vise senere, mer følsom for kvantiseringsfeil i koeffisientene når
filterets orden øker. Det er derfor vanlig å bryte ett IIR-filter ned i 1. og 2. ordens subfiltre.
Dette gjøres ved å faktorisere H(z) slik at H(z) kan uttrykkes ved en produktrekke:
H(z) = Hi(z)
Der Hi(z) er ett 1. eller 2. ordens ledd
Dette gir en kaskade struktur, som vist i fig . 3
Fig 3.
H(z) kan også deles opp i partielle fraksjoner, slik at H(z) kan uttrykkes som en sum av 2.
ordens polynomer:
(z) = Hi(z).
Dette gir en parallell struktur som i fig 4.
12

Fig 4.
I en parallell struktur er det likegyldig hvilken rekkefølge subfiltrene står i, mens i en seriell
struktur er rekkefølgen viktig. I begge tilfeller må det vurderes nøye hvilke røtter som skal
kombineres i subfiltrene. En filterseksjon med høy forsterkning øker behovet for skalering.
Økt skalering gir økt kvantiseringsfeil. For at forsterkningen i hver seksjon skal bli minst
mulig, bør nullpunktene og polene grupperes på en sånn måte at effekten av polene blir minst
mulig.
Størrelsen |H(z)| er forholdet mellom nullpunktsvektorene og polvektorene. Polvektorer som
ligger nær enhetssirkelen |z| = 1 blir små og gir derfor stor forsterkning. Reglen for gruppering
av poler og nullpunkter er da å velge nullpunkter som ligger nærmest polen, og å begynne
med den polen som ligger nærmest enhetssirkelen.
Rekkefølgen av subfiltrene i en seriell struktur er viktig. Plasseres det filterleddet med størst
forsterkning først, øker dette behovet for skalering. Plasseres det sist, vil det bidra til å
forsterke støyen fra alle tidligere filterledd og gi ett dårligere signal/støy forhold.
FIR Lattice
Ved hjelp av gjentatt rekursjon av H(z) kan vi få en struktur som vist nedenfor:
Fig 5.
hvor er figuren??
13

IIR-filtre
IIR-filtre kan sees på som den digitale ekvivalenten til analoge filtre, da de begge gjør bruk av
tilbakeføring 9 .
Alle filtre som er drøftet her er LSI (Linear Shift Invariant). De kan beskrives med deres
overføringsfunksjoner H(z). H(z) er forholdet mellom utgangen Y(z) og inngangen X(z):
H( z)
Denne er vanligvis reel og kan uttrykkes som forholdet mellom to polynomer:
H( z)
der er n er filterets orden.
Filterkoeffisientene aj og bj bestemmer filterets egenskaper.
I z-domenet er z^-n ensbetydende med en forsinkelse n, likningen ovenfor kan derfor
uttrykkes med differenslikningen:
aN y((n+N)T) + aN-1 y((n+N-1)T) +. a0 y(nT)=
bM x((n+M)T) + bM-1 x((n+M-1)T)+b0 x(nT).
Filterlikninger på denne formen er spesielt nyttige da de forteller noe om strukturen filteret
vil få.
Y( z)
X
( z)
b0 b1 z 1
.... bn z n
1 a1 z 1
.... a z n
....
Når ett digitalt filter designes, bestemmes først spesifikasjonene til det filtre man ønsker å
lage, dette kan være cuttoff frekvens, hvor 'skarpt' filteret skal være, største tillatte 'overshot',
faseresponsen osv. Vi kan kalle overføringsfunksjonen for dette ideelle filteret for Hid.
Utfordringen er nå å finne en realiserbar H(z) som er mest mulig lik Hid. Her finnes det flere
metoder og jeg skal beskrive to av dem, Standard Z-transformering og Bilineær Ztransformering.
IIR-filtre har poler og nullpunkter som ett analogt filter og det er derfor mulig å ta
utgangspunkt i analoge filtre. Dette er en todelt tilnærming, hvor det første steget er å velge et
analogt filter, med en overføringsfunksjon H(s), som er mest mulig lik overføringsfunksjonen
til det filteret vi ønsker, Hid. Steg to er å digitalisere dette filteret, for å danne en digital
overføringsfunksjon H(z). H(z) vil ha like mange poler og nullpunkter som H(s) (samme
orden). Fordelen med denne metoden er at vi kan ta i bruk en rekke kjente analoge filtere med
velkjente egenskaper, som feks. Butterworth og Chebychev.
Digitaliseringen av den analoge overføringsfunksjonen H(s) er ingen 'rett frem' prosedyre,
H(s) er ikke periodisk, mens H(z) er periodisk langs frekvensaksen w med periode ws.
14

H(s) er stabil i området til venstre for Im-aksen i s-planet, H(z) er stabil innenfor
enhetssirkelen |z| ws/2, er det digitale filteret identisk med det kontinuerlige, men dette
kravet er jo i praksis aldri oppfylt.
Generelt kan det sies at hvis filterets orden er stor og wcutoff

Eller motsatt:
Z = (1-s)/(1+s).
Det kan vises 6 at denne transformasjonen overfører hele den negative (og stabile) siden av splanet
til området innenfor enhetssirkelen i z-planet. Det er åpenbart at denne
transformasjonen vil føre til en forvrengning av frekvens-skalaen og det kan lages ett utrykk
for forvrengningen ved å sette s = jw inn i utrykket ovenfor:
jw = (e^jwT - 1)/(e^iwT + 1).
Utrykt ved det analoge filterets cutoff-frekvens wc og det digitale filterets cutoff-frekvens qc
og ved å anvende Eulers formel får vi utrykket:
wc = tan(qcT)/2 .
Dette utrykket er langt fra lineært. Frekvensen til den transformerte H(z) avviker sterkt fra det
linære når qc er en betydelig del av ws. Dette avviket må kompenseres for når H(z) skal
dannes med bilineær z-transformering. Ved kritiske frekvenser, for eksempel ved cutofffrekvensen,
er det mulig å 'pre-warpe' ved å sette wc = tan(qcT/2) inn i den analoge
prototypen.
Bilineær z-transformasjon er en algebraisk substitusjon som er lett å utføre. Den overfører
amplitude-frekvenskarakteristikken direkte, fra det analoge filteret til det digitale, men med en
forskyvning av frekvensaksen som resultat. Kritiske frekvenser forskyves med en forskyvning
som lett å beregne og som kan kompenseres med 'prewarping'.
Frekvensresponsen til det analoge filteret må kunne deles opp i områder der det er tilnærmet
konstant for at metoden med 'prewarping' skal kunne benyttes. Kan ikke H(s) deles opp i
områder på denne måten må standard z-transformasjon benyttes.
En annen metode for å tilnærme H(s) med en digital H(z) er å finne koeffisientene aj og bj ( i
polynomutrykket til H(z)) ved å numerisk tilnærme polynomene til H(s), og her finnes det ett
utall metoder og mye programvare er tilgjengelig for dette.
Stabilitet
Hvis polene er godt innenfor enhetssirkelen, er filteret stabilt. Hvis polene til H(z) ligger
nærme enhetssirkelen |z| =1, må vi være forsiktig så ikke kvantiseringsfeil flytter polene
utenfor det stabile området. Dette gjelder spesielt hvis IIR-filteret skal inngå som en del av ett
adaptivt filter, hvor koeffisientene kan forandres under kjøring. Risikoen for ustabilitet legger
16

føringer for filterkoeffisientene som det må taes hensyn til i designet av alle typer IIR-filtre 6 .
En måte å analysere dette på er å undersøke hvordan polene til H(z) beveger seg i z-planet,
når koeffisientene kvantifiseres med ulik nøyaktighet. Det kan lages ett mål på dette ved å
beregne forandringen i en pol dpi mot forandring i filter koeffisientene, dak.
H(z) kan faktoriseres og skrives som:
H( z)
n
1 ni z
i 0
1
1 pi z 1
p
Der ni er filterets nullpunkter og pi er filterets poler.
For ett filter realisert med direkte-form er filteret karakterisert med filterkoeffisientene ak og
bk og vi kan beregne den deriverte direkte:
dpi/dak = sum[dpi/dak]
og vi får ett uttrykk for dpi:
dpi = -sum[(pi^(-k+1) dak)/prod[(1-pjpi^-1)] (j |= i).
Denne likningen gir ett mål for polenes følsomhet i forhold til små forandringer i
filterkoeffisientene, dak.
Når polene til filteret ligger svært tett, går utrykket i nevneren (1-pj/pi) mot null og filteret blir
spesielt følsomt for kvantiseringsfeil. Det kan vises 6 at polene ligger tettere når forholdet w/fs,
der w er filterets virkeområdet og fs samplefrekvensen, blir mindre. Likningen ovenfor viser
også at polene blir mer følsomme jo høyere orden filteret har.
Høy samplefrekvens og høy orden øker altså kravet til nøyaktighet i filterkoeffisientene, det
er derfor ikke vanlig å realisere filteret i direkte form. Vanligvis deles filteret H(s), opp i
mindre subfiltre før digitaliseringen. Subfiltrene kan så settes sammen i kaskade eller parallell
form.
17

FIR-filtre
FIR-filtre er en klasse av digitale filtre som ikke benytter seg av tilbakeføring, det er altså ett
ikke-rekursivt filter. En impuls på inngangen, etterfulgt av nuller, vil derfor dø ut av seg selv,
derav betegnelsen 'endelig impulsrespons'. FIR-filteres overføringsfunksjoner er karakterisert
ved at de bare har nullpunkter og at eventuelle poler er lokalisert på origo, der de ikke har
noen effekt på amplituderesponsen. Ett analogt filter kan ikke ha flere nullpunkter enn poler,
FIR-filtre har derfor ingen analog ekvivalent 9 . FIR-filtre er alltid stabile og de er derfor ideelle
som utgangspunkt for adaptive filtre. Stabiliteten til FIR-filtre gjør at de er mindre følsomme
for kvantiseringsfeil i filterkoeffisientene. En annen fordel disse filtrene har er at de lett kan
realiseres med en linær faserespons, som jeg skal vise nedenfor. Ulempen med FIR-filtre er at
de krever mange filter-ledd for å få til en skarp overgang i frekvensresponsen. Jeg skal
begrense diskusjonen om FIR-filtre til filtre med linær fase. Disse filtrene kan skrives på polar
form som :
H(w) = |H1(w)|e^f(w).
Der |H1(w)| er en reel funksjon av w, og f(w) er linær. Om filteret har linær faserespons eller
ikke avhenger av symmetrien til H. Filtere har vanligvis like symmetri dvs. filteret har orden
N = 2M+1 og h(2M - k) = h(k).
Frekvensresponsen til denne type filter er:
H(w) = e^(-jMw) Re[sum(h(k)e^-jkw)]
Konstruksjonen av ett FIR-filter begynner, som for IIR-filtre, med å definere en ønsket
overføringsfunksjon, Hideel(w), og deretter approksimere en realiserbar H(z) som tilfredsstiller
kravene til filtret. Selve approksimeringen gjøres med dataprogrammer basert på FFT og jeg
skal drøfte teorien bak en metode som involverer bruk av funksjoner kalt ’vinduer’.
FIR er et digitalt filter med endelig impulsrespons.
Dette kan uttrykkes ved H(z) med ai = 0 for alle i:
H( z)
b0 b1 z 1
.... bn z n
....
Utrykt ved differens likningen:
Y(nT) = b(0) x(nT) +b(1) x((n-1)T) +.b(m) x((n-m)T) , der b(m) er den m'te impulsresponsen,
dette filteret har m+1 impulsresponsledd.
H(z) = sum[ajz^-1] = sum[h(k)z^-1] k=0 til N-1
Filteret er av orden N.
Frekvensresponsen er :
H(f) = sum[h(k)e^-jkT].
Frekvensresponsen er altså bare fouriertransformasjonen av filterkoeffisientene og
filterkoeffisientene finnes ved å danne den inverse fouriertransformasjonen av Hid(w). Den
18

ønskede overføringsfunksjonen er Hid(w), denne kan representeres av DFT med
Hid(w) = sum[hd(k)e^-ikt] fra +/- uendelig
Der sekvensen {hid(k)} er Hid(w)'s impulsrespons.
Vindu metoden
Velges h(k) = hid(k) for alle k og filterets orden går mot uendelig, blir H(z) = Hid(w). For å
danne en realiserbar H(z) må den uendelige sekvensen {hid(k)} avkortes.
Impulsresponsene til Hi(z), hi(n) er gitt ved den omvendte Fouriertransformasjonen:
h( i)
Hid
Sekvensen {h(n)} består av uendelig mange ledd og vindumetoden går ut på å avkorte til ett
antall ledd N som man multipliserer med en vindu funksjon w(n).
H(n) = w(n)h(n), der -M < n < M
FIR-filteret blir av lengde N=2M+1.
FIR-filterets frekvensrespons blir da:
H e i
H e i
Et mål på hvor godt denne aproksimerer den ideelle Hi() får vi ved å se på
'mean-square error' ^2:
FFT av en vindu-funksjon danner en kurve med en sentral hovedlobe og flere mindre
sidelober, symmetrisk om origo.
Det sentrale i teorien om dannelse av en realiserbar H(z) på denne måten, er å se hvilken
effekt formen på vindusfunksjonen w(k) har på frekvensresponsen til H(z). Effekten av å
multiplisere med ett vindu i tidsdomenet er en konvulsjon i frekvensdomenet.
2
Hid H e
i
2
Hid
d
Dette gir :
e in
H(z) = int[Hid(w)W(w)]
in
d
M
h( n)
e
n M
in
M
h( n)
e
n M
in
Der W(w) er den fouriertransformerte av w(k).
19

W(w) for det rektangulære vinduet er :
W(w) = sin(Nw/2)/sin(w/2) .
Fig 6.
Hovedloben blir smalere og høyere jo flere ledd N, i {hid(k)}, som tas med, amplituden på
sidelobene varierer ikke nevneverdig med N, men frekvensen av dem øker. Når N - >
uendelig går W mot deltaimpulsfunksjonen (0) og H(z) = Hid(). Effekten av en konvulsjon
med w(k) kan leses direkte av plottet av W. Bredden av den sentrale hovedloben, vil glatte ut
skarpe overganger i Hid() og sidelobene vil gi oscillasjoner i H(z), kalt Gibbs fenomen. Gibbs
oscillasjon kan gi filteret en 'overshot' ved overganger i amplituderesponsen, som kan gjøre
filteret ubrukelig. Utglattingen av frekvensresponsen henger sammen med filterets orden og
vinduets oppløsning som er definert med:
R = |hovedloben bredde|/|1.sidelobes bredde|.
Hovedlobens bredde er et mål for hvor skarpt filteret er. For dette vinduet er bredden b =
2/N. Felles for alle vindufunksjonene er at bredden er proporsjonalt med 1/N. Det kan vises 6
at dette vinduet minimaliserer ^2, men dette filteret gir store oscillasjoner i signalet (ripple)
og 'overshot' ved overganger i Hi(). Det kan vises 6 at den relative amplituden til sidelobene
ikke reduseres nevneverdig med økende N. Derfor brukes alltid andre vinduer, som har bedre
egenskaper.
De viktigste egenskaper til ett vindu er hovedlobens bredde og størrelsen på sidelobene. Det
finnes en rekke vinduer som kan brukes. De tre kritiske parameterene i ett FIR-filter design er
filterets størrelse (orden N), skarpheten i overgangene, som bestemmes av hovedlobens
bredde (oppløsning R) og hvor stor oscillasjon som kan godtas, bestemt av amplituden til
sidelobene. Disse parameterene er delvis forbundet med hverandre og er ofte motstridene
krav. Hvilket vindu som velges er helt avhengig av hvilke krav som er gitt til designet. Felles
for vindu funksjonene er at større dempning i sidelobene oppnås på bekostning av
oppløsningen. De viktigste vindu funksjonene er Hanning, Bralett, Kaisser og Chebyshev. For
eksempel har Kaisser en veldig variabel form, der oppløsningen kan byttes mot størrelsen på
sidelobene.
Problemstillingen med dannelse av ett FIR-filter er altså å finne ett filter som akkurat
tilfredsstiller kravene, med færrest mulige filterkoeffisienter. Skulle dette hvert gjort for hånd
20

ville man prøvd ut flere ulike vinduer, helt til man fikk det beste resultatet.
I praksis brukes algoritmer som Remez. Remez baserer seg på en iterativ prosess, der
filterkoeffesientene justeres helt til resultatet er optimalt med lavest mulig orden men innenfor
kravene. Parameterene som gis til en algoritme av denne typen er filterets orden N, maksimalt
tillatte oscillasjoner i frekvensbåndene og påkrevet dempningen i stoppbandet.
Frekvensvinduer
Mens den foregående metoden multipliserte ett utvalg impulsresponser av Hi() med ett
vindu i tidsdomenet, gjøres med denne metoden et utvalg av Hi i et frekvensområdet [-F,
F] og dette multipliseres med ett frekvensvindu. Mye av diskusjonen rundt tidsvinduer gjelder
også her, multiplikasjonen med et vindu i frekvensdomenet gir opphav til konvulsjon i
tidsdomenet og fenomener som 'ripple' og 'overshot' oppstår. I praksis så løses problemet ved
å approksimere Hi() med ett polynom. Dette polynomet interpolerer verdiene mellom
frekvenssamplene.
Minimax
I vindumetoden forsøker man å minimalisere feilen ^2 (mean-sqr error.)
Med Minimax minimaliseres den maksimale feilen, altså:
||Hi-Hr|| = max|Hi() - Hr(e^i)| over alle
Utfordringen er nå å finne Hr(z) = hr(k)z^-k , -M < k < M
som minimaliserer denne feilen.
Dette løses numeriske.
21

Bitserielt bibliotek
I en seriell krets, kommer dataene en bit av gangen på en ledning, i stedet for ett ord av
gangen på en buss av samme bredde som ordlengden. All kommunikasjon mellom
prosesseringselementene og innad i elementene skjer altså på en ledning. Fordelene med dette
er innlysende, fraværet av brede busser på brikken muliggjør en tett VLSI design og
kommunikasjonen mellom brikkene forenkles. Bitserielle prosesseringselementer er også
mindre enn et tilsvarende utført i parallell logikk. Dette gjør en bitseriell design attraktiv i
systemer der hastighetskrav ikke krever en parallell prosessering. Dette gjelder spesielt tale
systemer, som telefoni. Hastighet er lavere for en seriell krets som prosesserer en bit av
gangen, ved første øyekast er parallell prosessering N ganger raskere, der N er ordlengden.
Men en bitseriell implementering kan klokkes mye raskere på grunn av kortere logisk vei
mellom registrene. En parallell adder for eksempel kan ikke klokkes raskere enn at menten
rekker å bevege seg gjennom hele adderen.
Seriell arkitektur.
Målet med denne oppgaven er å lage et sett av vanlig brukte funksjoner utført i seriell logikk,
utgangspunktet mitt var de elementene som var foreslått i boka 'VLSI SIGNAL
PROCESSING : A bitserial approach' 8 .
Jeg presenterer her elementene med kretsskjema og en verilog modell. Verilog modellene er
simulert på PC på 'logisk nivå' dvs. uten hensyn til forsinkelser i portene. En mer nøyaktig
spice simulering er nødvendig for å bestemme hvor raskt man kan klokke disse elementene.
Elementer som DFF (dflipflop), FA (full adder), MUX (multiplekser), FIFO-registre er
standard celler og jeg modellerer bare deres oppførsel. Bibloteket er tenk mest mulig
teknologi uavhengig.
Som nevnt ovenfor kreves bare to kontrollsignaler, bitklokke c0 og ordklokke c1.C1 skal
tilkjennegjøre begynnelsen på et nytt ord og fordi datastrømmen forsinkes i ulik grad gjennom
elementene, har jeg valgt å la c1 gå gjennom ett signalnettverk med like mye forsinkelse som
elementet. Et alternativ er å la kontrollgeneratoren danne alle c10, c12 osv. Her kan det spares
en del DFF i kretsene før et endelig utlegg skal lages.
Nummerrepresentasjonen er tokomplementere tall med LSB først og MSB sist.
Fordelen med denne representasjonen er at addisjon og subtraksjon går riktig for seg uten å
kjenne fortegnet på forhånd. Ulempen viser seg i de kretser der resultatet ikke kan bestemmes
før fortegnet er kjent, som i multiplikatoren.
Tallrepresentasjon
Dataene kommer altså på en ledning LSB først og MSB sist. Kretsene er designet for å
behandle data uten buffring, dvs. dataene kommer rygg mot rygg inn til modulene.
Før jeg kunne begynne dette arbeidet måtte jeg bestemme meg for hvordan tallene skulle
representeres. Data og koeffisienter i ett signalbehandlingssystem er alltid signerte tall, og en
vanlig måte å angi tegnet på er ved å definere MSB som fortegnsbiten. MSB gis negativ vekt
og de resterende bitene representerer størrelsen på tallet.
To vanlig brukte representasjoner er 1'komplement og 2'komplement, de representerer begge
tall i området -1 =< X < 1.Større tallområde er mulig ved å skalere denne representasjonen
22

med en faktor 2^k, der k er det ønskede antallet heltallsbiter. Faktoren 2^k kaller jeg heretter
. bestemmer det dynamiske området til X dvs. at |X| = 0 og kommer ut uforandret ut hvis x < 0.
Hvis tallet er negativt må vi strengt tatt legge til 1, etter at tallet er invertert. Dette kan gjøres
ved å sette inn en adder etter inverteringen. Denne adderen har inngang b jordet og carry-inn
satt til 1 ved c11=1. Om man trenger dette eller ikke er avhengig av hvilken nøyaktighet som
kreves.
Begge varianter er vist nedenfor.
Helt tilslutt er det en DFF på utgangen.
23

Forsinkelsen i denne kretsen er swl+2 for den uten adder og swl+3 for den med.
Fig 7.
Fig 8. Absolutt uten adder:
Fig 9.Absolutt med adder:
Verilog modell:
abs #(swl)(out,c0,c1,in).
In = inngangssignal.
Out = utgangssignal.
Kontrollsignaler c0,c1.
Parameter swl = ordlengde.
Forsinkelse swl+2.
24

module abs(out,clk,wclk,in);
parameter swl=9;
output out;input clk,wclk,in;
wire [swl-1:0] reg_out;
shift_reg #(swl+1)r(reg_out,clk,in);
latch l(l_out,wclk,reg_out[swl-1]);
not
(Nl_out,l_out),
(Nreg_out,reg_out[1]);
and
(A0,Nreg_out,l_out),
(A1,reg_out,Nl_out);
or (out,A0,A1);
endmodule
Fig.10 Absolutt av en sinus.
140
120
100
80
60
40
20
0
sampel
ADDER
abs
Legger sammen to tall A og B. f(A,B) = A+B.
Addisjonen foregår i en tre bit's fulladder. Summen lagres i DFF1, og menten lagres i DFF2
og føres tilbake til fulladderen. Menten forsinkes i DFF2 slik at den legge til i neste addisjon,
hele veien opp til fortegnsbiten. Når c1 signaliserer ankomsten av neste ord, kanselleres
menten.
2's komplementær representasjon brukes nettopp fordi tallene kan adderes direkte uavhengig
av fortegnet.
abs
25

Eksempel:
Swl=5.
A = 5 => 00101
B = 10 => 01010
Sum = 15 => 01111
A = 5 => 00101
B = -7 => 11001
Sum = -2 => 11110
A = 10 => 01010
B = 10 => 01010
Sum = -2 => 10100 !
Det andre eksemplet viser hvordan 2'komplementær representasjon virker når vi adderer et
positivt tall med ett negativt. Summen i det siste eksemplet overflyter, summen 10 + 10 ble -
2, ett negativt tall. En av utfordringene med design av digitale kretser er nettopp å passe på at
signalene ved alle noder i kretsen ligger innenfor det tillatte dynamiske området. Verken
adderen eller subtraktoren kan avkorte eller avrunde resultatet slik som multiplikatoren. Vi må
ta hensyn til bit-veksten ved å skalere dataene A og B, eller begrense (klippe) størrelsen på
dataene med LIMIT, som jeg skal beskrive senere.
ADD har tre innganger A, B og Cin, to utganger Sum og Cout, og bruker to kontroll signaler c0
og c1.
Cin og Cout er tatt med for at man skal kunne lage en dobbelpresisjons-adder, fig. 11.
I en dobbelpresisjons adder er Cin i den første adderen jordet, Cout fra denne føres inn til Cin
på den neste osv. LW går in på den første adderen, HW på den neste. På denne måten kan vi
operere med økt dynamisk område internt i en krets. Å representere dataene med dobbel
presisjon enkelte steder i kretsen, kan være nødvendig for å hanskes med bitveksten etter
enkelte operasjoner.
Kontrollsignalet c1 styrer enten menten fra en tidligere addisjon eller Cin, inn i fulladderen.
Adder elementene kan også brukes til å lage kolonne addere. Disse er nyttige for å legge
sammen flere enn to signaler. En kolonne adder er en tre-struktur av serielle addere som vist i
fig.12. Kolonne adderen i fig. 12 adderer 7 signaler, A,B,C,D,E,F og G. Resultatet kommer på
Sum_Out, etter en forsinkelse på 3.
Hver adder kombinerer to innganger til en utgang, dermed halveres antall signaler for hvert
lag av addere. Hvis antallet signaler er odde, leveres en inngang til neste lag gjennom en DFF
for synkronisering. Summen har like mange biter som inngangene, det er derfor nødvendig
med 'guard bits' på inngangene. For å forhindre overflyt, må det være en 'guard bit' for hvert
lag med addere.
26

Fig 11.
Fig 12 ADD celle.
Fig 13.Dobbel presisjonsadder.
27

Fig. 14. Kolonne adder.
Verilog modell:
add (Sum,Cout,c0,c1,A,B,Cin);
A,B = inngangsdata.
Sum = utgangsdata.
Cin,Cout = mente inn/ut.
c0,c1 =kontrollsignaler.
Forsinkelse på Sum = 1.
module add(sum,c_out,c0,c1,a,b,c_in);
output sum,c_out;input c0,c1,a,b,c_in;
multiplex m1(ci,c1,c_out,c_in);
full_adder fa(si,carry,a,b,ci);
dEdgeFF dff1(c_out,clk,carry);
dEdgeFF dff2(sum,clk,si);
endmodule
SUBTRAKT
Trekker B fra A.f(A,B) = A-B.
Denne kretsen er nesten lik adderen, med den forskjell at B inverteres og 1 legges til på LSB.
Kjernen i kretsen er en tre bits fulladder, en multiplekser styrer menten tilbake til fulladderen.
Når c1 signaliserer nytt ord kanselerer den menten og setter Cin lik 1 for å tilfredstille
konvensjonen -B = inv(B) + 1. Det brukes to DFF, en til menten og en på utgangen. En NOT
port inverterer B.
SUB har tre innganger A, B og Cin.Utganger Diff og Cout.Cin og Cout kan brukes til å lage
subtraktorer med større presisjon eller kolonne subtraktorer.
Cin settes alltid til 1 i den første enheten.
Kretsen kan også brukes til å negere ett tall f(B) = -B, ved å jorde A.
28

Fig 15.
Fig. 16. SUB celle.
Verilog modell:
sub(Diff,Cout,c0,c1,A,B,Cin);
A,B = inngangsdata.
Diff = utgangsdata.
Cin,Cout = mente inn, mente ut.
c0,c1 = kontrollsignaler.
Forsinkelse = 1.
module serial_sub(sum,c_out,c0,c1,a,b,c_in);
output sum,c_out;
input c0,c1,a,b,c_in;
multiplex m1(ci,c1,c_out,c_in);
not (nb,b);
full_adder fa(si,carry,a,nb,ci);
dEdgeFF dff1(c_out,c0,carry);
dEdgeFF dff2(sum,c0,si);
endmodule
29

DSHIFT
Aritmetisk høyreskift. Kretsen skifter A p plasser til høyre. f(A) = A / 2^p. Med positive tall
ville dette hvert enkelt, vi kunne brukt en DFF og en multiplekser i signalveien som satt MSB
til null. Men for 2'komplimentere tall må vi 'redde' fortegnsbiten MSB og så fortegnsutvide
ved å sette de p øverste bitene lik MSB.
Eksempel:
Swl = 6
A = -19 => 101101
p = 1 , f(A) = 110110
p =2 , f(A) = 111011
Resultatet kommer ut avkortet med p biter.
Operasjonen gjøres ved å sette en multiplekser i signalveien som styrer signalet til utgangen,
eller setter utgangen til MSB. c1 styrer multiplekseren og lagringen av MSB. Selve
høyreskiftingen av A gjøres ved å definere forsinkelsen til swl = 2 +p, der 2 er kretsens 'reelle'
forsinkelse. Forsinkelsen p er ikke en fysisk forsinkelse i den forstand at signalet forsinkes av
DFF i signalveien, men er en redefinering av hvor signalet starter og hvor det ender.
Kretsen er altså bygget rundt en multiplekser som sender enten signalet eller MSB gjennom.
Signalet går først inn i DFF1, ved c1 lagres denne i en DFF2. Ett kontrollsignal til
multiplekseren styrer den lagrede MSB gjennom ved c11,c12 c1p.Forsinkelses linjer av DFF
genererer dette signalet.
Fig. 17.
Fig. 16. DSHIFT celle.
30

I fig.18 er vist to forsinkelseslinjer for p=2 og p=3.
Generelt trengs p DFF og en OR port med p innganger. I fig. 17 er signalene vist for p=2 og
p=3.
Fig. 17. Kontroll signaler. Fig 18.
Verilog modell:
dshift #(p)(out,c0,c1,in);
In = inngangsdata.
Out = utgang.
c0,c1 = kontrollsignaler.
Parameter p = antall høyreskift.
Forsinkelse = 2+p.
module dshift(out,c0,c1,in);
output out;
input c0,c1,in);
multiplex m1(m_out,c_m,s_1,s_2);
dEdgeFF dff1(s_1,c0,in),
dff2(s_2,c1,s_1),
dff3(out,c0,m_out),
dff4(c_11,c0,c1),
dff5(c_12,c0,c_11);
or (c_m,c_11,c_12);
endmodule
31

MSHIFT
Aritmetisk venstreskift. Kretsen skifter A p plasser til venstre. f(A) = A * 2^p. I DSHIFT
måtte MSB lagres og settes inn på rett sted i signalet, her trenger vi bare å skifte tallet p
plasser til venstre og sette de p nederste bitene til null.
Eksempel:
Swl=6.
A = 13 => 001101
p = 1 , A = 26 => 011010
p = 2 , A = -12 => 110100 Overflyt!
A = -5 => 111011
p = 1 , A = -10 => 110110
Overflyt forekommer når de p+1 mest signifikante bitene er ulike før en skift operasjon. I
kretsen jeg beskriver her er det ingen overflytsdetektor, men det kan legges inn ved å teste de
p+1 mest signffikante bitene. Selve skift operasjonen foregår ved å definere en forsinkelse p.
For å unngå å få en primitiv med negativ eller null forsinkelse legges p+1 DFF på utgangen,
slik at forsinkelsen totalt blir 1.
En multiplekser styrer signalet gjennom eller setter det til null. Signalet settes til null fra LSB
og opptil p-1. Multiplekseren styres av en forsinkelseslinje med lengde p, og som har c1 på
inngangen.
Fig 19.
Fig. 20. mshift.
32

For kretsen i fig. 20 er p = 2, det er satt på 3 DFF for at den totale forsinkelsen skal bli lik 1.
En DFF må alltid stå foran MUX for å hindre at LSB overskrives.
Verilog modell:
mshift #(p)(out,c0,c1,in).
In = inngangsdata.
Out = utgang.
c0,c1 = kontrollsignaler.
Parameter p = antall skift.
Forsinkelsen er 1.
module mshift(out,c0,c1,in);
output out;
input c0,c1,in;
multiplex (m_out,c_m,in,1'b0);
dEdgeFF dff1(s_1,c0,m_out),
dff2(s_2,c0,s_1),
dff3(out,c0,s_3,
dff4(c_11,c0,c1);
or (c_m,c1,c_11);
endmodule
ORDER
Finner det største av to tall og sender dette til utgang max, det minste tallet sendes på utgang
min. Jeg antar her at dataene A og B, begge er positive. I kretsen kan det ikke avgjøres
hvilken som er størst og hvilken som er minst før de siste bitene er sammenliknet.
A og B kommer inn på to skiftregistre. Sammenlikningen kan enten skje med en parallell
komparator når begge dataene er i registere, ved c1, eller med en to bit's komparator.
En to bit's komparator sammenlikner en og en bit etter hvert som de kommer inn, informasjon
om hvilket tall som foreløpig er størst, lagres i en DFF.Når alle bitene er ferdig sammenliknet,
styrer resultatet av sammenlikningen en multiplekser på utgangen.
En to bit's komparator består av en NOT, en XNOR og en AND port, som vist i fig 21.
Fig 21.
33

Utgangen på AND porten er 1 hvis A > B, ellers 0. Utgangen på XNOR er 1 hvis A = B, 0
ellers. Forbinder jeg disse to med en OR port er utgangen 1 hvis A >= B. På utgangen av
denne er DFF1.Hvis denne er 1 når alle bitene er sammenliknet er A >=B og A kommer ut på
max, B på min. Når bitene er like skal verdien av DFF1 forbli uforandret, dette skjer ved en
tilbakeføring gjennom AND porten. Når An > Bn skal DFF1 settes til 1.
Sannhetstabellen for komparatoren finnes i tab 1.
Tabell 1.
Fig 22.
FF1
T-1
A = B
Komparatoren er vist i fig 23.
Fig 23.
0 1
FF1(t) =
FF1(t-1)
FF1(t) =
FF1(t-1)
A > B FF1 = 1 FF1(t) =
FF1(t-1)
A < B
FF1(t) =
FF1(t-1)
FF1 = 0
34

Den siste DFF sampler resultatet ved slutten av sammenlikningen og holder denne en hel
ordlengde swl. Denne styrer multiplekseren. Multiplekseren nullstiller DFF1 i starten av en ny
sammenlikning.
Hele kretsen er vist i fig 24.
Fig 24.
Verilog modell:
order(max,min,c0,c1,in1,in2);
A,B = inngangssignal.
MAX,MIN = utgang.
c0,c1 = kontroll.
Forsinkelse = swl+3
module order(max,min,c0,c1,in1,in2);
parameter swl=6;
output max,min;
input c0,c1,in1,in2;
wire [swl+1:0] reg_a,reg_b;
shift_reg #(swl+2)a(reg_a,c0,in1),
b(reg_b,c0,in2);
ord ord1(out,c0,c1,in1,in2);
demux de(max1,min1,out,reg_a[0],reg_b[0]);
dEdgeFF dFF1(max,c0,max1),
dFF2(min,c0,min1);
endmodule
module ord(out,c0,c1,in_a,in_b);
35

output out;
input c0,c1,in_a,in_b;
and (greater,in_a,N_in_b);
not (N_in_b,in_b);
xnor (eq,in_a,in_b);
and (d,eq,o3);
or (o1,greater,d);
multiplex m1(o3,c1,o2,1'b0);
dEdgeFF F1(o2,c0,o1),
F2(out,c1,o2);
endmodule
module demux(max,min,g,a,b);
output max,min;input g,a,b;
not (Ng,g);
and
(a_min,a,Ng),
(a_max,a,g),
(b_max,b,Ng),
(b_min,b,g);
or
(max,a_max,b_max),
(min,a_min,b_min);
endmodule
Fig.25 max av en sinus og en cosinus.
300
250
200
150
100
50
0
max
1 5 9 13 17 21 25 29 33 37 41 45 49 53 57 61 65
sampel
max
36

FORMAT1TO2
Denne kretsen som gjør om et signal fra enkelpresisjon til dobbelpresisjon. Dette formatet er
beskrevet i innledningen.
Signalet økes fra en ordlengde swl til 2*swl. Det nylig introduserte ordet fylles med
fortegnsutvidelser.
Eksempel :
swl = 6 => 12
101100 => 111111 101100
011011 => 000000 011011
De to ordene LW og LW sendes ut på to ledninger. HW kommer forsinket swl, etter LW.
At dataene nå sendes gjennom to ledninger i stedet for en, introduserer en form for ’digit
serial’ prossesering.
Kretsen består av to DFF og en multiplekser. Ved c1, lagres fortegnsbiten. Denne resirkuleres
ved tilbakeføring gjennom multiplekseren.
Fig 26.
Fig 27. Format1to2.
37

Verilog modell:
format1to2(lw,hw,c0,c1,in);
in = inngang.
lw = laveste 0 .. swl-1 biter.
hw = høyste swl-1 .. 2*swl-1 biter.
c0,c1 = kontrollsignaler.
Forsinkelse = 1.
module format1to2(lw,hw,c0,c1,in);
output lw,hw;
input c0,c1,in;
dEdgeFF dFF1(lw,c0,in),
dFF2(hw,c0,mout);
multiplex m1(mout,c1,hw,lw);
endmodule
FORMAT 3TO1.
Denne kretsen gjør signalet om fra tredobbel-presisjon til enkel-presisjon.
Kretsen virker på den måten at den henter ut swl biter fra tre innganger LW, MW, HW og
setter dette ut på linje out. En parameter d bestemmer hvor ordet out begynner.
Eksempel:
swl = 9 og d=12.Kommaene impliserer HW, MW, LW.
h0 h1 h2 h3 h4 h5 h6 h7 h8 m0 m1 m2 m3 m4 m5 m6 m7 m8, l0 l1 l2 l3 l4 l5 l6 l7 l8
out = h7 h8 m0 m1 m2 m3 m4 m5 m6.
Her er det mange mulige realiseringer. Jeg har valgt å styre LW, MW og HW inn i en
multiplekser. Multiplekseren styres av k1 og k2. En kontroll generator lager styringssignalene
til multiplekseren av ordklokken c1.
Tabellen under viser hvilke signaler som kontrollgeneratoren må generere:
Klokkeperiode: d < swl d > swl
[d swl > 00 01
[swl d > 01 10
Alle kontrollsignalene er av varighet d eller swl-d . De kan genereres med en forsinkelseslinje
som vist i fig. 29. I dette eksemplet er swl = 9 og d = 4.
38

Fig 28.
Fig 29. forsinkelses linje med d = 4
Rekken består av d antall DFF, deretter swl -d DFF, knyttet sammen med OR porter for å
generere b og c.
c1_out kan hentes fra denne rekken som vist ovenfor.
Forsinkelsen er d.
Regelen for styring av multiplekseren er :
d < swl k1 = a , k2 = c .
d > swl k1 = c , k2 = b .
39

Verilog modell:
format3to1(out,c1_out,c0,c1,lw,mw,hw);
lw,mw,hw = inngangsdata.
out = utgangsdata.
c0, c1 = kontrollsignaler.
c1_out = kontrollsignal ut.
forsinkelse = d.
module format3to1(out,c1_out,c0,c1,lw,mw,hw);
parameter swl=9;parameter d=4;
output out,c1_out;
input c0,c1,lw,mw,hw;
wire [swl-1:0] ffout;wire a,b,c;wire [1:0] ctrl;
assign c1_out = c1;
assign ctrl[1]=(dswl) ? c:1'b0; //Tilkobler mux
dEdgeFF ff0(ffout[0],c0,c1),
ff1(ffout[1],c0,ffout[0]),
ff2(ffout[2],c0,ffout[1]),
ff3(ffout[3],c0,ffout[2]),
ff4(ffout[4],c0,ffout[3]),
ff5(ffout[5],c0,ffout[4]),
ff6(ffout[6],c0,ffout[5]),
ff7(ffout[7],c0,ffout[6]),
ff8(ffout[8],c0,ffout[7]);
or o1(o1_out,ffout[3],ffout[4]),
o2(o2_out,ffout[5],ffout[6]),
o3(o3_out,ffout[7],ffout[8]);
or o4(b,o1_out,o2_out,o3_out);
not (c,b);
multiplex3 m1(out,lw,mw,hw,ctrl);
endmodule
LIMIT
LIMIT skal sørge for at signalet data, holdes innenfor området [-limit, limit], dvs.
hvis ABS(data) < limit slipper data uforandret gjennom til out, ellers settes out = limit.
Kretsen skal virke på 2’komplementære tall.
En løsning kunne være å hardkode limit og – limit og en testlogikk som tester data mot disse
to. Denne testlogikken kunne være en parallell komparator og resultatet av testen kan deretter
styre enten limit, -limit eller data til utgangen out.
Jeg har valgt å lage kretsen med subtraktorer som kan utføre sammenlikingen seriellt.
Fordelen med dette er at SUB allerede er en del av det bitserielle biblioteket og verdien limit
kan settes in i ett programmerbart skiftregister. Størrelsen til kretsen vil heller ikke øke så
40

mye med økende swl, bare registerene R1(data) og R2(limit) vil øke.
Fig 30.
Fig. 31.
Sammenlikningen gjøres med subtraktorer. Data må sammenliknes med limit hvis data er
positiv, -limit hvis data er negativ. Kretsen kjenner ikke fortegnet på forhånd og det er derfor
nødvendig med to grener, slik som i MULTIPLY. En gren for positiv data og en for negativ.
Limit sirkuleres i skiftregisteret R2. SUB1 tar differansen, limit – data, og hvis denne er
negativ er data større enn limit. Fortegnet til differansen lagres en hel ord-periode (klokkes av
c11) i DFF4 som A. Er data negativ gir SUB1 bare meningsløs informasjon.
SUB2, med a jordet, danner –limit. Denne sammenliknes med data i SUB3. Når data er
negativ, er differansen (-limit) – data positiv hvis data er mindre enn -limit. Resultatet lagres i
DFF5, som B. DFF5 klokkes av c11.
Resultatet av sammenlikningene A og B, styrer hver sin multiplekser MUX1 og MUX2.
Fortegnet til data holdes en ordperiode i DFF1, og denne klokkes av c10. Fortegnet styrer
MUX3 og bestemmer hvilket av resultatene som skal komme på utgangen.
41

Tabellen nedenfor viser resultatene av testene, A og B. Stjerne betyr at resultatet ikke brukes.
Tabell 2.
data > 0 data > 0
A: data > limit 1 (out = limit) 0*
A: data < limit 0 (out = data) 0*
B: data > -limit 1* 1 (out = data)
B: data < -limit 1* 0 (out = - limit)
Verilog modell:
Limit(out,c0,c1,in);
in = inngangsdata.
out = utgangsdata.
c0,c1 = kontrollsignaler.
Forsinkelse = swl + 4.
module Limit(out,c0,c10,in);
output out;
input c0,c10,in;
parameter swl=9;
parameter limit=9'b001000001;// 65, brukt til testing
wire d12_out;
assign out=d12_out;
Sub SUB1(s1_out,s1Cout,c0,c11,d5_out,d4_out,1'b1),
SUB2(s2_out,s2Cout,c0,c10,1'b0,r2_out,1'b1),
SUB3(s3_out,s3Cout,c0,c11,s2_out,d4_out,1'b1);
multiplex MUX1(m1_out,A,r1_out,d7_out),
MUX2(m2_out,B,d10_out,r1_out),
MUX3(m3_out,d3_out,m1_out,m2_out);
dEdgeFF DFF1(d1_out,c10,d4_out),
DFF2(d2_out,c0,d1_out),
DFF3(d3_out,c0,d2_out),
DFF4(d4_out,c0,in),
DFF5(d5_out,c0,r2_out),
DFF6(d6_out,c0,d5_out),
DFF7(d7_out,c0,d6_out),
DFF8(A,c11,s1_out),
DFF9(d9_out,c0,s2_out),
DFF10(d10_out,c0,d9_out),
DFF11(B,c11,s3_out),
DFF12(d12_out,c0,m3_out),
DFF13(c11,c0,c10);
42

endmodule
Register #(swl+2)R1(r1_out,c0,d4_out);
RegisterProg #(swl,limit)R2(r2_out,c0,r2_out);
Fig.32 Sinus med limit =100.
150
100
50
0
-50
-100
-150
MULTIPLY
Multiplikatoren multipliserer to tall A og B, f(A,B) = A * B. Multiplikatoren er den mest
kompliserte og største kretsen i biblioteket. Den kan lages på mange forskjellige måter
avhengig av krav til tallformat, dobbel/ enkelpresisjon, areal, forsinkelse og avrunding. Jeg
skal først drøfte aritmetikken og så se på forskjellige løsninger.
Usignert multiplikasjon
limit
1 5 9 13 17 21 25 29 33 37 41 45 49 53 57 61 65
sampel
To tall c (koeffisient) og d (data) skal multipliseres .
c har lengde m, d lengde n.
c0, d0 = MSB c4,d4 = LSB.
c => c0 c1 c2 c3 c4
d => d0 d1 d2 d3 d4
(c0 c1 c2 c3 c4) * d4
(c0 c1 c2 c3 c4) * d3
(c0 c1 c2 c3 c4) * d2
(c0 c1 c2 c3 c4) * d1
(c0 c1 c2 c3 c4) * d0
y0 y1 y2 y3 y4 y5 y6 y7 y8
To tall, c og d, med lengde m og n danner ett produkt med størrelse m+n-1 og m*n delprodukter.
Utregningen ovenfor illustrerer virkemåten til en seriell/parallell multiplikator. c
limit
43

påtrykkes parallelt og d serielt. Koeffisienten c multipliseres med hver av bitene i d, adderes
med ett tidligere resultat og skiftes en gang til høyre. Dette gjentas hele veien fra d4 til d0.
Den binære multiplikasjonen gjøres bitvis i m AND porter, der verdien av di avgjør om
koeffisienten c skal legges til produktet eller ikke.
En krets som gjør dette finnes i fig 31. Den første biten d4 multipliseres med alle bitene i c og
resultatet legges inn i en adder rekke. Når neste bit d3 kommer, er det forrige produktet flyttet
en plass til høyre og det nye produktet c *d3 legges til. Alle DFF'ene må nullstilles når ett nytt
produkt skal dannes.
AND porten og den serielle adderen utgjør en celle i multiplikatoren, og en multiplikator som
den i fig 1 består av m celler koblet i serie. Produktet kommer seriellt ut fra den siste cellen,
med LSB først.
Fig 33.
Multiplikasjon med signert koeffisient
Det vi trenger er en multiplikator som kan arbeide med 2'komplementære tall.
Multiplikatoren må også klare å utregne produktene sekvensielt, der både c og d kommer
kontinuerlig og uten noen form for buffring. Det betyr at en celle som er ferdig med å beregne
siste delprodukt p(m+n-1), i neste klokke syklus må kunne beregne p0 i ett nytt produkt.
Som nevnt tidligere har MSB negativt fortegn:
c = -c0 + ci/2^i
d = -d0 + di/2^i
c * d = d* ci/2^i + d * (-c0)
44

En multiplikasjon mellom to 2'komlementære tall blir som vist nedenfor. Jeg har her byttet
om på c og d.
(d0 d0 d0 d0 d0 d1 d2 d3 d4) * c4
(d0 d0 d0 d0 d1 d2 d3 d4) * c3
(d0 d0 d0 d1 d2 d3 d4) * c2
(d0 d0 d1 d2 d3 d4) * c1
+/- (d0 d1 d2 d3 d4) * c0
y0 y1 y2 y3 y4 y5 y6 y7 y8
Fortegnsutvidelsen av d0 er nødvendig pga bitveksten og for å bevare det 2'komplementære
formatet når delproduktene skal legges sammen. c0 har negativ vekt, og hvis c0 = 1 må d
trekkes fra i den siste linjen.
Den multiplikatoren jeg skal beskrive her er delvis bygget på den beskrevet i boka 'VLSI
SIGNAL PROCESSING: A BITSERIAL APPROACH.'. Det er en avkortingsmultiplikator,
dvs. produktet 'kuttes' slik at det får samme lengde som dataen. I eksemplet ovenfor ville
produktet bestå av bitene y0 y1 y2 y3 y4, mens y5 y6 y7 y8 ville blitt kansellert.
Jeg skal også vise hvordan en avrundingsmultiplikator og en dobbelpresisjonsmultiplikator
kan lages ved å gjøre noen modifikasjoner på avkortingsmultiplikatoren.
En del av strukturen kan tas direkte fra utregningen ovenfor. Den vil ha n celler der den siste
cellen må danne det 2'komplmentære av d. Produktet må skiftes en plass til høyre i forhold til
de nye delproduktene som legges til.
Cellen MULT er tegnet i fig.3, og MSBMULT i fig.5.
MULT utgjør de første n-1 cellene og MSBMULT den siste.
MULT består av en AND port der data_in multipliseres med koeffisientbiten cn.
Delproduktet går inn i en seriell adder der menten resirkuleres helt til LSB ankommer, da
kanseleres menten. På utgangen av adderen er det en multiplekser som styrer signalet ut til
DFF3, denne tilbakeføres og dupliseres når c1 er høy. Det er denne tilbakeføringen som
utfører fortegnsutvidelsen.
Data_in forsinkes to ganger i DFF1 og DFF2 før det kommer ut som data_out. c1 skal følge
LSB og forsinkes to ganger i FF5 og FF6 før det kommer ut som c1_out. c1_in sletter menten
fra FF4 når c1_in = 1.
Den siste cellen i rekken er MSBMULT, her multipliseres data_in med fortegnsbiten c0.
Denne cellen er nesten lik MULT men med en seriell subtraktor der det 2'komplementære av
data kan legges til produktet. Det ferdige produktet kommer seriellt ut på p_out.
Fig 34.
45

Fig 35. multcelle
Fig 36.
Fig 37.msb-multcelle
Cellene kobles sammen som vist i fig. 38. Dette er en multiplikator med 5 celler (n = 5).
Det avkortede produktet kommer ut serielt ved product_out.
46

Fig 38.Multiplikator med cwl=5.
Verilog modell:
spmult(p_out,d_out,c_out,c0,c_in,d_in,y);
d_in = data inn.
y = koeffisient inn.
p_out = produkt ut.
d_out = data ut.
c0,c1 = kontrollsignaler.
Forsinkelse på p_out = 2*cwl.
module spMultCell(p_out,d_out,c_out,c0,p_in,d_in,c_in,y_in); // seriell-paralell modul
output p_out,d_out,c_out;
input c0,p_in,d_in,c_in,y_in;
dEdgeFF DFF1(ff1_out,c0,d_in),
DFF 2(d_out,c0,ff1_out),
DFF 4(ff4_out,c0,carry),
DFF 3(p_out,c0,m1_out),
DFF 5(ff5_out,c0,c_in),
DFF 6(c_out,c0,ff5_out);
and (a1,y_in,d_in),
(a2,ff4_out,nc_in);
not (nc_in,c_in);
full_adder fa1(sum,carry,a1,p_in,a2);
multiplex m1(m1_out,c_in,sum,p_out);
endmodule
module spMultCellMsb(p_out,d_out,c_out,c0,p_in,d_in,c_in,y_in); // seriell-paralell modul
47

output p_out,d_out,c_out;
input c0,p_in,d_in,c_in,y_in;
dEdgeFF DFF1(ff1_out,c0,d_in),
DFF2(d_out,c0,ff1_out),
DFF3(p_out,c0,sum),
DFF4(ff4_out,c0,carry),
DFF5(ff5_out,c0,c_in),
DFF6(c_out,c0,ff5_out);
and (a1,y_in,nd_in),
(a2,o1,y_in);
not (nd_in,d_in);
or (o1,ff4_out,c_in);
full_adder fa1(sum,carry,a1,p_in,a2);
endmodule
module spMultiplier(p_out,d_out,c_out,c0,c1_in,d_in,y);
parameter swl=9;
output p_out,d_out,c_out;
input c0,c1_in,d_in;
input [swl-1:0] y;
wire [swl-1:0] p,d,c;
assign p_out=p[8],d_out=d[8],c_out=c[8];
spMultCell
s0(p[0],d[0],c[0], c0,1'b0,d_in,c1_in,y[0]),
s1(p[1],d[1],c[1], c0,p[0],d[0],c[0],y[1]),
s2(p[2],d[2],c[2], c0,p[1],d[1],c[1],y[2]),
s3(p[3],d[3],c[3], c0,p[2],d[2],c[2],y[3]),
s4(p[4],d[4],c[4], c0,p[3],d[3],c[3],y[4]),
s5(p[5],d[5],c[5], c0,p[4],d[4],c[4],y[5]),
s6(p[6],d[6],c[6], c0,p[5],d[5],c[5],y[6]),
s7(p[7],d[7],c[7], c0,p[6],d[6],c[6],y[7]);
spMultCellMsb s8(p[8],d[8],c[8], c0,p[7],d[7],c[7],y[8]);
endmodule
I tabellen nedenfor er det vist i detalj hvor og når de ulike delproduktene dannes i denne
multiplikatoren.
Den horisontale aksen betegner cellen's posisjon og den vertikale betegner tiden angitt i
klokke steg c0.
48

Posisjon
c0 Mult1 (c4) Mult2 (c3) Mult3 (c2) Mult4 (c1) Msbmult (c0)
1 d4c4
2 d3c4
3 d2c4 d4c3
4 d1c4 d3c3
5 d0c4 d2c3 d4c2
6 d1c3 d3c2
7 d0c3 d2c2 d4c1
8 d1c1 d3c1
9 d0c0 d2c1 d4c0
10 d1c1 d3c0
11 d0c1 d2c0
12 d1c0
13 d0c0
Delproduktene summeres diagonalt nedover i denne tabellen, for eksempel y8 = d4c4 og y7 =
d3c4+d4c3. I tabellen er noen delprodukter anngitt i kursiv, dette er delprodukter som
fortegnsutvidelsen sletter. Den delen av produktet som ikke slettes, y0y1y2y3, kommer ut av
MSBMULT etter T = 10, eller 2*n.
Fortegnsutvidelsen i denne multiplikatoren tjener to hensikter. Den ene er å avkorte produktet
med n biter, slik at produktet er av samme størrelse (swl) som data. Den andre er å hindre nye
delsummer, i et nytt produkt, fra å interferere med tidligere delsummer som allerede finnes i
multiplikatoren.
Multiplikasjon med signert data og koeffisient.
Multiplikatoren ovenfor kan bare multiplisere signerte koeffisienter, data må være positiv.
Hvis data var negativ, d0 =1, måtte multiplikatoren legge til den 2'komplementære av
koeffisienten til summen, når d0 entrer multiplikatoren.
En måte å omgå dette på er å lage det 2'komplementære av data når denne er negativ, så
multiplisere koeffesienten med denne, og deretter ta det 2'komplemetære av produktet for å få
det riktig tegnet tilbake.
Problemet er at fortegnsbiten d0 ikke blir kjent før helt tilslutt i multiplikasjonen. Jeg har løst
dette med en multiplikator som har to grener, en for positiv data og en for negativ. Når d0
entrer multiplikatoren, styrer denne en multiplekser på utgangen som velger hvilken av de to
produktene som skal komme ut på product_out.
I den nederste banen beregnes produktet som om data var negativ. Data negeres, dvs. det
danner det 2'komplementære av data, ved å kjøre det gjennom b inngangen på primitiven
SUB, a inngangen jordes. På utgangen av den nederste banen dannes det 2'komplementære av
produktet for å gjenopprette fortegnet.
De to SUB primitivene har hver en forsinkelse 1 og for å kompensere benyttes to DFF i den
øverste banen.
DFF1 har som oppgave å holde fortegnsbiten d0 gjennom en hel ordlengde swl. Den klokkes
av c1_in. Denne styrer igjen multiplekseren på utgangen.
49

Fig 39. spSignedMultiplier, cwl = 5.
Verilog modell:
spSignedMultiplier (prod,d_out,c1_out,c0,c1_in,d_in,y);
d_in = data inn.
y = koeffisient.
c0,c1 = kontrollsignaler.
c1_out = c1 ut.
prod = produkt ut.
d_out = data ut.
forsinkelse på prod, d_out = 2* cwl + 3.
module spSignedMultiplier(prod,d_out,c1_out,c0,c1_in,d_in,y);
parameter swl=9;
output prod,d_out,c1_out;
input c0,c1_in,d_in;
input [swl-1:0] y;
// Positiv gren ---->
dEdgeFF DFF1(ff1_out,c0,c1_in),
DFF2(ff2_out,c0,d_in),
DFF3(ff3_out,c1_in,ff2_out), // Låser fortegnet.
DFF4(ff4_out,c0,prod_pos_out),
DFF5(prod,c0,prod1),
DFF6(ff6_out,c0,d_pos_out),
DFF7(d_out,c0,ff6_out),
50

endmodule
DFF8(c1_out,c0,c1_pos_out);
spMultiplier sp(prod_pos_out,d_pos_out,c1_pos_out,c0,ff1_out,ff2_out,y);
// Negativ gren ---->
serial_sub sub1(d_neg,c_out1,c0,c1_in,1'b0,d_in,1'b1),
sub2(prod_neg,c_out2,c0,c1_neg_out,1'b0,prod_neg_out,1'b1);
spMultiplier sn(prod_neg_out,d_neg_out,c1_neg_out,c0,ff1_out,d_neg,y);
multiplex m1(prod1,ff3_out,ff4_out,prod_neg); // Velger resultat.
Det tette designet setter en del krav til både data og koeffisienter. Data må ha en 'guard'-bit,
dvs. data må ligge mellom 11 000 000 < data < 01 000 000.Hvis ikke vil den mest
signifikante biten overskrives og resultatet vil bli meningsløst. Produktet skal være av samme
størrelsesorden som data, derfor må koeffisienten defineres som en fraksjon og koeffisientene
må ligge mellom -1 < koeff < 1. Denne begrensningen på koeffisientene er i virkeligheten
ikke noe problem fordi koeffisientene uansett må skaleres før de gis til multiplikatorene. Jeg
kjørte flere simuleringer av multiplikatoren på PC, og resultatet stemte med teorien så lenge
kravene ovenfor var overholdt. Hele kretsen har en forsinkelse på m+3. Den produserer en bit
av produktet per c0 og ett helt produkt per c1. Multiplikatoren kan behandle data og
koeffisienter av ulik lengde, produktet vil uansett være av lengde n. Jeg skal se på tre
forskjellige scenarioer, m > n , m = n og m < n. Hvis m > n er det rimelig å anta at
konverterings-støyen som introduseres i multiplikasjonen minker, men produktet vil likevel
avkorte de ekstra bitene m-n. De 'ekstra' bitene som dannes internt vil kanselleres før de når
utgangen, og jeg konkluderer med at lengre koeffisienter i forhold til data er unødvendig.
Hvis m < n kan det spares en del maskinvare, men produktet må fortsatt være av lengde n.
Den delen av produktet som kanselleres vil ha større vekt og derfor øke konverterings-støyen
fra multiplikatoren. I en filter konfigurasjon betyr dette at posisjonen til nullpunkter og poler
ikke kan bestemmes nøyaktig. Av dette konkluderer jeg at m = n er den mest fornuftige
konfigurasjonen.
Avrundingsmultiplikator
Multiplikatoren ovenfor avkorter produktet, dvs. den fjerner de laveste m -1 bitene.
Avkortingen vil sette de positive tallene ned til det nærmeste heltall, de negative tallene
avrundes også nedover dvs. magnituden på negative tall øker.
Effekten av dette er en avrundingsstøy i området q[-1,0]. Fra signalteori er det kjent at dette
gir mer støy totalt enn om støyen lå i området q[- ½ , ½].
Det er mulig å modifisere avkortings multiplikatoren slik at den virker som en
avrundingsmultiplikator, ved å sette inn en avrundings bit på rett sted i utregningen. I
eksemplet nedenfor har jeg prøvd å illustrere dette. Bitene til høyre for kommaet avkortes/
avrundes. Produktet før avkorting: 00110,1000
51

Ved å legge til en bit blir produktet:
00110,1000
+00000,1000
00111,
Biten kan legges til i den første modulen i rekken, ved tiden T0 + m-2.Dette kan løses ved å
bruke en av de tilgjengelige kontrollsignalene c1n, og en multiplekser som setter c_in til 1 i
den første cellen.
Seriell/seriell multiplikator
I multiplikatorene ovenfor påtrykkes data seriellt og koeffisientene parallellt. Det er mulig å
lage en multiplikator der også koeffisientene påtrykkes seriellt.
Fig 40 ssMultCell.
Denne modulen er nesten helt lik den forrige. Forskjellen er DFF7 og DFF8. DFF7 holder
koeffisientenbiten fast gjennom hele ordperioden, mens DFF8 sørger for at den neste
koeffisientbiten ankommer til rett tid i den neste modulen. Ved å flytte DFF1 og DFF5 slik
som jeg har gjort, kan kontrollsignalet c1_in brukes direkte til å låse koeffisientbitene.
fig 41. ssMultCellMsb.
52

Verilog modell:
module ssMultiplier(prod,d_out,c1_out,c0,c1_in,d_in,y);
d_in = data inn.
y = koeffisient inn.
c0,c1 = kontrollsignaler.
prod = produkt ut.
d_out = data ut.
c1_out = c1 ut.
forsinkelse på 2* cwl + 3
module ssMultCell (p_out,d_out,c_out,y_out,c0,p_in,d_in,c_in,y_in); // seriell-seriell modul
output p_out,d_out,c_out,y_out;
input c0,p_in,d_in,c_in,y_in;
dEdgeFF ff1(ff1_out,c0,d_in),
ff2(d_out,c0,ff1_out),
ff3(p_out,c0,m1_out),
ff4(ff4_out,c0,carry),
ff5(ff5_out,c0,c_in),
ff6(c_out,c0,ff5_out),
ff7(ff7_out,c_in,y_in),
ff8(y_out,c0,y_in);
and (a1,ff7_out,ff1_out),
(a2,ff4_out,nc_in);
not (nc_in,ff5_out);
53

full_adder fa1(sum,carry,a1,p_in,a2);
multiplex m1(m1_out,ff5_out,sum,p_out);//ff5
endmodule
module ssMultCellMsb (p_out,d_out,c_out,c0,p_in,d_in,c_in,y_in); // seriell-seriell modul
output p_out,d_out,c_out;
input c0,p_in,d_in,c_in,y_in;
dEdgeFF ff1(ff1_out,c0,d_in),
ff2(d_out,c0,ff1_out),
ff3(p_out,c0,sum),//
ff4(ff4_out,c0,carry),
ff5(ff5_out,c0,c_in),
ff6(c_out,c0,ff5_out),
ff7(ff7_out,c_in,y_in);
and (a1,ff7_out,nd_in),
(a2,o1,ff7_out);
not (nd_in,ff1_out),
(no1,o1);
or (o1,ff4_out,ff5_out);
full_adder fa1(sum,carry,a1,p_in,a2);
endmodule
module ssMult(p_out,d_out,c_out,c0,c_in,d_in,y_in);
parameter swl=9;
output p_out,d_out,c_out;
input c0,c_in,d_in,y_in;
wire [swl-1:0] p,d,c,y;
assign p_out=p[8],d_out=d[8],c_out=c[8];
ssMultCell
s0(p[0],d[0],c[0],y[0],c0,1'b0,d_in,c_in,y_in),
s1(p[1],d[1],c[1],y[1],c0,p[0],d[0],c[0],y[0]),
s2(p[2],d[2],c[2],y[2],c0,p[1],d[1],c[1],y[1]),
s3(p[3],d[3],c[3],y[3],c0,p[2],d[2],c[2],y[2]),
s4(p[4],d[4],c[4],y[4],c0,p[3],d[3],c[3],y[3]),
s5(p[5],d[5],c[5],y[5],c0,p[4],d[4],c[4],y[4]),
s6(p[6],d[6],c[6],y[6],c0,p[5],d[5],c[5],y[5]),
s7(p[7],d[7],c[7],y[7],c0,p[6],d[6],c[6],y[6]);
ssMultCellMsb s8(p[8],d[8],c[8] ,c0,p[7],d[7],c[7],y[7]);
endmodule
module ssMultiplier(prod,d_out,c1_out,c0,c1_in,d_in,y);
parameter swl=9;
output prod,d_out,c1_out;
input c0,c1_in,d_in,y;
54

endmodule
// Positiv gren ---->
dEdgeFF ff1(ff1_out,c0,c1_in),
ff2(ff2_out,c0,d_in),
ff3(ff3_out,c1_in,ff2_out), // Låser fortegnet.
ff4(ff4_out,c0,prod_pos_out),
ff5(prod,c0,prod1),
ff6(ff6_out,c0,d_pos_out),
ff7(d_out,c0,ff6_out),
ff8(c1_out,c0,c1_pos_out),
ff10(ff10_out,c0,y),
ff11(d1_out,c0,ff12_out),
ff12(ff12_out,c0,ff13_out),
ff13(ff13_out,c1_in,ff3_out);
ssMultsp(prod_pos_out,d_pos_out,c1_pos_out,c0,ff1_out,ff2_out,ff10_out);
// Negativ gren ---->
serial_sub sub1(d_neg,c_out1,c0,c1_in,1'b0,d_in,1'b1),//
sub2(prod_neg,c_out2,c0,c1_neg_out,1'b0,prod_neg_out,1'b1);
ssMultsn(prod_neg_out,d_neg_out,c1_neg_out,c0,ff1_out,d_neg,ff10_out);
multiplex m1(prod1,ff12_out,ff4_out,prod_neg); // Velger resultat.
Fig. 42 Produkt av ’Spike’-signal og sinus.
150
100
50
0
-50
-100
-150
Serial-Serial Multiplier
1 5 9 13 17 21 25 29 33 37 41 45 49 53 57 61 65
product
55

Dobbelpresisjonsmultiplikator.
Det er noen ganger være nødvendig å arbeide med dobbelpresisjon internt i en krets, et
eksempel er FIR filtre der mange produkter skal summeres. Dobbelpresisjon vil også minke
avrundingsstøyen på utgangen. Multiplikatoren jeg har beskrevet ovenfor kan med noen
modifikasjoner gi hele produktet i dobbelpresisjon. I multiplikatorene ovenfor, kanseleres de
interne delproduktene i multiplekseren i hver celle. I multiplikator-cellen i fig.43 'reddes' disse
delproduktene og legges ned i en rekke av DFF og kommer ut av multiplikatoren på en egen
linje som LW. Multiplikatoren har nå fått to utganger, HW og LW. Hele produktet har derfor
bredde 2*swl.
Fig 43. dpssms
Fig 44. dpspmlasts.
56

Denne multiplikatoren må også fortegnsutvide i den siste cellen slik at HW og LW begge blir
av bredde SWL.
Hele multiplikatoren vises i fig 45.
Fig 45.Dobbelpresisjons-multiplikator.
57

For eksempel med swl = 5 må produktet bli y0 y0 y1 y2 y4 y5 y6 y7 y8 ,
der HW = y0 y0 y1 y2 y3 og LW = y4 y5 y6 y7 y8.
Verilog modell:
dpssMultiplier(hw,lw,d_out,c1_out,c0,c1_in,d_in,y);
d_in = data inn.
y = koeffisient inn.
c0,c1 = kontrollsignaler.
hw,lw = produkt ut.
d_out = data ut.
c1_out = c1 ut.
forsinkelse på hw = 2* cwl + 3
forsinkelse på lw = cwl + 3
module dpssms(hw_out,lw_out,d_out,c_out,y_out,c0,hw_in,lw_in,d_in,c_in,y_in);
output hw_out,lw_out,d_out,c_out,y_out;
input c0,hw_in,lw_in,d_in,c_in,y_in;
dEdgeFF ff1(ff1_out,c0,d_in),
ff2(d_out,c0,ff1_out),
ff3(hw_out,c0,m1_out),
ff4(ff4_out,c0,carry),
ff5(ff5_out,c0,c_in),
ff6(c_out,c0,ff5_out),
ff7(ff7_out,c_in,y_in), //låser coeffesienten
ff8(y_out,c0,y_in),
ff9(lw_out,c0,m2_out);
and (a1,ff7_out,ff1_out),
(a2,ff4_out,nc_in);
not (nc_in,ff5_out);
full_adder fa1(sum,carry,a1,hw_in,a2);
multiplex m1(m1_out,ff5_out,sum,hw_out),
m2(m2_out,ff5_out,lw_in,sum);
endmodule
module dpspmlasts(hw_out,lw_out,d_out,c_out,c0,hw_in,lw_in,d_in,c_in,y_in); // dp seriellseriell
modul msb
output hw_out,lw_out,d_out,c_out;
input c0,hw_in,lw_in,d_in,c_in,y_in;
dEdgeFF ff1(ff1_out,c0,d_in),
ff2(d_out,c0,ff1_out),// data out
ff3(hw_out,c0,m1_out),
ff4(ff4_out,c0,carry),
58

endmodule
ff5(ff5_out,c0,c_in),
ff6(ff6_out,c0,ff5_out),
ff7(ff7_out,c_in,y_in),
ff8(lw_out,c0,lw_in),// lw out
ff9(c_out,c0,ff5_out),
ff10(y_out,c0,y_in);
and (a1,ff7_out,nd_in),
(a2,o1,ff7_out);
not (nd_in,ff1_out),
(neg_ff5_out,ff5_out),
(no1,o1);
or (o1,ff4_out,ff5_out);
full_adder fa1(sum,carry,a1,hw_in,a2);
multiplex m1(m1_out,c_in,sum,hw_out);
// I dpssmult må Koeffesient lengden bestemmes
// Nedenfor brukes 12 bit
module dpssmult(hw_out,lw_out,d_out,c_out,c0,c_in,d_in,y_in);
parameter swl=12;
output hw_out,lw_out,d_out,c_out;
input c0,c_in,d_in,y_in;
wire [swl-1:0] hw,lw,d,c,y;
assign hw_out=hw[11],lw_out=lw[11],d_out=d[11],c_out=c[11]; // definerer hvor
utgangene er
dpspms
s0(hw[0],lw[0],d[0],c[0],y[0],c0,1'b0,1'b0,d_in,c_in,y_in),
s1(hw[1],lw[1],d[1],c[1],y[1],c0,hw[0],lw[0],d[0],c[0],y[0]),
s2(hw[2],lw[2],d[2],c[2],y[2],c0,hw[1],lw[1],d[1],c[1],y[1]),
s3(hw[3],lw[3],d[3],c[3],y[3],c0,hw[2],lw[2],d[2],c[2],y[2]),
s4(hw[4],lw[4],d[4],c[4],y[4],c0,hw[3],lw[3],d[3],c[3],y[3]),
s5(hw[5],lw[5],d[5],c[5],y[5],c0,hw[4],lw[4],d[4],c[4],y[4]),
s6(hw[6],lw[6],d[6],c[6],y[6],c0,hw[5],lw[5],d[5],c[5],y[5]),
s7(hw[7],lw[7],d[7],c[7],y[7],c0,hw[6],lw[6],d[6],c[6],y[6]),
s8(hw[8],lw[8],d[8],c[8],y[8],c0,hw[7],lw[7],d[7],c[7],y[7]),
s9(hw[9],lw[9],d[9],c[9],y[9],c0,hw[8],lw[8],d[8],c[8],y[8]),
s10(hw[10],lw[10],d[10],c[10],y[10],c0,hw[9],lw[9],d[9],c[9],y[9]);
dpspmlasts s11(hw[11],lw[11],d[11],c[11] ,c0,hw[10],lw[10],d[10],c[10],y[10]);
endmodule
59

OBS! dpssmultiplier lw har ingen fortegnsbit, lw er derfor skiftet en til venstre i forhold til
et signert resultat
// LSB i lw vil derfor alltid være 0
// Har forsinkelse 2*cwl+2 ( i dette tilfelle 24)
module dpssmultiplier(hw,lw,d_out,c1_out,c0,c1_in,d_in,coef_in);
parameter swl=12;
output hw,lw,d_out,c1_out;
input c0,c1_in,d_in,coef_in;
endmodule
// ff5,ff7,ff9,ff13 er buffer på utgangen av mux'ene.
// De kan som oftest sløyfes
// Positiv gren ---->
dEdgeFF ff1(ff1_out,c0,c1_in),
ff2(ff2_out,c0,d_in),
ff3(ff3_out,c1_in,ff2_out), // Låser fortegnet.
ff4(ff4_out,c0,hw_pos_out),
//ff5(hw,c0,prodhw), // ikke nødvendig
ff6(d_out,c0,d_pos_out),
//ff7(d_out,c0,ff6_out), // kan fjernes sammen med ff5,ff9,ff13
ff8(c1_out,c0,c1_pos_out),
//ff9(lw_prod_neg,c0,lw_neg_out),
ff10(ff10_out,c0,coef_in),
ff11(ff11_out,c1_in,ff3_out),//
ff12(ff12_out,c0,ff11_out),
//ff13(lw,c0,prodlw),
ff14(ff14_out,c0,lw_pos_out),
ff15(ff15_out,c0,ff3_out);
dpssmult
sp(hw_pos_out,lw_pos_out,d_pos_out,c1_pos_out,c0,ff1_out,ff2_out,ff10_out);
// Negativ gren ---->
serial_sub sub1(d_neg,c_out1,c0,c1_in,1'b0,d_in,1'b1),// feil på signalering av lsb
sub2(lw_prod_neg,c_out2,c0,c1_pos_out,1'b0,lw_neg_out,1'b1),
sub3(hw_prod_neg,c_out3,c0,c1_pos_out,1'b0,hw_neg_out,c_out2);
dpssmult
sn(hw_neg_out,lw_neg_out,d_neg_out,c1_neg_out,c0,ff1_out,d_neg,ff10_out);
multiplex m1(hw,ff12_out,ff4_out,hw_prod_neg),
m2(lw,ff15_out,ff14_out,lw_prod_neg); // Velger gren.
60

Implementering.
Filterstrukturene jeg har beskrevet under avsnittet ’Filterstrukturer’ er alle virtuelle maskiner,
dvs. multiplikatorene og adderene er ikke ment å ha forsinkelse på signalveien. All forsinkelse
ligger implisitt i ett forsinkelsesregister.
I det bitserielle biblioteket har alle modulene forsinkelse på en eller mer. Dette må tas hensyn
til når filteret skal implementeres i maskinvare.
Jeg skal først implementere en 2’ordens IIR filter modul.
IIR filter.
Fig 46.
Multiplikatorene er merket m1,m2,m3 og m4. Adderene er merket a1,a2,a3 og a4.
Forsinkelses elementene R1 og R2. Filterstrukturen er av typen ’Direkte Form II’, med to
poler og to nullpunkter. Jeg har valgt å analysere et 2. ordens filter for eksempelets skyld,
normalt vil et filter bestå av flere slike ledd.
Filteret må tilfredstille rekursjonen y(n) = Ax(n) + Bx(n-1) + Cy(n-1) + Dy(n-2), der
koeffesientene er skalert slik at A = 1.
Jeg skal analysere forsinkelsen gjennom de ulike grenene og velger origo, t = 0, ved
inngangen, x(n). Adderen har en forsinkelse 1,R1 har forsinkelse f1 og multiplikatoren, med
koeffesientlengde cwl har en forsinkelse 2*cwl + 3. Den totale forsinkelsen i
tilbakeføringssløyfen fra a1,R1,m1,a2 tilbake til a1, blir summen av forsinkelsene, 1 + f1 +
2*cwl +3 +1 = f1+2*cwl + f1.
Skal rekursjonslikningen være oppfyllt må forsinkelsen i sløyfen være lik swl. Om jeg setter
f1 = 0 er forsinkelsen lik 2*cwl + 5.Hvis cwl = swl blir forsinkelsen i multiplikatoren så stor at
den ikke rekker å beregne ett resultat før en ny sampel annkommer filteret. Dette avslører ett
problem med bitseriell implementering av IIR filtere. Forsinkelsen i elementene er så stor at
det setter begrensninger på størrelsen til koeffesientene.
En måte å komme rundt dette på kan være å buffre data-samplene. Man må da godta at
61

multiplikatorene vil beregne ’skrot’ i deler av klokkesyklene, slik at resultatet får tid til å
kommer gjenom tilbakeføringen. Dette bufferet kan være en rekke med fortegnsutvidelser
mellom samplene. Denne løsningen gir mulighet til vilkårlig store koeffesient-lengder på
bekostning av økt forsinkelse og dårligere utnyttelse av maskinvaren.
Ellers må bredden på koeffesienteene (cwl) reduseres i forhold til swl. Tids-likningen for den
første tilbakeføringssløyfen blir da 2*cwl+5

Koeffesientene må skaleres før de gis til multiplikatoren, mshift skalerer utgangssignalet opp
igjen med s^2.
Den store forsinkelsen i multiplikatorene gjør altså at bredden på koeffesientene må reduseres
i forhold til bredden på signalet. Dette gjelder for alle filtere som har tilbakeføring, også
lattice filtere
FIR filtre.
Ett FIR filter har ingen tilbakeføringer og bredden på koeffesientene er bare begrenset av hvor
stor forsinkelse filteret kan tillates å ha.
Som eksempel har jeg valgt å bruke en seriell-seriell multiplikator med forsinkelse swl, dvs.
en koeffesientlengde swl-3. Produktet vil nå komme til rett tid til adderen a1. Adderen har
forsinkelse 1. For å kompensere for dette må jeg legge til en DFF på data_out. Hvert filterledd
har en total forsinkelse swl.
Ett FIR filterledd har verilog modell :
parametere :
swl – signal-ordbredde
cwl – koeffesient ordbredde
module Fl(y_out,d_out,c1_out,c0,c1_in,d_in,y_in,coeff);
parameter swl,cwl;
output y_out,d_out,c1_out;
input c0,c1_in,d_in,y_in;
input [cwl-1:0] coeff;
multiply #(cwl) m1(p_out,data_out,c1_out,c0,c1_in,d_in,coeff);
add a1(a1_out,c_out,c0,c1_out,p_out,y_in,1'b0);
delay #(swl-1) d1(y_out,c0,a1_out);
endmodule
Y_out,d_out og kontrollsignalet c_out kommer nå ut sammtidig og dette forenkler arbeidet
med å lage et FIR filtere av vilkårlig orden N.
module FIR(y,c0,c1,data,coeff);
output y;
input c0,c1,data;
input [cl-1:0] coeff [N-1:0];
wire [N-1:0] y_out,dd,cc;
ledd l1(y_out[1],dd[1],cc[1],c0,c1 ,data ,coeff[1]),
l2(y_out[2],dd[2],cc[2],c0,cc[1],dd[1],coeff[2]),
l3(y_out[3],dd[3],cc[3],c0,cc[2],dd[2],coeff[3]),
l4(y_out[4],dd[4],cc[4],c0,cc[3],dd[3],coeff[4]),
.
63

endmodule
.
.
lN(y,dd[N],dd[N],c0,cc[N],d[N-1],coeff[N]);
c0 er det eneste kontrollsignalet som er globalt, c1 påtrykkes bare på inngangen av FIR
filteret.
Praktiske FIR filtere har høy orden, og utgangen består da av mange del-produkter som legges
sammen. Dette gir en stor bitvekst i summen. Enten kan koeffesientene skaleres så lavt at delproduktene
blir små, eller så kan swl økes for å gi rom til bitvekseten. En annen metode er å
øke data representasjonen der hvor bitveksten skjer. Jeg gjør dette i eksemplet nedenfor. Jeg
bruker dpSeriellSeriell multiplikator og denne gir produktet i dobbelpresisjon. På utgangen av
denne brukes format2to3, dermed er ordlengden 3*swl i adder-rekken. Dette gir en god
dynamisk bredde. På utgangen må bredden på signalet reduseres til swl igjen. Dette gjøres
med format3to1.
I multiplikatoren DPMULTIPLY, kommer produktene ut LW_int forsinket swl+2 og HW_int
er forsinket 2*swl+2. MW og HW fra Format1To2 er forsinket 1 i forhold til LW_int, DFF5
kompenserer for dette før delproduktene gis til adder rekken.
I filterlerleddet IP skal alle signalene ankomme med LSB langs samme bølgefront, og
DFF6 – DFF14 synkroniserer signalene i adder-rekken. DFF1 – DFF4 synkroniserer d_out og
c1_out med LW_out, MW_out og HW_out. På utgangen av disse igjen, er skiftregistere R1,
R2 og R3 med lengde swl.
Forsinkelsen i data banen er 2*swl+4 og i adder banen swl+4, dette tillfredstiller FIR filter
likningen. ’Ekstra’ forsinkelsen på swl+4 er lik i alle signalveiene og forandrer derfor ikke
resultatet. Dette er en ’pipelining’ prosessoren. Registerene R1, R2 og R3 kan sløyfes i det
siste leddet i en ’full array’ implementasjon.
Fig 47. Filterledd IP.
64

Verilog modell:
module
IP(hw_out,mw_out,lw_out,data_out,c1_out,c0,c1_in,hw_in,mw_in,lw_in,data_in,coeff_in);
output hw_out,mw_out,lw_out,data_out,c1_out;
input c0,c1_in,hw_in,mw_in,lw_in,data_in,coeff_in;
parameter swl=12;
endmodule
dpssmultiplier #(swl)mult(hw,lw,di,ci,c0,c1_in,data_in,coeff_in);
format1to2 form(hwi,mwi,c0,ci,hw);
serial_adder a1(lwii,carry1,c0,d3_out,d5_out,d8_out,1'b0),
a2(mwii,carry2,c0,d3_out,mwi,d11_out,carry1),
a3(hwii,carry3,c0,d3_out,hwi,d14_out,carry2);
dEdgeFF d1(d1_out,c0,di),
d2(data_out,c0,d1_out), // data_out forsinkes 2
//ganger for å synce med lw_out
d3(d3_out,c0,ci), // brukes til å klokke adderene
d4(c1_out,c0,d3_out),
d5(d5_out,c0,lw);
dEdgeFF d6(d6_out,c0,lw_in),
d7(d7_out,c0,d6_out), // alle data inn i adderene
//må forsinkes 3 ganger
d8(d8_out,c0,d7_out), // for å synkronisere med ny
// addend
d9(d9_out,c0,mw_in),
d10(d10_out,c0,d9_out),
d11(d11_out,c0,d10_out),
d12(d12_out,c0,hw_in),
d13(d13_out,c0,d12_out),
d14(d14_out,c0,d13_out);
Register r1(lw_out,c0,lwii), // disse kan sløyfes i siste ledd i en
// 'full array' arkitektur
r2(mw_out,c0,mwii),
r3(hw_out,c0,hwii);
Fig 48. N-ordens FIR filter. ’Full array’ arkitektur.
65

Hvis filteret realiseres med en prosessor per koeffesient som ovenfor, vil det oftest bli raskere
enn nødvendig.
Målet med implementeringen av ett filter må være å utnytte maskinvaren best mulig dvs. å
klokke den på høyest mulig frekvens. Er filteret raskere enn nødvendig er det mulig å
multiplekse filteret og dermed spare maskinvare ressurser. Dette er det samme som å
båndbredde tillpasse filteret.
Multiplekset FIR filter.
Nedenfor har jeg laget en modul som bruker ett filterledd til alle beregningene. Filteret har
orden N. Koeffesientene har bredde cwl biter.
Filterleddet har jeg kalt IP2 og det er likt IP bortsett fra at R1, R2 og R3 er sløyfet.
Prossesoren har to innganger, en for seriell data og en for seriell koeffesient buss. Utgangen er
seriell.
Internt er det to kontrollsignaler, en bit klokke c0 og en ordklokke c1. Ordklokkens frekvens
må være N*sampelfrekvensen.
Koeffesientsløyfen sirkulerer koeffesientene til multiplikatoren og akkumulatorsløyfen samler
opp resultatene. Koeffesientsløyfen er ikke vist i figuren. Resultatet hentes på utgangen hver
c_sample.
Skiftregisterene d1,d2,d3 og d4, sørger for minne til prosessoren. Forsinkelsen i IP mellom
d_in og d_out er 2*cwl+4. Forsinkelsen i hele sløyfen skal være N*swl + 1, d1 må derfor ha
forsinkelse N*swl – 2*cwl – 3.
Forsinkelsen mellom LW_in,MW_in, HW_in og LW_out, MW_out , HW_out er 1.
Denne sløyfen skal ha en total forsinkelse på swl. Registerene d1, d2 og d3 må derfor ha
lengde swl-1.
Multiplekserene styres av ordklokker med pulser av lengde swl. Cm1 styrer in ett nytt sampel
så snart prosessoren er ferdig med N iterasjoner. Cm2, Cm3, og Cm4 sørger for å slette
resultatet i akkumulatoren når prosessoren er klar til å ta fatt på N nye iterasjoner. Dette må
skje samtidig med at LW fra det nye samplet kommer til ADD1. Dette skjer cwl+3 etter Cm1.
Cm3 of Cm4 er forsinket med swl i forhold til Cm2.
Altså:
Cm1 = C20. Cm2 = C2(cwl + 3). Cm3 = C2(swl + cwl + 3). Cm4 = C2(2*swl + cwl + 3).
66

Fig 45. Multiplekset FIR filter.
Verilog modell:
// Ett FIR filterledd uten R1, R2 og R3 registere på adderrekken,
// kan brukes som siste ledd in en 'full array' arkitektur eller i ett multipleksed FIR filter
// forsinkelse på data er 2*cwl+4 = 28
// forsinkelse i adderrekken er 4
module
IP2(hw_out,mw_out,lw_out,data_out,c1_out,c0,c1_in,hw_in,mw_in,lw_in,data_in,coeff_in);
output hw_out,mw_out,lw_out,data_out,c1_out;
input c0,c1_in,hw_in,mw_in,lw_in,data_in,coeff_in;
parameter swl=12;
dpssmultiplier #(swl)mult(hw,lw,di,ci,c0,c1_in,data_in,coeff_in);
format1to2 form(hwi,mwi,c0,ci,hw);
serial_adder a1(lw_out,carry1,c0,d3_out,d5_out,d8_out,1'b0),
a2(mw_out,carry2,c0,d3_out,mwi,d11_out,carry1),
a3(hw_out,carry3,c0,d3_out,hwi,d14_out,carry2);
dEdgeFF d1(d1_out,c0,di),
d2(data_out,c0,d1_out), // data_out forsinkes 2
//ganger for å synce med lw_out
67

endmodule
d3(d3_out,c0,ci), // brukes til å klokke adderene
d4(c1_out,c0,d3_out),
d5(d5_out,c0,lw); // format1to3 har forsinkelse 1,
// denne synkroniserer dem
dEdgeFF d6(d6_out,c0,lw_in),
d7(d7_out,c0,d6_out), // alle data inn i adderene
d8(d8_out,c0,d7_out), // må forsinkes 3 ganger
d9(d9_out,c0,mw_in), // for å synkronisere med ny addend
d10(d10_out,c0,d9_out),
d11(d11_out,c0,d10_out),
d12(d12_out,c0,hw_in),
d13(d13_out,c0,d12_out),
d14(d14_out,c0,d13_out);
// multipleksed FIR filter
// med ekstern koeffesient sløyfe
//
module multiplexFIR(out,test,c1_out,c0,c1_in,c20_in,c21_in,c22_in,data_in,coeff_in);
output out,test,c1_out;
input c0,c1_in,c20_in,c21_in,c22_in,data_in,coeff_in;
wire lwi_out,mwi_out;
assign out=lwi_out,test=mwi_out;
IP2
#(12)ip(hwi_out,mwi_out,lwi_out,di_out,c1_out,c0,c1_in,m4_out,m3_out,m2_out,
m1_out,coeff_in);
Register2 r2(r2_out,c0,lwi_out), // registerene i adder rekken swl-4
r3(r3_out,c0,mwi_out),
r4(r4_out,c0,hwi_out);
Register3 r1(r1_out,c0,di_out); // registeret i data sløyfen
// ((N+1)*swl – (2*cwl+4))
multiplex m1(m1_out,c20_in,r1_out,data_in),
m2(m2_out,c20_in,r2_out,1'b0),
m3(m3_out,c21_in,r3_out,1'b0),
m4(m4_out,c22_in,r4_out,1'b0);
endmodule
Filteret ovenfor har en von Neumann arkitektur. Når filteret skal båndbredde tilpasses, vil det
vanligvis kreve at flere moduler av typen ovenfor seriekobles. Dette krever at data-sløyfene
og akkumulator-sløyfene i multiplexFIR-modulene sammenkobles. Dette lar seg enkelt gjøre,
68

og alle grader av multipleksing mellom ’full array’ og ’von Neumann’ er mulig.
Test av filtere .
FIR filterene ovenfor kan enkelt testes med en ’konvulsjonstest’ 10 . Koeffesientene i denne
testen danner en firkant (N=11) {0,0,0,A,A,A,A,A,0,0,0} og datasignalet ett firkant signal
...0,0,0,B,B,B,B,B,0,0,0... . Konvulsjonen av to firkanter er en trekant, i dette tillfellet en
trekant med maks høyde 5AB : ..0,0,AB,2AB,3AB,4AB,5AB,4AB,3AB,2AB,AB,0,0...
Kjøringen av denne testen viser at filterene fungerer som de skal.
Fig. 47. Test av filter.
1200
1000
800
600
400
200
0
Test av FIR filter
1 3 5 7 9 11 13 15 17 19 21 23 25 27 29
Jeg skal lage en mer realistisk test med å danne ett lavpass-filter. Lavpass-filteret skal ha disse
egenskapene:
F(cuttof) =1/10 F(nyqvist)
swl = 12
Filterorden N = 21
Antallet desimalplasser som er nødvendig for å representere ett 12 bits fraksjon er gitt av
formelen 7 : d = I(0.3b + 1), der d er antallet desimalplasser, b er cwl og I(x) er absolutt
verdien av x.
I dette tilfellet, med cwl =12, blir d = I(0.3*12+1) = I(4.6) = 4.
Med disse parameterene gir Remez-algoritmen i matlab følgende koeffesienter:
f=[0 0.1 0.2 1];% frekvensommrådet
a=[1 1 0 0]; %ønsket amplitude respons
b = remez(n,f,a);
Serie1
69

{-0.0390 -0.0187 -0.0146 -0.0028 0.0168 0.0433 0.0736 0.1039 0.1298 0.1472
0.1533 0.1472 0.1298 0.1039 0.0736 0.0433 0.0168 -0.0028 -0.0146 -0.0187 -0.0390 }
Frekvensresponsen til dette filteret er vist i fig 48 nedenfor. Dette er den teoretiske responsen,
generert av matlab.
Fig 48.
Koeffesientene som gis til multiplikatoren må ligge mellom , den største her er 0.1533
og den minste er -0.0390. Jeg finner først den største faktoren, delelig på 2, som gjør at
koeffesientene utnytter området best mulig. I dette tillfellet er det 4.
Multiplisert med 4 blir koeffesientene nå:
{ -0.1560 -0.0748 -0.0584 -0.0114 0.0674 0.1732 0.2946 0.4156 0.5191 0.5886
0.6134 0.5886 0.5191 0.4156 0.2946 0.1732 0.0674 -0.0114 -0.0584 -0.0748 -0.1560 }
70

I binær representasjon og med cwl = 12 , blir koeffesientene:
{ 111011000001, 111101100111, 111110001001, 111111101001, 000010001010,
000101100010, 001001011111, 001101010011, 010000100111, 010010110101,
010011101000, 010010110101, 010000100111, 001101010011, 001001011111,
000101100010, 000010001010, 111111101001, 111110001001, 111101100111,
111011000001 }
For å avgjøre hvilken del av resultatet Format2To1 skal plukke ut på utgangen, må jeg finne
det størst mulige resultatet som kan komme ut av filteret. Med cwl =12 og en ’guard-bit’ på
data, er det største signalet som kommer inn til filteret 001111111111 = 1023. Største signal
på utgangen blir da 1023*(-319 –153 –119 –23 +138 +354 +607 +851 +1063 +1205 + 1256
+1205 +1063 +851 + 607 +354 +138 –23 -119 –153 -319) = 1023*8464 eller
100001000001111011110000 .
Format3To1 må derfor plukke ordet fra hw1 til mw2, dvs. out består av :
{hw1 hw0 mw11 mw10 mw9 mw8 mw7 mw6 mw5 mw4 mw3 mw2}.
Test signalet består av 3 sinus signaler, y=sin(400*t) + 0.5*sin(3300*t) + 0.5*sin(1900*t).
De er samplet slik at fs=10000Hz, fn=5000 og dermed blir fcuttof=500Hz.
Den første sinusen ligger innenfor passbandet, de to andre ligger i stoppbandet.
Før filtrering ser signalet ut som i figuren nedenfor:
Fig. 49.
71

Etter filtreringen ser signalet slik ut:
De to signalene som lå i stoppbandet er effektivt dempetm mens signalet i passbandet er
uforandret. Uregelmessighetene i starten av filtreringen (før 21. sampel) skyldes at minnet i
filteret er ’tomt’ i utgangspunktet.
Fig. 50.
800
600
400
200
0
-200
-400
-600
-800
1 9 17 25 33 41 49 57 65 73 81 89 97
out
72

Konklusjon.
Jeg har i denne oppgaven vist at det er mulig å lage alle vanlige funksjoner i en bitseriell
implementering. De bitserielle cellene vil være små og strukturen muligjør en kompakt
realisering i utlegget.
Det som også har kommet fram er at cellene øker mindre i størrelse med økende ordlengder
enn tilsvarende funksjoner uført i parallell logikk.
Ulempen viser seg i cellenes forsinkelse, særlig i multiplikatorene. Dette fører til
begrensninger i koeffesientlengdene for filtere med tilbakeføring (IIR/Lattice). Denne
begrensningen gjelder ikke for FIR filtere og i multipleksede FIR filtere vil denne
forsinkelsen utnyttes som en del av minnet i data-sløyfen og adder-sløyfen. Bitseriell
implementering er derfor godt egnet til disse filterene.
Det som idag begrenser bruken av bitseriell implementering er hastigheten, parallell
implementering vil alltid kunne lages raskere enn en tilsvarende seriell implementering. Jeg
tror likevel at seriell implementering har så mange fordeler at det vil få flere og flere
annvendelses områder.
73

Litteratur
1 David Pescovitz. "Wired for Speed."
SCIENTIFIC AMERICAN, MAY 2000
2 Raymond J. Andraka."FIR Filter Fits in an FPGA using Bit Serial Approach"
3 DIGITAL NUMBER SYSTEMS
4
Kent Palmkvist. "Design and Implementation of Recursive Digital Filters using Bit-Serial
arithmetics."
Linkøping University, S-581 83 Linkøping Sweden.
5 Per Larsson-Edefors."High-Speed CMOS Design Bit-Serial Arithmetic Applications and
Tecnology Mapping of Combinational Boolean Equations."
Linkøping University, S-581 83 Linkøping, Sweden.
6 Richard A. Roberts,Clifford T. Mullis." DIGITAL SIGNAL PROCESSING."
Addison-Wesly.ISBN 0-201-16350-0
7 E.L . Johnson, M.A Karim,"DIGITAL DESIGN. A PRAGMATIC APPROACH"
PWS ENGINEERING. ISBN 0-534-06972
8
Peter Denyer, David Renshaw. "VLSI SIGNAL PROCESSING:A BIT-SERIAL
APPROACH."
ADDISON-WESLEY PUBLISHING COMPANY. ISBN 0-201-14404-2
9 Howard Hutchings. "INTERFACING WITH C"
An Elektronics World + Wireless World Publication.
10 Sanjit K. Mitra. "Digital Signal Processing. A Computer-Based Approach."
McGraw-Hill Higher Education. ISBN 0-07-118175-X
74