SE465393B - Adressprocessor foer en signalprocessor - Google Patents

Description

465 395 2 cirkulär buffert av storleken 2“, där n är ett heltal större än O. En pekare anger den äldsta tillständsvariabelns minnesposi- tion, dvs den cirkulära buffertens vikningsadress. Efter avläs- ning av den äldsta tillstándsvariabeln skrivs ett nytt samplings- värde in i den utpekade minnespositionen, varvid denna äldsta tillståndsvariabel skrivs över. Om nu pekaren ändras till att peka mot den näst äldsta tillståndsvariabeln kommer pekaren att ange en ny vikningsadress. Den tidigare näst äldsta tillståndsva- riabeln är nu äldst, och resultatet av proceduren är ekvivalent med att alla tillståndsvariablerna i den cirkulära bufferten skiftats en minnesposition utan att rent fysisk ha förfyttats.

Endast pekaren har uppdaterats till att ange den nya viknings- adressen. Metoden kallas därför virtuell skiftning. När pekaren nått den cirkulära buffertens första minnesposition kommer den vid nästa skiftning att peka mot den sista minnespositionen.

Adresseringen av bufferten kan sålunda betecknas som "modulo 2” adressering".

En väsentlig nackdel vid denna kända metod är dock att bufferten endast kan ha storleken 2“, så att även filtren måste vara av längden 2”. Detta gör metoden lämplig för endast vissa speciella filter.

En annan känd metod använder sig av en buffert med godtycklig längd och utnyttjar en pekare som stegas ned från buffertens slut mot dess början under filterberäkningarna. När pekaren nått buf- fertens början laddas pekaren åter med adressen till buffertens slut, så att proceduren kan upprepas.

Nackdelen med denna kända metod är att det ej är möjligt att vid godtycklig tidpunkt adressera en godtycklig tillståndsvariabel i ett godtyckligt filter. Metoden fungerar endast om filtren be- räknas i sekvens enligt ovan. Detta gör metoden oanvändbar som utgångspunkt för en generell adressprocessor. j) 465 3-93 UPPFINNINGENS SYFTEMÅL Föreliggande uppfinning syftar till erbjudande av en adresspro- cessor av den inledningsvis nämnda typen, vilken skall vara ka- pabel att i åtminstone en cirkulär buffert adressera och vir- tuellt skifta tillståndsvariablerna för åtminstone två i buffer- ten efter varandra lagrade digitala filter med godtyckligt antal fördröjningselement eller längd, men med samma samplingsfrekvens.

SUMMERING AV UPPFINNINGEN Ovanstående syftemål uppnås enligt uppfinningen med en adresspro- cessor som uppvisar de i patentkravet 1 angivna särdragen.

KORT BESKRIVNING AV RITNINGEN Uppfinningen kommer att beskrivas närmare nedan under hänvisning till den bifogade ritningen, i vilken: Fig. 1 visar dataminnesindelningen vid föreliggande upp- finning; K Fig. 2 visar indelningen av en buffert vid föreliggande uppfinning; Fig. 3 visar ett filterschema för filtren i bufferten i fig. 2; Fig. 4 illustrerar filtrens och vikningsadressens läge i bufferten i fig. 2 under på varandra följande be- räkningssteg; Fig. 5 visar en föredragen utföringsform av en adressprocessor i enlighet med föreliggande uppfinning; 465 393 4 Fig. 6 visar ett beräkningstidsdiagram för adressprocessorn enligt fig. 5; och Fig. 7 visar ett signaltidsdiagram för adressprocessorn enligt fig. 5 för tre filter A, B och C med 2, l resp N tap- par, där N är ett godtyckligt positivt heltal.

BESKRIVNING Av FÖREDRAGNA UTFöRINGsFoRMER Fig. l visar minnesorganisationen för den del av RAM-minnet som innehåller tillståndsvariablerna för olika filter. I detta fall antages att minnet innehåller filter för åtta kanaler CH 0-CH 7.

Varje kanal innehåller'buffertar BUFF O - BUFF 2. Antalet buffer- tar är godtyckligt, men varje kanal har samma antal buffertar med motsvarande längder. Buffertarna innehåller i sin tur filter FILTER O - FILTER 2. Buffertarna har normalt olika längder, men filtren i varje buffert svarar mot samma samplingsfrekvens. Vid föreliggande uppfinning innehåller åtminstone en buffert två eller flera filter. Buffertlängderna beror av summan av filter- längderna; närmare bestämt utgöres buffertlängden av summan av antalet fördröjningselement i de ingående filtren plus 1.

I fig. l visas ett dataminne indelat i åtta kanaler CH O - CH 7.

Uppfinningen är dock ej begränsad till just åtta kanaler, utan ett godtyckligt antal kanaler är möjliga. Vidare indikeras i fig. 1 ett dataminne bestående av 512 minnesceller. Även detta antal kan varieras.

I fig. 2 visas innehållet i en buffert mera i detalj. I exemplet innehåller bufferten tre filter med filterbegynnelseadresserna filter_addr(O), filter_addr(l), filter_addr(2). Buffertens abso- luta startadress betecknas mod_start. Tillstàndsvariablerna i det första filtret är betecknade X(n), X(n-l), X(n-2), X(n-3). Här anger X(n) det senaste samplingsvärdet, X(n-1) det näst senaste samplingsvärdet osv. 5 För att förenkla den följande beskrivningen antages till att börja med att de tre filtren i bufferten i fig. 2 är icke rekursiva.

Vid beräkningen av FILTER 0 hämtas då tillståndsvariablerna i tur och ordning från minnet, med början från den äldsta tillståndsva- riabeln X(n-3 ) , och multipliceras med motsvarande filterkoeffici- enter, vilka hämtas från RAM- eller ROM-minne. Filtret beräknas genom summering av dessa multiplicerade tillståndsvariabler.

Sedan filtret beräknats skrivs det erhållna värdet Y(n) in i minnescellen för den äldsta tillståndsvariabeln X(n-3). I fig. 2 har detta indikerats genom att tillståndsvariabeln eller samp- lingsvärdet X(n-3) delar minnescellen med filterutsignalen Y(n).

De beräknade filtervärdena Y(n), Y(n-1)... bildar på detta sätt insignaler till FILTER 1. FILTER 1 beräknas på motsvarande sätt, och sedan detta beräknats skrivs dess värde in i minnescellen för den äldsta tillståndsvariabeln Y(n-2) såsom insignal till FILTER 2. Denna procedur, där utsignalen från ett filter bildar insignal till nästa filter, är möjlig på grund av att filtren i bufferten svarar mot samma samplingsfrekvens.

För att ytterligare belysa beräkningsproceduren, och i synnerhet även de komplikationer som uppkommer i samband med rekursiva filter, hänvisas till fig. 3 och 4.

Fig. 3 visar ett generellare filterschema för filtren i bufferten i fig. 2. Såsom tidigare är det första filtret, FILTER 0, ett icke rekursivt filter som endast innehåller en transversell del.

Det andra filtret, FILTER 1, innehåller däremot en rekursiv väns- terdel och en transversell högerdel. Det tredje filtret, FILTER 2, innehåller endast en rekursiv del och ingen transversell del.

I fig. 3 har fördröjningselementen indikerats med T. Såsom fram- går av fig. 2 innehåller FILTER O tre fördröjningselement T och fyra koefficienter a°...a3. FILTER l innehåller två fördröjnings- element T och två koefficienter bl, bz i den rekursiva delen samt tre koefficienter c°...c2 i den transversella delen. FILTER 2 465 393 6 innehåller två fördröjningselement T samt två koefficienter du dr Enligt ovanstående beräkningsregel har sålunda bufferten längden 3 + 2 + 2 + 1, dvs. 8.

Fig. 4 visar en sekvens av beräkningar för de tre filtren i fig. 30 Två saker är väsentliga att notera i fig. 3.

För det första ligger värdena av tillståndsvariablerna X(n)..., .Y(n)..., W(n)... hela tiden stilla i den minnescell de en gång tilldelats. För varje ny figur (a)-(h) ökar n med 1, dvs. X(n) kommer att kallas X(n-1) osv. Tillstândsvariablernas värden lig- ger dock kvar i den ursprungliga minnescellen. De äldsta till- ståndsvariablerna skrivs sedan över med nya tillståndsvariabel- värden när de ej längre behövs. Ingen förflyttning av tillstånds- variablerna erfordras således.

För det andra uppdateras hela tiden buffertens vikningsadress mod_pointer. Denna pekare pekar hela tiden ut den minnesadress där den cirkulära bufferten viker sig, i detta fall gränsen mel- lan FILTER 2 och FILTER Ö. Pekaren mod_pointer utgör en "noll- referens" , med vilken det är möjligt att erhålla korrekt absolut adress för en aktuell tillståndsvariabel, vilket närmare skall belysas nedan.

Vid beräkningen av adressen till en viss tillståndsvariabel ut- nyttjas följande variabler: mod_start = buffertens absoluta startadress; data_addr = den valda tillståndsvariabelns förskjutning relativt buffertens startadress, mod_start; write_addr = den valda skrivadressen relativt buffertens startadress, mod_start; mod_numb = buffertens längd, kan väljas godtyckligt; mod_pointer = buffertens aktuella vikningsadress; ms CN LH 04-. xg CN 7 rel_addr = den beräknade adressen relativt buffertens startadress, modstart; dmaddr = den slutliga, absoluta minnesadressen.

Vid beräkningen av adressen till en tillståndsvariabel beräknas först summan data_addr + mod_pointer Sedan testas om denna summa är mindre än mod_numb. Om så är fal- let sättes rel_addr till den erhållna summan, dvs. rel_addr = data_addr + mod_pointer Om vilkoret däremot inte är uppfyllt, dvs summan är större eller lika med mod_numb, så sättes rel_addr till rel_addr = data_addr + mod_pointer - mod_numb I båda fallen har nu den sökta minnespositionens förskjutning relativt buffertens startadress, mod_start, erhållits. Den slut- liga, absoluta dataminnesadressen, dmaddr, erhålles genom att mod_start adderas till det erhållna resultatet, dvs dmaddr = rel_addr + mod_start I begynnelsetillstándet sätts mod_pointer = mod_numb - 1 så att rel_addr = data_addr - l En inskrivningsadress beräknas på samma sätt med den skillnaden att data_addr genomgående ersätts med write_addr. 465 393 8 Beräkningen av FILTER O, FILTER 1 och FILTER 2 går till på följande sätt. 1) 2) 3) 4) Insignalen skrivs in i position X(n).

FILTER O beräknas på följande sätt. Först sätts data_addr = filter_addr(0) + index, där index = 3. Med detta värde på data_addr beräknas adressen till X(n-3) enligt ovan. X(n- 3) hämtas från den utpekade minnescellen och multipliceras med koefficienten aa. Därefter minskas index och sålunda även data_addr med 1. X(n-2) hämtas och multipliceras med az. Produkten adderas till den tidigare erhållna produkten.

På motsvarande sätt stegas index ända ned till O, så att samtliga variabler i FILTER 0 hämtas i tur och ordning, multipliceras med motsvarande koefficient och adderas.

FILTER O är därefter färdigberäknat.

FILTER l beräknas på följande sätt. Först beräknas den re- kursiva vänstra delen genom att data_addr sätts lika med filter_addr(1) + index, där index = 2. Härigenom utpekas Y(n-2), vilken multipliceras med bz, varefter index och så- ledes även data_addršminskas med 1. Den erhållna produkten adderas till det från FILTER O erhållna resultatet. På mot- svarande sätt adderas även Y(n-1) multiplicerad med koeffi- cienten bl till det tidigare erhållna resultatet. Vid nästa nedstegning av index erhålls adressen till position X(n- 3)/Y(n). I denna minnesposition skrivs nu det erhållna re- sultatet Y(n) över den tidigare tillståndsvariabeln X(n-3).

Nu finns samtliga nödvändiga tillståndsvariabler Y(n), Y(n- l) och Y(n-2) tillgängliga för beräkning av den transver- sella högra delen av FILTER l. Denna beräkning sker på samma sätt som vid beräkningen av FILTER O, med den skillnaden att vid beräkningen av data_addr används filter_addr(l) och ett index = 2 i utgångsläget.

FILTER 2 beräknas på samma sätt som den rekursiva delen för FILTER 1, med den skillnaden att filter¿addr(2) används för 463 säs 9 beräkningen av data_addr och dl, dz används som koefficien- ter. I utgångsläget sätts index = 2. När index nått värdet O skrivs resultatet W(n) över värdet Y(n-2).

Alla dessa beräkningar genomförs i det läge som visas i fig. 4(a). Vid övergång till fig. 4(b) minskas mod_pointer med 1 och ökas n med 1, så att X(n) numera kallas X(n-1) osv. Nästa insig- nalvärde skrivs in i den position som betecknas X(n), varefter beräkningscykeln enligt ovan upprepas.

På detta sätt stegas mod_pointer ned en enhet för var och en av figurerna 4(a)-(h). När filtren beräknats i fig. 4(h) och mod_pointer skall uppdateras sker en vikning tillbaka till det läge som visas i fig. 4(a), varefter hela proceduren upprepas.

Av ovanstående inses att buffertens minnesarea utnyttjas på ett mycket effektivt sätt. I synnerhet kan bufferten adresseras modu- lo n, där n är ett godtyckligt positivt heltal. Denna metod har visat sig vara särskilt fördelaktig om många korta filter skall realiseras.

Nedan följer nu en beskrivning av en föredragen utföringsform av adressprocessorn under hänvisning till figurerna 5-7.

I enlighet med fig. 5 kan adressprocessorn logiskt uppdelas i tre olika delar. I den första, översta delen lagras buffertkonstan- terna. I den andra, mellersta delen utförs adressberäkningen. I den tredje, understa delen lagras slutligen adresserna för åtkomst av minnena vid lämplig tidpunkt.

För varje samplingsfrekvens, sample_rate, lagras en pekare mod_pointer. I den föredragna utföringsformen innehåller adress- processorn en registeruppsättning S innehållande fyra register för lagring av fyra olika värden på mod_pointer, ett för varje samplingsfrekvens och därmed varje buffert. I den föredragna ut- föringsformen är dessa register fem bitar långa. En dekremente- ringskrets DEC, exempelvis bildad av halvsubtraherare, dekremen- 465 393 10 terar en vald pekare och laddar tillbaka densamma i motsvarande register efter användning enligt ovan. När pekaren når värdet O, dvs. när en vikning av bufferten är aktuell, laddas en konstant i registret. Denna konstant kan vara hårdvirad på registeringång- arna. Konstantens värde är mod_numb-l, där'mod_numb är buffertens längd. En dekrementering av mod_pointer göres när signalen dec_mod_count är hög. En vald pekare laddas i ett register mod_reg innan den dekrementeras eller laddas i beräkningsdelen.

Konstanterna för buffertstorlek och buffertplacering i minnet kan även vara hårdvirade på registeringångarna. Signalen sample_rate väljer de konstanter som svarar mot en viss samplingsfrekvens för laddning i de olika registren. Varje register innehåller i den föredragna utföringsformen fyra ingångar D1-D4, en för varje samplingsfrekvens. Konstanten för buffertstorleken, mod_numb, laddas såsom ett två-komplementvärde, dvs. såsom -mod_numb.

Konstanten laddas i ett fem bitar långt register mod_num_reg.

Konstanten för buffertens placering i minnet laddas såsom mod_start i ett register mod_sta_reg med ordlängden sex bitar.

Beräkningsdelen består av två register A_reg, som är sex bitar långt, B_reg, som är fem bitar långt och en sex bitars adderare, exempelvis en s.k. carry boost adder, där adderarens mest signi- fikanta bit är en halvadderarcell.

Adressberäkningen börjar med laddning av antingen data_addr eller write_addr i B_reg, i beroende av om en läsning eller skrivning skall ske. A_reg laddas med antingen mod_pointer från mod_reg på ingången.D2 eller O på ingången Dl. Laddningen av registret A_reg styrs av en.modulodeaktiverande signal mod_dis i beroende av vald adressmod, antingen modulo- eller absolut adressering.

I absolut adresseringsmod (mod_dis är hög) laddas O i registret A_reg, så att den inmatade adressen, data_addr eller write_addr adderas till O. Detta. gör' beräkningsenheten transparent för absolut adressering. 465 3§3 ll I modulo-mod adderas den i A_reg laddade mod_pointer till den i B_reg laddade adressen, data_addr eller write_addr. Resultatet återmatas till registrets B_reg ingång D3.

Det i registret mod_num_reg laddade två-komplementvärdet av mod_numb, dvs. -mod_numb, överförs till registret A;reg och adderas till innehållet i registret B_reg. Resultatet laddas i B_reg om resultatet är icke negativt. Om resultatet är negativt sparas det gamla värdet i registret B_reg för nästa operation.

Genom att registret mod_num_reg laddats med två-komplementet av mod_numb, dvs. -mod_numb, förenklas hela denna testprocedur genom att tecknet för resultatet av additionen direkt kan utläsas ur den mest signifikanta biten i resultatet. Denna bit styr via ledningen +/- tillsammans med de i fig. 7 visade signalerna CHSST och IXZ laddningen av registret B_reg.

Den från registret mod_sta_reg till registret A_reg överförda konstanten mod_start adderas i nästa steg till innehållet i registret B_reg, och resultatet lagras i ett register RREG för en läsoperation eller i registret WREG för en skrivoperation.

Detta är~den slutliga minnesadressen för läsning eller skrivning.

Vid koefficientläsning, där absolut adressering används, matas koefficientadressen coe_addr direkt till ett register CAREG.

Den nedersta delen av adressprocessorn, vilken är avsedd för adresslagring och åtkomst av minnet, består av fem stycken sex bitar långa register. Registren RREG och WREG har redan omnämnts och innefattar endast en ingång Dl. Registren DAREG och CAREG är förbundna med dataminnesbussen DMADDRSST resp. koefficientminnes- databussen.CMADDRSST. Det femte registret, FBREG, lagrar läs- och skrivadresser på ett cykliskt sätt. Adresserna återmatas från utgångsbussarna CMADDRSST resp. DMADDRSST på motsvarande ingångar D1 och D2. Återmatningen styrs av signalerna PDMWSST och PCMWSST i fig. 7. 465 393 12 Återkopplingsadresseringsschemat används endast när adresspro- cessorn omväxlande ger skriv- och läsadresser. Detta inträffar när en filterberäkning är avslutad och resultatet skrivs in i en minnescell samtidigt som en ny filterberäkning påbörjats för nästa filter och data läses från minnet för denna beräkning.

Skrivning sker när CHSST är jämn och läsning sker när CHSST är udda, se fig. 6 (i fig. 6 och 7 står R för läsning och W för skrivning).

I den föredragna utföringsformen av uppfinningen behandlas åtta kanaler i en cyklisk läs/skrivprocess. Två kanaler behandlas samtidigt, så att sista läsning/skrivning kommer att ske i cyklerna 6 och 7.

För en mera detaljerad beskrivning av funktionen av den föredrag- na utföringsformen av adressprocessorn enligt föreliggande upp- finning hänvisas till efterföljande signaldefinitioner för adressprocessorn samt den därefter följande simuleringen av adressprocessorn i Texas Instruments simuleringsspråk RTL. .ta- CN ._ xp ~ 04 13 Signaldefinitioner för Adressprocessor Signaler och variabler som slutar på "sst" betyder att värdena är "Stabila" på "Slav“ ("True") tillståndet.

BUS 8 chsst; # SIGNAL izlsst; # SIGNAL iz6sst; # SIGNAL iz7sst; # SIGNAL pdmwsst; # SIGNAL pcmwsst; # Styr laddning av utgångsregistren SIGNAL cwsst; # -klockfasen och befinner sig i det sanna Kanalval (Channel Select).

Index Noll och chsst grindas. IXZ går till hög nivå när sista sampel läses från minnet.

Förbered skrivning i dataminnet (Prepare Data Memory Write).

Förbered skrivning i koefficientminnet (Prepare Coefficient Memory Write). data- och koefficientskrivadresser i DAREG, CAREG och FBREG.

Koefficientskrivmod (Coefficient Write mode).

Inställer adressprocessorn i absolut adressberäkningsmod.

Beräkning av skrivadressen för koefficientminnet börjar när denna signal går till hög nivå. 465 393 14 “apcsst" utgör en del av instruktionsordet som kommer från kontrollenheten.

BUS 23 apcsst; ll coe_addr data_addr write_addr apcsst[5:0]; apcsst[10:6]; apcsst[l5:11]; # Adressprocessorstyrning (Address Processor Control). # 6-bit Koefficientadress. # 5-bit Dataadress. # 5-bit Skrivadress.

Data- och skrivadresser dekrementeras med 1 varje gång indexräknaren dekrementeras. Indexräknaren laddas med filterlängden "number_of_taps". Allt detta göres i kontrollenheten. dec_mod_count mod_en_r sample_rate_r mod_en_w sample_rate_w II ll apcsst[l6]; apcsst[l7]; apcsst[l9:18]; apcsst[20]; apcsst[22:2l]; # 1-bit # 1-bit # 2-bit # 1-bit # 2-bit Styrsignal för dekrementering av moduloräkna- ren.

Friger modulo adressberäkning, läsmod.

Väljer cirkulär buffert, läsmod.

Friger modulo addressberäk- ning, skrivmod.

Väljer cirkulär buffert, skriv- mod.

SIGNAL lst? SIGNAL lmtï # Lokal Slavklocka sann (True).

# Lokal Masterklocka sann (True). 465 së3 15 SIGNAL ltt; # Lokal Testklocka sann (True).

SIGNAL lgsrlltt; # Lokal testklocka för Global avsöknings- kedja.

SIGNAL lscanisst; # Testavsökning lokal insignal (Test scan Local Input).

SIGNAL gscanisst; # Testavsökning global insignal (Test scan Global Input).

SIGNAL lscanosst; # Testavsökning lokal utsignal (Test scan Local Output).

SIGNAL gscanosst; # Testavsökning global utsignal (Test scan Global Output).

BUS 6 dmaddrsst; # Dataminnesadress.

BUS 6 cmaddrsst; # Koefficientminnesadress.

Lokala Variabler REG 6 d_a_reg; # Dataadressregister DAREG.

REG 6 c_a_reg; # Koefficientaddressregister CAREG.

REG 6 w_del_reg_m; # Skrivfördröjningsregister master WREG.

REG 6 w_del_reg_s; # Skrivfördröjningsregister slav.

REG 6 r_del_reg_m; # Läsfördröjningsregister master RREG.

REG 6 r_de1_reg_s; # Läsfördröjningsregister slav.

REG 6 feedback_reg_m; # Återkopplingsregister master FBREG.

REG 6 feedback_reg_s; # Återkopplingsregister slav. =ß= REG 6 a_reg; Ingångsregister till Adderare.

REG b_reg; # Ingångsregister till Adderare.

Ch REG REG REG REG REG FF FF FF FF 465 395 00000101 mod_reg_m; mod_reg_s; mod_numb_reg_m; mod_numb_reg_s; mod_start_reg_m; mod_start_reg_s; 16 Modulopekarregister master.

Modulopekarregister slav.

Modulonummerregister master.

Modulonummerregister slav.

Modulostartregister master. åtåtititflhåt Modulostartregister slav.

Index noll grindad med kanalvalstidslucka 7. iz7_dell_m; iz7_del1; iz7_del2_m; iz7_del2; REG 5 mod_a_reg_m(4); REG 5 mod_a_reg_s(4); REG 6 sum; SIGNAL mod_dis; BUS 2 sample_rate; ROM 5 mod_numb(4); ROM 6 mod_start(4); # Index noll fördröjningsvippa master.

# Index noll fördröjningsvippa slav.

# Index noll fördröjningsvippa master.

# Index noll fördröjningsvippa slav. # ät Modulopekarregisterstack master ( mod_numb-1 ) .

Modulopekarregisterstaok slav.

Utgångsbuss från adderaren.

Modulospärr, absolut adressing om sann.

Samplingsfrekvens. Väljer circulär buffert i beroende av samplings- frekvens. 4, 5-bitars Modulonummerkonstanter ( -mod_numb ). 4, 6-bitars Modulostartkonstanter.

BLOCK add INPUT INPUT INPUT INPUT INPUT INPUT INPUT INPUT co 46 säs C u 17 SIMULERING AV ADRESSPROCESSOR I RTL rpr ( BUS 8 chsst; SIGNAL izlsst7 SIGNAL iz6sst7 SIGNAL iz7sst; SIGNAL pdmwsst SIGNAL pcmwsst SIGNAL CWSSt; BUS 23 apcsst; e_addr data_addr write_addr dec_mod_count mod_en_r än än # Channel Select # Index Zero # Prepare Data Memory write # Prepare Coefficient Memory write # Coefficient write # Address processor Control apcsst[5:0]; #6-bit Coefficient #5-bit Data address #5-bit #1-bit #1-bit apcsst[10:6]; apcsst[l5:11]; apcsst[l6]; Write address Contr. sign. apcsst[17]; Enable read sample_rate_r = apcsst[19:18]; #2-bit Select read mod_en_w = apcsst[20]; #1-bit Enable write sample_rate_w = apcsst[22:21]; #2-bit Select write INPUT SIGNAL lst; # Slave Clock INPUT SIGNAL lmt; # Master Clock INPUT SIGNAL ltt; # Test Clock Local INPUT SIGNAL lgsrlltt; # Test clock Global INPUT SIGNAL lscanisst; # Testscan Local Input INPUT SIGNAL gscanisst; # Testscan Global Input OUTPUT SIGNAL lscanosst; # Testscan Local Output OUTPUT SIGNAL gscanosst; # Testscan Global Output OUTPUT BUS 6 dmaddrsst; # Data memory address OUTPUT BUS 6 cmaddrsst;) # Coefficient memory address LOCAL REG 6 d_a_reg; # Data address register LOCAL REG 6 c_a_reg; # Coefficient address register LOCAL REG 6 w_del_reg_m; # Write delay register master LOCAL REG 6 w_del_reg_s; # Write delay register slave LOCAL REG 6 r_del_reg_m; # Read delay register master LOCAL REG 6 r_del_reg_s; # Read delay register slave 465 395 LOCAL REG 6 feedback_reg_m; LOCAL REG 6 feedback_reg_s; LOCAL REG 6 a_reg; LOCAL REG 6 b_reg; LOCAL REG 5 mod_reg_m; LOCAL REG 5 mod_reg_s; LOCAL REG 6 mod_numb_reg_m; LOCAL REG 6 mod_numb_reg_s; LOCAL REG 6 mod_start_reg_m; LOCAL REG 6 mod_start_reg_s; LOCAL FF iz7_de11_m; LOCAL FF iz7_dell; LOCAL FF iz7_del2_m; LOCAL FF iz7_del2; LOCAL REG 5 mod_a_reg_m(4); LOCAL REG 5 mod_a_reg_s(4); LOCAL REG 6 sum; LOCAL SIGNAL mod_dis; LOCAL BUS 2 sample_rate; ROM 5 mod_numb(4); ROM 6 mod_start(4); I-* CD åtitititåtåtätåtitfiâtitåtätfiätåtätåtitätätfiätåt Feedback register master Feedback register slave Input register adder Input register adder Modulo register master Modulo register slave Modulo number register master Modulo number register slave Modulo start register master Modulo start register slave Index zero delayed Flip Flop master Index zero delayed Flip Flop slave Index zero delayed Flip Flop master Index zero delayed Flip Flop slave Modulo register stack master Modulo register stack slave Output register adder Modulo disable Sample rate Modulo number constants Modulo start constants # ==================Z====================================2==== BEHAVIOR # Circular buffer constants, # ----------------------- -- mod_numb(0):=15; # 32 mod_numb(1):=16; # 16 mod_numb(2):=9; # 8 Sampling Frequency kHz, Buffer size kHz kHz ”å .Is c\ an ßfln vn- nu 19 mod_numb(3):=5; # 500 Hz mod_start(O):=49; # 32 kHz, Start address in memory mod_start(1):=33; # 16 kHz mod_start(2):=24; # 8 kHz mod_start(3):=20; # 500 Hz # =1==I=2ÉZ============================ÉÉÉZ=ÉÉ=ZÉ=====ÉZ==== # If true, absolute addressing mode # ------------------------------- -- mod_dis:=(“mod_en_w+cwsst)*(iz6sst+iz7sst+iz7_dell)+ 'mod_en_r*(chsst[3]+chsst[4]+chsst[5]); # ======================================================= # **** modulo counter **** samp1e_rate:=SELECT( chsst[5] : sample_rate_w; # Selects ELSE sample_rate_r ); # circular # buffer # Detect lmt edge, "decrement modulo counter" in "Index # zero 1" time slot # ----------------------------------------------------- -- IF lmt*“\lmt*dec_mod_count*izlsst IF mod_reg_s = O # Initialize buffer pointer mod_a_reg_m(samp1e_rate):=mod_numb(sample_rate) - 1; ELSE # Decrements buffer pointer mod_a_reg_m(samp1e_rate) := mod_reg_s - 1; END END IF lst # Master to Slave mod_a_reg_s(sample_rate):=mod_a_reg_m(sample_rate); END 465 393 # ==ÉÉÉ=É2:É=='É=É=:2Z=ÉZ===2==:ÉÉÉ==å====ï====šfåä==ïï=šää== IF lmt # Master Clock Phase iz7_dell_m:=iz7sst; # "Delay Index zero 7" 1 and 2 iz7_del2_m:=iz7_dell; # cycles respectively # Load modulo register from stack mod_reg_ :=mod_a_reg_s(sample_rate); IF ( chsst[2] + chsst[5] ) # Load buffer size mod_numb_reg_m:=(-mod_numb(sample_rate)); # Load buffer startaddress mod_start_reg_m:=mod_start(sample_rate); END # Load A and B registers with data # --------------------------------------------------- -- a_reg := SELECT ( (chsst[5]+chsst[0])*“mod_dis : mod_start_reg_s; (chsst[4]+chsst[7])*'mod_dis : mod_numb_reg_s; (chsst[3]+chsst[6])*“mod_dis : mod_reg_s; mod_dis : OXOO; # absolute addressing mode ELSE \a_reg # Keep old data in reg. A b_reg := SELECT ( chsst[3] : data_addr; izösst : write_addr; 'sum[5]*(chsst[4]+chsst[5]+iz7sst+iz7_del1) : sum; ELSE \b_reg # Keep old data in reg. B Lä? 465 áè3 21 IF chsst[6] r_del_reg_m := sum; # Load "read delay register" END # with calculated address RREG IF iz7_ae12 w_del_reg_ := sum; # Load "write delay register" END # with calculated address WREG # --------------------------------------------------- -- # **** Load coefficient address CAREG **** c_a_reg := SELECT ( iz7sst*pcmwsst : w_del_reg_s; # WREG chsst[0] : coe_addr; # External address “iz7sst*“chsst[0]*pcmwsst : feedback_reg_s ; ELSE \ c_a_reg # --------------------------------------------------- -- # **** Load data address DAREG **** d_a_reg :=SELECT ( iz7sst*pdmwsst : w_del_reg_s: # WREG chsst[0] : r;del_reg_s; # RREG “iz7sst*'chsst[O]*pdmwsst : feedback_reg_s; ELSE \ d_a_reg ); # --------------------------------------------------- -- # **** Load Feedbacked address FBREG **** feedback_reg_m :=SELECT ( pdmwsst : dmaddrsst; # Data mem. addr. pcmwsst : cmaddrsst; # Coeff. mem. addr.

ELSE \ feedback_reg_m END # lmt 465 593 22 # ======================================================= # Master to Slave Transfer # ----------------------- -- IF lst mod_reg_s := mod_reg_m; mod_numb_reg_ := mod_numb_reg_m; mod_start_reg_s := mod_start_reg_m; sum := a_reg + b_reg; # Calculate r_del_reg_s := r_del_reg;m; w_del_reg_s := w_del_reg_m; feedback_reg_s := feedback_reg_m; dmaddrsst = d_a_reg7 # Put data address on bus cmaddrsst := c_a_reg; # Put coefficient address on bus iz7_dell := iz7_dell_m; iz7_del2 := iz7_del2_m; END # 1st END # behavior Det inses att uppfinningen ej är begränsad till de specifikt beskrivna utföringsformerna, utan att många olika modifieringar kan vidtagas av fackmannen. Sålunda kan.exempelvis buffertlängden minskas med ett, så att den blir summman av antalet fördröjnings- element i de i bufferten ingående filtren, om det senaste samp- lingsvärdet X(n) istället lagras i ett extra register. Vidare kan antalet kanaler, antalet buffertar i varje kanal, ordlängden för de olika registren och sättet att ladda konstanter i de olika registren varieras utan avvikelse frán uppfinningens grundtanke som definieras i de bifogade patentkraven.

Q;

Claims (9)

1. (a) (b) 43:. CN U1 Lflü ND LN 23 PATENTKRAV Adressprocessor för en signalprocessor, k ä n n e t e c k n a d av organ för adressberäkning i ett skriv/ läs-minne innehållande åtminstone en cirkulär buffert för lagring av digitala fil- ters tillståndsvariabler (X(n), X(n-1), ...; Y(n), Y(n-1), ...; W(n), W(n-1), ...), varvid åtminstone en buffert inne- håller tillståndsvariablerna för åtminstone två digitala filter, alla filtren i samma buffert svarar mot samma samp- lingsfrekvens (sample_rate) och buffertlängden (mod_numb) beror av summan av antalet fördröjningselement i de mot respektive buffert svarande filtren, vilka organ innefattar: en uppsättning (S) register för lagring av den aktuella vikningsadressen (mod_pointer) för varje cirkulär buffert relativt buffertens absoluta startadress (mod_start); och en beräkningsenhet (+) för utförande av stegen (1) addering av den aktuella vikningsadressen (mod_pointer) till en vald tillståndsvariabels (X(n), X(n-1), ...; Y(n), Y(n-1), ---: W(n), W(n-1), (data_addr, write_addr) relativt motsvarande bufferts ...) förskjutning startadress (mod_start), (2) reducering av den i steg (1) erhållna summan (data_addr + mod_pointer, write_addr + mod_pointer) med nämnda motsvarande bufferts längd (mod_numb) om summan över- skrider eller är lika med denna buffertlängd, och (3) addering av buffertens startadress (mod_start) till det i steg (2) erhållna resultatet för erhållande av den valda tillståndsvariabelns absoluta adress. 465 595 24

2. Adressprocessor enligt krav 1, k ä n n e t e c k n a d av att buffertlängden (mod_numb) utgöres av summan av antalet för- dröjningselement i de mot respektive buffert svarande filtren plus ett.

3. Adressprocessor enligt krav 1 eller 2, k ä n n e t e c k - n a d av att beräkningsenheten (+) utgöres av en adderare, var- vid den eventuella reduceringen i steg (2) utföres genom att två-komplementet av buffertlängden (-mod_numb) adderas till summan i steg (1).

4. Adressprocessor enligt krav 3, k ä n n e t e c k n a d av ett första register (A_reg) för lagring av den aktuella viknings- adressen (mod_pointer), två-komplementet (-mod_numb) av buffert- längden och buffertens startadress (mod_start) i sekvens efter varandra. _

5. Adressprocessor enligt krav 4, k ä n n e t e c k n a d av ett andra register (B_reg) för lagring av den valda tillstånds- variabelns (X(n), X(n-1), ...; Y(n), Y(n-1), ...; W(n), W(n-1), ...) förskjutning (data_addr, write_addr) relativt motsvarande bufferts startadress (mod_start), den i steg (1) erhållna summan och eventuellt det i steg (2) erhållna resultatet i sekvens efter varandra.

6. Adressprocessor enligt krav 5, k ä n n e t e c k n a d av att den mest signifikanta biten i adderaren (+) efter steg (2) utnyttjas som teckenbit och att det i steg (1) erhållna re- sultatet behålls i det andra registret (B_reg) om resultatet från steg (2) är negativt och att det i steg (1) erhållna resul- tatet i det andra registret (B_reg) ersätts med det i steg (2) erhållna resultatet om detta ej är negativt.

7. Adressprocessor enligt något av föregående krav, k ä n n e - t e c k n a d av att varje filter beräknas genom att filtrets tillståndsvariabler (X(n), X(n-1)...; Y(n), Y(n-l)...; W(n), W(n- l)...) och motsvarande koefficienter hämtas i sekvens efter var- UI» 465 393 25 andra med hjälp av ett index, som är lika med antalet fördröj- ningselement i filtret, varvid nämnda index adderas till filtrets startposition för erhållande av den äldsta tillståndsvariabeln och motsvarande koefficient och sedan stegas ned till O för er- hållande av allt yngre tillståndsvariabler.

8. Adressprocessor enligt krav 7, k ä n n e t e c k n a d av att värdet av ett beräknat filter skrivs in i minnesposi- tionen för den äldsta tillståndsvariabeln i föregående filter, så att denna minnesposition återanvänds.

9. Adressprocessor enligt något av föregående krav, k ä n n e - t e c k n a d av att registeruppsättningen (S) innehåller fyra register.