ISRN UTH-INGUTB-EX-E-2011/02-SE

Examensarbete 15 hpMars 2011

Utveckling av projektlaboration för signalbehandling med digital signalprocessor programmerad

med LabVIEW och Matlab

Jonas MäkiHandledare: Tomas OlofssonÄmnesgranskare: Tadeusz StepinskiExaminator: Nora MassziInstitution: Signaler och System

Teknisk- naturvetenskaplig fakultet UTH-enheten Besöksadress: Ångströmlaboratoriet Lägerhyddsvägen 1 Hus 4, Plan 0 Postadress: Box 536 751 21 Uppsala Telefon: 018 – 471 30 03 Telefax: 018 – 471 30 00 Hemsida: http://www.teknat.uu.se/student

Abstract

Utveckling av projektlaboration för signalbehandling med digitalsignalprocessor programmerad med LabVIEW och MatlabDevelopment of project laboration for signalprocessing with digital signal processor programmedwith LabVIEW and MatlabJonas Mäki

This report describes how to process audio signals in real time with a digital signalprocessor. The digital signal processor used in the thesis and described in the reportare the Blackfin processor ADSP-BF537 from Analog Devices.

In the body of this report there is theory of the processor characteristics and thevarious programming languages used. All experiments that were made on theprocessor are described, these descriptions also help in understanding the annexeswhere the experiments will be presented. The body of this report also describes theprogram used to do experiments. Testing the CPU limit was done and the results arepresented to get a good view of what it can handle. The tests were ruling the use forwhich the processor will be used in the course of signal processing. A Introductionlaboration going through settings on the processor and a simple signal processingapplications is described. The guide is also attached to the end of the report (seeAnnex 1 for Introduktionslaboration i LabVIEW, page 20). Implementation of the labare done with both LabVIEW and Matlab on the processor. This was tested to seewhich program was most appropriate to use. The pros and cons of both programsare described.

The final section of the report mentioned observations of the problems encounteredand suggestions for how to proceed in the future. Options other than the processorused in this thesis are mentioned and described. References to information sourceson the Internet were information was gathered and used to program the processor isindicated. Finally the report ends with appendices, where each step is described in theexperiments that was implemented on the processor. Even more specific informationabout how everything will be implemented in the programs are described and theadvantages and disadvantages they have.

ISRN UTH-INGUTB-EX-E-2011/02-SEExaminator: Nora MassziÄmnesgranskare: Taduesz StepinskiHandledare: Tomas Olofsson

1

Sammanfattning Denna rapport beskriver hur man med en digital signalprocessor kan behandla

ljudsignaler i realtid. Den digitala signalprocessorn som används i examensarbetet och

beskrivs i rapporten är Blackfinprocessorn ADSP-BF537 från Analog Devices.

I rapportens huvuddel finns teori för processorns egenskaper och de olika programspråk

som används. Alla experiment som gjordes på processorn finns beskrivna, dessa

beskrivningar hjälper även till för förståelsen till bilagorna där experimentens gång

redovisas. Huvuddelen beskriver också vilka program som användes för att göra

experimenten. Test av processorns begränsning gjordes och resultatet presenteras för att

få en bra bild av vad den klarar av. Testen var avgörande för vilket användningsområde

processorn kommer att kunna användas till i kursen för signalbehandling. En

introduktionslaboration som går igenom inställningar på processor och ett enkelt

signalbehandlingsprogram finns beskrivet. Guiden finns även bifogad sist i rapporten

(se bilaga 1 under Introduktionslaboration i LabVIEW, sida 20). Implementation av

laborationen gjordes på processorn både med LabVIEW och med Matlab. Detta testades

för se vilket program som var mest lämpligt att använda. För- och nackdelar för båda

programmen redovisas.

I den avslutande delen av rapporten nämns observationer för de problem som uppstått

och förslag för hur man kan gå vidare i framtiden. Andra alternativ än den processor

som används i detta examensarbete tas upp och beskrivs. Referenser till

informationskällor på internet anges där information hämtats och använts för att

programmera processorn. Slutligen avslutas rapporten med bilagor där varje steg

beskrivs i de experiment som implementerades på processorn. Även mer specifik

information om hur allt ska implementeras i programmen beskrivs för båda

programmen samt vilka för- och nackdelar de har.

2

Förord Examensarbetet utfördes på Signaler och System vid Uppsala universitet som är en del

av institutionen för teknikvetenskaper. Examensarbetets syfte är att ta fram ett bra

laborationsinstrument för signalbehandling i realtid som ska programmeras genom

LabVIEW eller Matlab. Rapporten beskriver vilka typer av instrument som ska

användas, hur de ska programmeras och med vilka program. Implementeringen av de

olika projekten som skulle göras på instrumentet finns beskrivna i bilagor.

Jag vill tacka Tomas Olofsson som varit min handledare under detta examensarbete.

Tomas som gett mig möjligheten att få göra detta arbete har också hjälpt mig att förstå

mycket av den signalbehandling som skulle utföras på processorn. Jag vill också tacka

Tadeusz Stepinski som varit min ämnesgranskare och även tillhandahållit programvara

för att utföra arbetet. Nora Masszi vill jag tacka för att hon visade mig en guide, skriven

av Kennet Axelsson och Lars Degerman, som jag kunde använda för att skriva den här

rapporten. Nora är även min examinator.

Huvudförfattare av rapporten är Jonas Mäki och Anders Barkander har varit med och

skrivit inledning och bakgrund.

Uppsala juli 2010

Jonas Mäki

3

Innehållsförteckning Sammanfattning ................................................................................................................ 1

Förord ................................................................................................................................ 2

Innehållsförteckning .......................................................................................................... 3

1. Inledning ....................................................................................................................... 5

2. Bakgrund ....................................................................................................................... 5

3. Uppgiftsbeskrivning ...................................................................................................... 6

4. Utvecklingsmiljö ........................................................................................................... 7

4.1 Om ADSP-BF537 EZ-KIT lite ............................................................................... 7

4.2 Om LabVIEW ......................................................................................................... 7

4.3 Om Matlab .............................................................................................................. 7

5. Experiment .................................................................................................................... 8

5.1 Skicka ljud genom processorn ................................................................................ 8

5.2 IIR-filter med LabVIEW ......................................................................................... 8

5.3 Decimering och interpolering med LabVIEW ........................................................ 9

5.4 Bearbetning av data via RS232 UART i LabVIEW ............................................. 11

5.5 IIR-filter med Matlab ............................................................................................ 11

5.6 Fördröjning med Matlab ....................................................................................... 11

6. Utförda och framtida undersökningar ......................................................................... 12

7. Observationer efter utfört examensarbete ................................................................... 13

7.1 Minneshantering .................................................................................................... 13

8. Resultat ........................................................................................................................ 13

9. Analys & slutsats ........................................................................................................ 13

10. Referenser ................................................................................................................. 15

11. Bilagor ....................................................................................................................... 15

LabVIEW för Blackfin .................................................................................................... 15

Några tips för att göra ett Blackfinprojekt .................................................................. 15

Introduktionslaboration i LabVIEW ........................................................................... 20

Implementation av ett IIR-filter .................................................................................. 21

Implementation av decimering och interpolering ....................................................... 23

File saver-program ...................................................................................................... 24

Lite om gränser ........................................................................................................... 25

4

Hur ställs filterkoefficienter in för olika VI’s? ........................................................... 25

Guide för Blackfin ADSP-BF537 med Matlab ............................................................... 26

Programmera ett reverb med Matlab........................................................................... 27

IIR-filter med Matlab .................................................................................................. 29

För och nackdelar med Matlab jämfört med LabVIEW ............................................. 30

RS232 UART kommunikation med LabVIEW .............................................................. 30

Utgående kommunikation med LabVIEW ................................................................. 30

Ingående kommunikation med LabVIEW .................................................................. 33

Skicka data till kortet .................................................................................................. 35

5

1. Inledning I dagens samhälle hittas digitala signalprocessorer i många olika produkter i olika

tillämpningar. Den kanske mest uppenbara tillämpningen är den inom ljudfiltrering. Det

kan röra sig om allt ifrån små mp3-spelare till stora ljudanläggningar som används vid

konsertevenemang. Tillämpningen ställer krav på den digitala signalprocessor som ska

användas. För mp3-spelare och andra bärbara enheter är batteritid en viktig faktor och

processorn bör därför vara strömsnål medan en stereoanläggning i hemmet med tillgång

till elnätet inte alls ställer samma krav på strömförbrukning. Prestanda och

strömförbrukning har en direkt koppling till varandra och det gäller därför att välja

processor till sin specifika tillämpning med omsorg. Digitala signalprocessorer har

också många andra tillämpningsområden, det kan t.ex. handla om att filtrera bort eller

hitta en signal dold i brus.

Vid utveckling av program för digitala signalprocessorer används ofta lågnivåspråk som

t.ex. C eller assembler. Att programmera mjukvara med dessa språk kräver dock

kunskap och det kan ta tid att utveckla ett program. Många personer har kunskap inom

signalbehandling, men saknar den kunskap som krävs för att programmera

signalbehandlingstillämpningar i C. Att kunna ta fram mjukvara för digitala

signalprocessorer med hjälp av mer lättanvända verktyg är därför av intresse.

Studenter som läser signalbehandling på Uppsala universitet får i dagsläget ingen

möjlighet att praktiskt utöva sina kunskaper. För att studenterna ska få en bättre

förståelse och insikt i området kan implementering av de olika delmomenten i kursen

göras på hårdvara. Problemet är dock att studenterna inte nödvändigtvis har någon

tidigare erfarenhet av programmering i C. För att studenterna ska få möjlighet att ändå

göra detta behövs därför något verktyg.

Det finns ett antal signalprocessorer som tillåter att ett mer grafiskt gränssnitt används

för framtagning av mjukvaran. Två program som stöder detta är LabVIEW och Matlab

och det är dessa alternativ som kommer att utvärderas i detta arbete.

Målet med arbetet är att utvärdera de verktyg som finns tillgängliga och ta fram enkla

program som exekveras på den hårdvara som ska användas. Detta är algoritmer så som

FIR- och IIR-filtrering samt FFT. Även tillämpningar som använder sig av dessa

metoder ska implementeras på hårdvaran och utvärderas för de utvecklingsverktyg som

används. Om tid finns kommer även mer avancerade tillämpningar att implementeras.

2. Bakgrund Kursen signalbehandling har tidigare varit mindre praktisk och ska nu ändras något.

Den nya något större kursen är tänkt att innefatta mer praktiska moment än den tidigare

kursen. De praktiska inslagen handlar om att implementera olika

signalbehandlingsalgoritmer på en digital signalprocessor. På så sätt får studenterna en

mer inspirerande signalbehandlingsupplevelse och de får dessutom tillfälle att lära sig

6

verktyg som kan vara användbara i yrkeslivet. Tanken är att utnyttja LabVIEW och

Matlab som plattform.

3. Uppgiftsbeskrivning – Hitta en lämplig processor som går att programmera med LabVIEW och Matlab.

– Ställa in korrekt inställningar för att optimera för hastighet på processorn.

– Implementering av enkel talk through(ljud in/ut), IIR-filter samt decimering och

interpolation.

– Ta fram en introduktionslaboration för enkel filtrering.

– Syftet med enkel talk through är att få en förståelse och bättre

uppfattning om lämpliga bufferstorlekar att arbeta med. Samt att se vilken

svårighetsgrad det är att programmera processorn. Implementering av IIR-

filter gjordes med avsikt att göra en lätt introduktionslaboration. Även för

att se begränsningar för processorn till eventuella projekt som ska

implementeras. Decimering och interpolering undersöktes för att utöka

kapaciteten för signalbehandling genom att få längre beräkningstider.

Avsikten med hela projektet är att kunna använda materialet i kursen

signalbehandling. För att ge studenterna en djupare förståelse och en mer

praktiskt bild av signalbehandling.

– Signalbehandling kan behöva göras för att representera en signal eller

manipulera en signal för att åstadkomma önskad effekt på den. Det går

t.ex. att behandla en signal för att undertrycka buller i en industriell miljö

som kommer från en motor eller liknande.

Den information som behövs för att lösa de problem som uppstår hämtas från datablad

och andra informationskällor på internet. Eventuell signalbehandlingskunskap ges av

böcker, internet alternativt handledare.

7

4. Utvecklingsmiljö Lite fakta om processorn som använts samt de programspråk som använts för att

programmera processorn.

4.1 Om ADSP-BF537 EZ-KIT lite ADSP-BF537 EZ-KIT lite är utvecklingskortet som används för examensarbetet. Nedan

nämns några av de viktigaste parametrarna vilka finns lite mer utförligt beskrivna i

datablad under referenser (se Referenser[1], sida 15).

Processor: ADSP-BF537 Blackfin processor.

Maximal processorhastighet: 600 MHz.

ADC: samplingsfrekvens 48kHz 3,5mm stereoingång.

DAC: samplingsfrekvens 48kHz med 3,5mm stereoutgång.

Frekvensen för de analoga omvandlarna är fast.

RS-232 UART port används för kommunikation med processorn under exekvering. Den

har snabbare och även bättre precision än USB för debugningsmöjligheter.

Programmeras via USB som även kan används för debugläge.

Programmeras med Analog Devices VisualDSP++ i C/C++ kod. Både LabVIEW och

Matlab sköter denna kompilation till C/C++ automatiskt. VisualDSP++ skriver sedan

ner koden på processorn.

4.2 Om LabVIEW LabVIEW är ett grafiskt programmeringsspråk som har ett unikt exekveringssätt. De

flesta programspråk exekverar rad för rad i ett program och kan hoppa till andra rader

beroende på olika villkor som programmeras. LabVIEW fungerar på ett lite annorlunda

sätt jämfört med Matlab och Simulink. I dessa textbaserade program exekveras rad efter

rad. LabVIEW exekverar det block som är klart att exekveras så fort det går, alltså när

all indata finns tillgänglig för en viss operation. LabVIEW har en avancerad arkitektur

för att exekvera sin programkod så parallellt som möjligt och med dagens nya

flerkärniga processorer så processas koden ännu snabbare och optimalare i flera trådar i

processorkärnorna. En fördel med LabVIEW gentemot andra programspråk är att man

också minskar implementationstid för olika projekt eftersom det är grafiskt och väldigt

lättanvänt. Det största användningsområdet för LabVIEW är mätning, kontroll, styrning,

test och simulering av olika system. Det är ett väldigt flexibelt programmeringsspråk

som går att använda i många tillämpningar och det finns väldigt mycket verktyg som

tillägg för ytterligare programmeringsfunktioner. Begränsningarna sitter ofta hos

programmeraren.

4.3 Om Matlab Matlab är ett program med ett programmeringsspråk mer likt ett scriptspråk som man

kan använda för tekniska beräkningar såsom matematiska beräkningar, analys m.m. Det

finns också möjlighet att göra test-, mät-, kontrollsystem och även simulerade system.

Matlab jämfört med LabVIEW har lite mer begränsningar att kopplas mot hårdvara.

8

Man kan designa filter både med algoritmer och olika toolboxar, vilket utnyttjades i

detta examensarbete. Det finns en uppsjö med olika verktygstillägg för olika

applikationer. De som används i detta arbete är Simulink och verktygstillägg till det

som heter signal processning samt embedded systems som är till för signalprocessorer.

Simulink är Matlabs programtillägg där man kan göra avancerade test-, mät-,

kontrollsystem och simulerade system. Programmeringen i Simulink är grafiskt ungefär

som med LabVIEW.

5. Experiment Det här avsnittet beskriver vad som gjordes i examensarbetet. Syfte för implementation

för de olika delarna beskrivs för att ge en tydligare bild av de bilagor som hänvisas till

för implementering av projekten.

5.1 Skicka ljud genom processorn Efter att ha kollat upp hur processorn ska programmeras så gjordes en enkel applikation

som bara tar in en ljudsignal på AD-omvandlaren. Utan någon bearbetning skickas den

ut på DA-omvandlaren för att se om den enklast möjliga implementation fungerar som

den ska. Processorn och viktiga komponenter beskrivs under Utvecklingsmiljöavsnittet

(se 4.1 Om ADSP-BF537 EZ-KIT lite, sida 7 och även data blad under 10.

Referenser[1], sida 15)

Syftet för detta test var för att få en bra uppfattning om implementationstid och även

komplexitet i programmeringen. Det ansågs även vara en bra grund att bygga vidare

större projekt på.

I bilagorna finns en guide för att programmera denna ”Talk through” (skicka ljud in/ut)

(se Bilaga 1 LabVIEW för Blackfin, sida 15). En detalj som iakttas är att alltid se till att

använda rätt datatyper för de block som används. Bufferstorlek är också en annan viktig

parameter, som inte bör göras för liten. Då kommer inte processorn att hinna med att

göra den bearbetning av signalen som ska göras. Den får dock inte ställas för högt, då

uppträder ljudet fördröjt och då mister man hela syftet med att göra behandlingen av

ljudet i nutid.

5.2 IIR-filter med LabVIEW Ett IIR-filter implementeras i programmet som bara skickar ljudet från ingången till

utgången. Detta IIR-filter har i uppgift att lägga till reverb på den mottagna signalen. Att

lägga till reverb på en signal innebär att digitalt härma rumsklanger. Detta görs med

hjälp av flera fördröjda sampels av första ekot under flera sekunder där amplituden

försvagas med tiden. Det kommer alltså låta som väldigt mycket eko.

Överföringsfunktion för ett IIR-filter med N sampels fördröjt eko.

1

1−𝑎𝑁𝑧−𝑁 där 𝑎𝑁 är koefficienten som matas in i IIR-filtret och 𝑧−𝑁 beskriver

tidsfördröjningen med N antal steg.

9

Kopplar man flera parallella filter enligt ovanstående överföringsformel med olika

mycket förstärkning och fördröjning av alla sampel kommer man att höra ett reverb.

Detta filter implementerades på processorn för att först och främst få en

introduktionsguide som kan användas till kursen signalbehandling. Men även som med

det första experimentet där bara ljud skickades genom processorn se vilka svårigheter

som uppkommer samt se vilken tid ett enkelt projekt som detta skulle ta att göra.

Viktiga anmärkningar vid implementation av IIR-filter är som ovan att se till att

datatyper är korrekta samt att använda sig av de block som ligger under Blackfin i

funktionspaletten, eftersom de är mer optimerade för processorns arkitektur. Vissa av de

vanliga operationerna går inte att kompilera ned på processorn. De vanligaste går bra att

använda men kan dock i vissa fall ge en liten förlust i hastighet. De vanligaste

operationerna fungerar dock utmärkt, t.ex. de enkla matematiska operationsblocken. I

bilagor beskrivs mer utförligt hur IIR-filtret ska implementeras med koefficienter och

andra viktiga parametrar samt vilka block som är snabbast(se Hur ställs

filterkoefficienter in för olika VI’s? sida 25). För att se hur IIR-filter implementeras (se

Introduktionslaboration i LabVIEW sida 20).

5.3 Decimering och interpolation med LabVIEW För att kunna göra längre och mer krävande filter så undersöktes decimering och

interpolation av signalen. Detta gjordes med redan färdiga operationsblock som är

optimerade för processorn. Det som ska ställas in är storleken på decimeringsfaktor

samt FIR-filterkoefficienter för att kunna filtrera bort de frekvenser som inte går att

bearbeta efter decimering. Efter att decimering är utförd på signalen kan man behandla

signalen fast då med mer krävande processning eftersom man tagit bort en del av de

sampel som ursprungligen fanns i signalen. Interpolationen görs sedan för att ta upp

signalen till den ursprungliga bufferstorleken och samplingsfrekvens som användes.

Figur 5.0 flödet vid decimerings- och interpolationsprocessen.

Bilden ovan beskriver hur förloppet vid decimering och interpolation av en signal

fungerar. LP står för lågpassfiltrering, M står för decimerings och interpoleringsfaktor

och Proc. står för processning. Det första lågpassfiltret är för att undvika

vikningsdistortion och det andra lågpassfiltret används för att jämna ut signalen efter att

ha återupptagit alla sampels efter interpolationen. Vid decimering så lågpassfilterar man

först för att inte få störningar från högre frekvenser som efter nedsamplingen inte ger

någon intressant information annat än störningar. Efter det steget så samplar man ned

signalen genom att ta bort ett visst antal sampel mellan de sampel man ska behålla. Hur

många sampel man ska ta bort bestäms av decimeringsfaktorn. 𝑓𝑛𝑦 =𝑓𝑠

𝑀 där 𝑓𝑠 är den

ursprungliga frekvensen 𝑓𝑛𝑦 är den nya frekvensen vid decimering om decimerings

10

faktorn är M. Antalet sampel som är kvar efter decimering är 𝑁

𝑀 Där N står för antal

sampel ursprungligen i signalen och M för decimeringsfaktor. I figur 5.1 illustreras

förloppet vid decimering grafiskt.

Figur 5.1 förloppet av decimering av en signal

Vid interpoleringen så lägger man till de sampels som togs bort vid decimeringen, dessa

nya sampels ges värdet noll och det är därför man lågpassfiltrerar signalen. Efter

lågpassfiltrering kommer signalen bli mer jämn och de värden som lagts till har fått nya

värden som representerar kurvan på ett mer realistiskt sett. Detta görs för att få tillbaka

den frekvens signalen hade från början. Figur 5.2 nedan beskriver förloppet av

interpolering grafiskt.

Figur 5.2 förloppet av interpolering av en signal. I bilden till vänster har lågpassfiltreringen inte utförts

och bilden till höger har signalen lågpassfiltrerats.

Syftet med detta är alltså att få längre tid att utföra bearbetning av signalen så att större

projekt kan göras.

I guiden för LabVIEW under bilagor (se Implementation av decimering och

interpolation, sida 22) beskrivs hur decimering och interpolationblocken ska ställas in

och implementeras på ett korrekt sätt. Försök att implementera detta i Matlab gjordes

utan några positiva resultat. De block som utförde decimeringen och interpolationen tog

för lång tid att exekvera.

11

5.4 Bearbetning av data via RS232 UART i LabVIEW Till kursen signalbehandling finns önskemål att kunna ändra parametrar under

exekvering. Filterparametrar vill man kunna styra för att få ett varierande resultat på

utsignalen. Denna seriella kommunikation med RS232 fanns tillgänglig på processorn

(ADSP-BF537 som beskrivs under 4. Utvecklingsmiljö, sida 7) och ansågs därför vara

ett lämpligt sätt att skicka data mellan processorn och dator.

Möjligheter att ändra parametrar under exekvering testades via RS232 UART (seriell

kommunikation). Det fungerade att göra, dock med förlust av bearbetningstid till andra

operationer. Detta var inte så optimalt att använda med LabVIEW. Eftersom det inte

fanns några stöd för avbrott som bestämmer att porten ska läsas då bufferten var fylld.

Man måste sätta en konstant tid som den skulle läsa efter, är inte bufferten full då så

kommer man att märka lite hack i ljudsignalen ut i väntan på att bufferten fylls.

Information om hur implementation i LabVIEW för ut- och ingående kommunikation

med LabVIEW samt kommunikation från dator till processorn finns beskrivet i bilagor

(se bilaga 3, RS232 UART kommunikation med LabVIEW, sida 29 och framåt).

5.5 IIR-filter med Matlab För att se skillnader mellan Matlab och LabVIEW så implementerades samma

introduktionslaboration i Matlabs Simulink. Innan ett IIR-filter implementerades så

testades även här som med LabVIEW att bara mata ljudet genom processorn utan

bearbetning för att se att allt fungerade. IIR-filter implementerades sedan väldigt snabbt

och enkelt med Matlabs inbyggda filterdesignblock. En nackdel med Matlab var dock

att man inte kunde använda fler än ca 30 koefficienter, vilket främst beror på att C-

koden som kompileras från Matlab inte är optimerad för Blackfinprocessorns arkitektur

men även på de väldigt många olika processorinställningarna, vilket inte helt hunnits

med att undersökas.

Syftet med detta är som med LabVIEW att göra en introduktionsguide som kan

användas i signalbehandlingskursen samt se vilken svårighetsgrad det är på

programmeringen samt vilken tid det tar att implementera programmet.

I bilagor finns beskrivet hur man ska göra för att implementera IIR-filter med Matlab

och mer information om filterkoefficienter samt för- och nackdelar (se Bilaga 2, IIR-

filter med Matlab, sida 29) och (se För och nackdelar med Matlab jämfört med

LabVIEW, sida 29).

5.6 Fördröjning med Matlab Då IIR-filter i Matlab inte klarade så många koefficienter som ett reverb krävde så

används delay sample-block för att uppnå samma effekt med liknande resultat som för

IIR-filtret med LabVIEW. Det som sker då är att istället för att göra en massa

beräkningar som skulle resulterat i nollvärden så sätter man ett visst antal sampels till

noll, dvs. delay(fördröjning), och får på så sätt ut samma effekt som IIR-filtret i

LabVIEW. Detta program motsvarar introduktionslaborationen i LabVIEW.

12

Efter att ha gjort implementation av IIR-filter i Matlab behövdes en bättre lösning för att

få en likvärdig introduktionslaboration som gjordes i LabVIEW. Men samtidigt ha

samma svårighetsgrad programmeringsmässigt och se vilken implementationstid detta

projekt har i mjukvara.

Hur delay sample-programmet implementerades finns beskrivet i bilagor och är

introduktionslaborationsguiden för Matlab (se Bilaga 2, Programmera ett reverb med

Matlab, sida 27).

6. Utförda och framtida undersökningar Detta avsnitt beskriver kort de undersökningar som gjorts under examensarbetets gång,

även några alternativ för ett fortsatt arbete med den digitala signalprocessorn beskrivs.

Alternativa lösningar till processorn studeras också.

Olika alternativ för hur filter och andra behandlingar av signaler kunde implementeras

undersöktes genom att helt enkelt testa vilka som exekverades snabbast och vilka som

klarade flest koefficienter. Hela examensarbetet är en undersökning om hur processorn

klarar de önskade uppgifterna. Utöver de som redan tagits upp så testades även hur

parallella IIR och FIR-filter fungerade.

De IIR-filter som är gjorda för Blackfinprocessorn i LabVIEW kunde parallellkopplas,

dock med stor förlust i bearbetningshastighet då minnet fylls fort. De inbyggda FIR-

filter som var avsedda för processorn fungerade inte när de parallellkopplades. Orsaken

till att de inte fungerade var att de skrev över varandras tillstånd i minnet på

processorn(ADSP-BF537). Under referenser finns det källor till National Instruments

internetadress där kända problem med Blackfinmodulen beskrivs (se Referenser[2], sida

15).

För ett fortsatt arbete med denna processor bör ytterliga möjligheter med Matlab

undersökas, främst med att försöka få upp hastigheten för processorn genom olika

inställningar för processorn i Simulink. Fortsatt undersökning med LabVIEW kan

utföras, t.ex. att testa implementering av något lite större djupare projekt som kanske

inte kräver mer än 1000 filter koefficienter för IIR-filter. Andra alternativ som går att

undersöka för att klara av större projekt kan vara att testa andra produkter t.ex. FPGAs.

Även DAQ-kort(Data Aquisition - kort) kan undersökas t.ex. NI USB-9239 (se

Referenser[3], sida 15) kan användas direkt till datorn via USB kontakt med datorns

processorklocka för bearbetning av signalen. En fördel med det kan vara att man kan

använda alla de operationer som LabVIEW har att erbjuda. En annan fördel är att

processorklockan ofta arbetar i GHz området vilket kan hjälpa att klara fler beräkningar.

Med en något större budget kan även en Plattform från National Instruments som heter

CompactRIO användas(se Referenser[4], sida 15). Detta är en plattform för att ta in

väldigt många olika datasignaler t.ex. den som nämnts ovan NI 9239. Denna plattform

har optionen att kunna exekvera kod på kontrollens processor som arbetar i MHz

13

området och även på chassits FPGA, vilket gör att det inte störs av Windows eller annat

operativsystem.

7. Observationer efter utfört examensarbete Detta stycke beskriver de observationer som upptäcktes under examensarbetet. De

problem som uppkom vid programmering av den digitala signalprocessorn beskrivs.

7.1 Minneshantering En viktig aspekt att tänka på när man ska behandla en signal med filter är att inte göra

det för omfattande och stort med koefficienter och beräkningar, så att all data inte får

plats i det interna flashminnet på processorn. När det interna minnet fylls så används ett

externt SDRAM-minne som kräver väldigt mycket processtid. Bussen mellan

processorn och det externa minnet saktar ned bearbetningstiden grovt. I nästan alla fall

då minnet fylls kommer inte processorn att hinna med de önskade beräkningarna.

8. Resultat Att programmera den digitala signalprocessorn fungerar bra med både LabVIEW och

med Matlab. Begränsningar som berör både LabVIEW och Matlab är hur de olika

blockoperationerna kompileras till C-kod och inställningar som görs för att få

processorn att jobba så snabbt som möjligt. Introduktionslaborationsguiden gick bra att

implementera i såväl LabVIEW som i Matlab. Med LabVIEWs IIR-filter kunde man

dock använda mycket fler koefficienter än med Matlab. LabVIEW kunde ha lite mer än

tusen koefficienter och Matlab bara runt trettio, men för introduktionslaborationen som

gjordes så duger metoden med fördröjning av sampel i Matlab utmärkt. Det programmet

uppnår samma resultat som IIR-filter med LabVIEW. Däremot var det något enklare att

implementera projekten i Matlab, eftersom allt fanns i programmet t.ex. att

filterkoefficienter inte behövde implementeras från andra program. Försök att göra

större projekt misslyckades p.g.a. att bearbetning av signalen för mindre projekt tog för

lång tid, eftersom minnet i processorn fylldes. Varför projekt av större och svårare grad

inte implementerades som det först var tänkt beror dels på tidsbrist och dels på att

processorn inte klarade av att hantera så mycket data på den tid som gavs av

bufferstorleken. Denna buffert ställdes mellan 1024 och ca 6000 sampels efter det

tappar man realtidsfunktionen.

9. Analys & slutsats För introduktionslaborationen blev resultaten något sämre än de mål som satts upp. Då

IIR-filterblocken inte kunde ta så många koefficienter, lite över tusen med LabVIEW

och ca 30 med Matlab, så hann inte processorn med de beräkningar som krävdes för ett

längre reverb. Med de filter som implementerades så blev reverbet inte så långt,

Resultatet blev mer som att sitta i ett rör och tala.

14

Försöken till parallellkoppling av filter i LabVIEW blev sämre än önskat. Det beror på

att minnet fylldes mycket snabbt och antalet koefficienter som kunde användas

minskade markant. Ett väntat resultat hade varit att det skulle minska med en faktor två

vid två parallellkopplade IIR-filter, det riktiga fallet var närmare tio eller något mer

gånger långsammare.

Försöken att öka antalet koefficienter med hjälp av decimering och interpolering gav

positivt resultat, dock inte så mycket som önskats. Vid en decimeringsfaktor på två

borde man ha fördubblat tiden att bearbeta signalen, men då decimering och

interpolation krävde tid av processorn och plats i minnet så vart fallet inte detta. Med en

decimeringsfaktor inställd på sex kunde man använda ungefär dubbla antalet

koefficienter.

De resultat som uppnåddes både i LabVIEW och i Matlab med en fördröjning av ca

tusen sampels skulle kunna användas till reverb för t.ex. en gitarr eller en enklare

equalizer.

Utifrån de resultat som uppnåtts så kan man säga att den valda digitala signalprocessorn

klarar av lite mindre projekt och att den är ganska begränsad vid användning av

parallella filter, med LabVIEW och Matlab-programmering. Då exekveringstiden inte

skalar med en förväntad faktor två med två parallella filter utan snarare en faktor tio

eftersom minnet så snabbt fylls.

Att minnet fylls så snabbt kan bero på att LabVIEW och Matlab kompilerar koden till

C- och C++kod och att den kanske inte är helt optimerad för processorns arkitektur. Så

att skriva programmen själv i C och C++ kan möjligen göra det något mer optimerat.

Eftersom man då får bättre kontroll på exakt vad som sker, dock kräver det högre

programmeringskunskaper och längre implementationstider. Med egen skriven kod

avsedd för VisualDSP++ kompilatorn och processorn hade man förmodligen kunnat

minimera antalet hängningar vid kompilering som uppstod i LabVIEW och i Matlab.

Dock till förlusten av förlängd implementationstid.

15

10. Referenser [1]Processorn:

http://www.analog.com/en/embedded-processing-dsp/blackfin/bf537-

hardware/processors/product.html

[1]Datablad för processorn:

http://www.analog.com/static/imported-

files/product_highlights/26411200ADSP_BF537_EZKIT_A__final.pdf

http://www.cs.put.poznan.pl/wswitala/download/pdf/ADSP_BF537_EZ_KIT_Lite_Man

ual_Rev._2.2.pdf

[2]Källa till kända problem med Blackfin embedded module:

http://digital.ni.com/public.nsf/allkb/2E40257F70708D088625736B006F650B

[3]Alternativa lösningar: USB-DAQ

http://sine.ni.com/nips/cds/view/p/lang/en/nid/205190

[4]Alternativa lösningar: CompactRIO

http://www.ni.com/crio/

11. Bilagor

Bilaga 1

LabVIEW för Blackfin Under detta avsnitt beskrivs hur man ska göra ett nytt Blackfin projekt i LabVIEW. Tips

var man finner de olika Blackfinspecifika programmeringsblocken ges och beskrivs.

Några tips för att göra ett Blackfinprojekt – Öppna LabVIEW och välja nytt Blackfinprojekt, se till att välja rätt kort (ADSP-

BF537). En kort bildguide finns i slutet av denna guide.

– Högerklicka i blockdiagramet för att få fram funktionspaletten och där finns det en

Blackfinflik med färdiga filterdesigner m.m. Dessa är mer lämpliga att använda på

processorn då de är optimerade för arkitekturen.

– Det behövs ett antal VI’s för att få igång ljud in/ut-gångarna

Blackfin / EZ-KIT/Audio / BF initialize Audio.vi denna gör precis som den heter,

initierar ljud in/ut-gångar. Man behöver ange antal sampel för ljudbuffern, lämpligt är

1024 om inte annat anges, de utgångar som finns är referenser för att ta emot och skicka

data.

Blackfin/Device/common / BF Device get buffer och BF Device set buffer dessa två

VI’s används för att läsa och skriva från ljud in/ut-gångarna. För dessa två VI’s behövs

16

även två flaggVI’s Blackfin/Device/Peripherals/AD1871 / BF AD1871 wait on data

ready flag och BF AD1871 clear data ready flag. De gör precis som de heter, flaggar när

man vill läsa från eller skriva till samt rensa bufferten.

Blackfin/Miscellaneous/BF separate Audio Channels och BF Combine Audio Channels

är två VI’s som används för att fläta ihop höger och vänster ljudkanal till och från en

I2S buffert, vilket är ett vanligt protokoll för ljudsignaler.

– En sak att tänka på är att se till att man kopplar rätt datatyp till ingångarna, detta

kollas lättast genom att hålla över ingången högerklicka och välja create constant och

sedan kolla egenskaper för konstanten.

– Programming/Numeric/Conversion/~ data-konverteringar som behövs hittas här.

under Blackfin/Blackfin Numeric/Conversion/~ finns också några data-konverteringar

som behövs.

FilterVI’s hittas under

-Blackfin/Blackfin Analysis Library/Blackfin Signal Processing/Filters/~ här finns de

inbyggda filter som är speciellt anpassade för processorn och bör användas, se hjälpen

för dessa för att bättre förstå vad som behövs för att få filtret att fungera som önskat.

Processor inställningar.

– Öppna projektexplorerfönstret, högerklicka på VDK Application under Build

Specifications och sedan properties. Under General-fliken väljs debugmode ifall det

önskas. Alla checkboxar utom generate c style function calls och Enable profile

information ska vara ikryssade. Under Advanced options-fliken kan man välja att

använda cache vilket används för att snabbare kunna arbeta med filter o.s.v. på

processorn. Enable cache och Enable linker ska vara ikryssade, Enable cache ska vara

inställd på Instructions, data A Cache, dessa cacheminnen ska inte användas då inga

påfrestande beräkningar ska utföras. Det kan leda till oönskade effekter så som hack i

signalen.

För att programmera processorn finns följande alternativ.

– Se till att USB-kabeln är ansluten

– Starta programmet från LabVIEW med Run-knappen(görs alltid första gången man

ska kompilera ett program), detta kommer att kompilera LabVIEW-koden till c-kod och

sedan läggas ned på processorn. Gör man på detta sett fungerar dock inte

debugningsmöjligheterna.

– Ett annat alternativ att programmera ned LabVIEW-koden till processorn är att gå via

projektexplorerfönstret, högerklicka på VDK Application välj där build sedan deploy

och sist run alt. debug (detta sätt rekommenderas). Då man kan välja debugläge samt att

man kan välja när man vill exekvera programmet på processorn samt att man inte

kompilerar om kod som redan är kompilerad.

17

Blackfin nytt projekt guide:

18

19

VDK Application egenskaper(detta ställs in första gången du ska kompilera ned koden

på processorn):

20

Introduktionslaboration i LabVIEW Denna introduktionslab beskriver grundligt hur man ska implementera ett program på

den digitala signalprocessorn (ADSP-BF537) för att lägga till ett reverb på en

ljudsignal. Denna reverbeffekt som beskrevs tidigare i rapporten ska implementeras av

ett IIR-filter (se Experimentdelen 6.1 & 6.2 sida 8)

I texten nedanför kommer följande ord att ersättas med akronymer inom parenteserna:

(BFIA)BF Initialize Audio

(BFDGB)BF Device Get Buffer

(BFDSB)BF Device Set Buffer

(BFAWODRF)BF AD1871 Wait on Data Ready Flag

(BFACDRF)BF AD1871 Clear Data Ready Flag

(BFSAC)BF Separate Audio Channels

(BFCAC)BF Combine Audio Channels

(BFCC)BF Convert Coefficients

(BFDFIIF)BF Direct Form I IIR Filter

– Från frontpanelen går du in i blockdiagrammet där du programmerar genom att

antingen trycka ctrl+e eller klickar på Windows i menylistan och sedan show block

diagram

– Placera ut en while-loop. Den finns i funktionspaletten under

programming/structures/while loop och koppla en constant till loopvillkoret.

– Sätt (BFIA) utanför while-loopen och bestäm antal sampel, lämpligt är 1024 eller mer.

Ställ även in den på BF537.

– Placera ut en (BFDGB) och en (BFDSB) bredvid varandra i while-loopen och ställ in

båda på i32 som datatyp.

– Receive buffer reference från (BFIA) kopplas till buffer reference in på (BFDGB) och

transmit buffer reference kopplas till buffer reference in på (BFDSB).

– Koppla en tom array in till data buffer in på (BFDGB). Denna array gör du utanför

while-loopen med hjälp av Initialize Array under programming/array, den ska vara lika

lång som du valde sampel till (BFIA) (obs viktigt att sätta denna array till i32 som

datatyp). Välj att göra den till ett skiftregister vid ingången till while-loopen genom att

högerklick och välj replace with shift register. Koppla data out från (BFDSB) till

skiftregistret på andra sidan.

– Placera ut en (BFAWODRF) i while-loopen och koppla den till sub buffer select på

(BFDGB) och (BFDSB).

– Placera ut en (BFACDRF) i while-loopen och koppla result från (BFDSB) till denna.

– Placera ut en (BFSAC) och ställ in den på 16-bit och koppla data buffer out från

(BFDGB) till samples in på (BFSAC).

21

– Placera ut en (BFCAC) och ställ in den på 16-bit och koppla samples out från

(BFSAC) till samples in på (BFCAC). Koppla samples out från (BFCAC) till data in på

(BFDSB). Koppla right out och left out från (BFCAC) till while-loopen och gör om till

ett skiftregister som ovan. Koppla den andra sidan av skiftregistret till right in och left

in på (BFSAC).

– Utan bearbetning av ljudbuffern kopplas right out och left out från (BFSAC) till right

in och left in på (BFCAC).

– Placera ut två Initialize array precis som innan utanför while-loopen och gör arrayerna

hälften så stora som samples till (BFIA) koppla dessa arrayer till right- och left-

skiftregistrena. OBS! se till att använda i16 som datatyp.

Efter detta bör ditt program se ut såhär med reservation för skillnad i placering av

funktionsblocken.

Figur 11.1 Bilden ovan är ett LabVIEW program för Blackfinprocessorn ADSP-BF537. Programmets

syfte är att sampla 1024 sampels och sedan bara föra det från ingången till utgången på kortet. Alltså från

AD till DA utan någon signalbehandling alls. Detta förklaras mer i avsnitt 5.1 Skicka ljud genom

processorn sida 8. Alla VI's beskrivs under LabVIEW för Blackfin på sida 15.

Implementation av ett IIR-filter

–Placera ut en (BFCC) utanför while-loopen.

–Placera en (BFDFIIF) inne i while-loopen mellan (BFSAC) och (BFCAC).

–Koppla right out eller left out från (BFSAC) till input på (BFDFIIF) och koppla output

från (BFDFIIF) till right in och left in på (BFCAC).

–Placera en Initialize array utanför while-loopen och gör den till halva sampel

längden(i32 kan användas).

– Koppla Initialize Array till en To Single Precision Float som hittas under

programming/numeric/conversion.

22

– Koppla Initialize Array till en BF Single to Fract16 hittas under

Blackfin/numeric/conversion och ställ in den på __Blackfin_float_to_fr16_1d.

– Koppla Initialize Array till outputingången på (BFDFIIF).

– Koppla halva sampelstorleken till length-input på (BFDFIIF).

– Håll över continue-ingången högerklicka och välj create constant placera denna

konstant utanför while-loopen, dra in den till continue-ingången samt gör om

övergången till while-loopen till ett skiftregister. Koppla en constant skilt från 0 på

andra sidan av skiftregistret.

– Koppla coeff_out från (BFCC) till coefficients på (BFDFIIF).

– Koppla A-koefficienter till acoeff på (BFCC) kontrollera att data typ To Single

Precision Float är vald. (Läs under Hur ställs filterkoefficienter in för olika VI’s på sida

25 för korrekt inmatade A- och B-koefficienter).

– Koppla B-koefficienter till bcoeff på (BFCC) välj datatyp To Single Precision Float.

(Läs under Hur ställs filterkoefficienter in för olika VI’s sida 25 för korrekt inmatade A-

och B-koefficienter).

– Koppla en constant till nstages som är hälften så lång som A-koefficienterna(utan a0).

Koppla även denna constant till biquad_stages på (BFDFIIF).

– Placera ut en Initialize array och gör den 4 x nstages + 2 lång med datatyp i32.

Koppla sedan den till coeff på (BFCC).

Efter detta bör ditt program se ut såhär med reservation för skillnad i placering av

funktionsblocken.

Figur 11.2 Bilden ovan är en utbyggnad av programmet i figur 11.1 det som lagts till är ett IIR-filter och

dess koefficienter. Vad detta IIR-filter har för funktion är att fördröja varje sampel en viss tid så att man

ska uppfatta rumsklanger eller med en annan benämning reverb. Detta förklaras även närmare i avsnitt 5.2

IIR-filter med LabVIEW sida 8. Se LabVIEW för Blackfin på sida 15 för förklaring av VI's i programmet

i bilden ovan.

23

Implementation av decimering och interpolering Denna guide beskriver hur man ska implementera decimering och interpolation av

signalen (uppsampling och nedsampling). Detta görs för att få längre tid att beräkna på

signalen, dock till en förlust i frekvensområde. Mer om detta beskrivs i rapporten (se 6.3

Decimering och interpolation med LabVIEW, sida 9).

Fler akronymer:

(BFFDF) BF FIR Decimation Filter

(BFFIF) BF FIR Interpolation Filter

– Placera ut en (BFFDF) och en (BFFIF) inne i while-loopen.

– Koppla output_out från (BFFDF) till input på (BFDFIIF).

– Koppla output_out från (BFDFIIF) till input på (BFFIF).

– Koppla output_out från (BFFIF) till left in och right in på (BFCAC).

– Koppla en ny output array till output på (BFDFIIF), denna skall vara halva

bufferstorleken/decimationsindex och av datatyp fract16.

– Koppla en array till output på (BFFDF) med hjälp av Initialize array hittas under

programming/array, välj fract16 som datatyp. Denna array skall vara

bufferstorlek/decimationsindex (måste vara ett heltal).

– Koppla en constant till lenght_input på (BFFDF) som ska vara halva bufferstorleken.

– Koppla decimeringskoefficienter från Matlab till coefficients på (BFFDF) använd en

BF Single to Fract16 för att få rätt datatyp på koefficienterna. Denna hittas under

Blackfin/Blackfin/numeric/conversion. Dessa koefficienter beskrivs noggrannare under

Hur ställs olika filterkoefficienter in för olika VI’s? sida 25.

– Koppla decimeringskoefficienterna till en Array size utanför while-loopen och koppla

sedan den till length_coefficients på (BFFDF).

– Koppla en constant till decimationsindex på (BFFDF), koppla även denna constant till

interpolation_index på (BFFIF).

– Skapa ett skiftregister i while-loopen genom att göra en constant som ska vara 0

utanför while-loopen och koppla den till continue på både (BFFDF) och (BFFIF) gör

sedan övergången till while-loopen till ett skiftregister. Koppla en constant skilt från 0

till andra sidan av skiftregistret. Går bra att använda samma continue-constant som

används till (BFDFIIF) till både (BFFDF) och (BFFIF).

– Koppla en array till output på (BFFIF) på samma sätt som till (BFFDF) och gör den

till halva bufferstorleken, med datatyp fract16.

24

– Koppla en constant till length_input på (BFFIF) som är halva

bufferstorleken/interpolationsindex(decimeringsindex). Koppla även denna till

lenght_input på (BFDFIIF).

– Koppla interpolationskoefficienter från Matlab till coefficients på (BFFIF), använd en

BF Single to Fract16 för att få rätt datatyp på koefficienterna. Denna hittas under

Blackfin/Blackfin/numeric/conversion. Dessa koefficienter beskrivs noggrannare under

Hur ställs olika filterkoefficienter in för olika VI’s? sida 25.

– Koppla en constant till length_coeffs_polyphase som är

interpolationskoefficienter/decimeringsindex. Detta görs lättast med en Array Size och

en dividerings-funktion.

Efter detta bör ditt program se ut såhär med reservation för skillnad i placering av

funktionsblocken. (samt den tidigare visade koden från figur 11.1 detta är alltså en

utbyggnad av det programmet nedåt).

Figur 11.3 Bilden ovan visar halva detta programmet för andra halvan se figur 11.1. Detta program är

även det en påbyggnad av programmet i figur 11.1. Vad programmet gör är att utföra decimering och

interpolering på signalen före resp. efter signalbehandling. Signalbehandlingen som sker är IIR-

filtreringen som förklarat i figur 11.2 ovan och i avsnitt 5.2 IIR-filter med LabVIEW sida 8. Decimering

och interpolering beskrivs i avsnittet 5.3 Decimering och interpolering med LabVIEW sida 9.

File saver-program Använd detta program för att läsa in en txt-fil i LabVIEW, t.ex. filterkoeficienter.Man

kan även använda programmet för att spara txt-filer från LabVIEW.

–Placera ut en Read From och en Write To Spreadsheet File, Programming/File I/O.

– Placera ut en Array Size och en Index Array och även en Reshape Array från

Programming/Array.

– Placera ut två st. To Single Precision Float från Programming/Numeric/Conversion.

25

– Koppla all rows utgången från Read From Spreadsheet File till en av To Single

Precision Float och även Array Size.

– Koppla sedan Array Size utgången till array ingången på Index Array.

– Skapa en constant till index ingången på Index Array.

– Koppla utgången från den tidigare använda To Single Precision Float till array

ingången på Reshape Array.

– Koppla utgången på Index Array till dimension size ingången på Reshape Array.

– Koppla utgången på Reshape Array till ingången på den oanvända To Single Precision

Float

– Skapa en indicator på utgången från To Single Precision Float genom att högklicka

på utgången och välja create/indicator.

För att läsa in en fil trycker man på Run-knappen, en dialogruta visas där man får välja

vilken fil man vill läsa in. Kopiera sedan indikatorn till det program där du vill ha filen.

Högerklicka sedan där på indikatorn och välj Change to constant.

Använd detta program för att spara ned data från en array i LabVIEW till en fil.

– Högerklicka på file path-ingången på Write To Spreadsheet File och välj create

constant. Skriv in sökvägen till där vill spara filen.

– Koppla den array du vill spara till 1D array input på Write To Spreadsheet File.

Varje gång programmet exekveras kommer arrayen kopplad till 1D array att skrivas till

en fil och sparas på den sökväg som angivits i konstanten.

Lite om gränser Med Data A och B cache aktiverad så klarar processorn IIR-filter med 1400

koefficienter med en bufferstorlek på 4096. Med decimering och interpolering klarar

processorn av ett IIR-filter med ungefär 2800 koefficienter med en bufferstorlek på

8184(för att talet skall vara jämt delbart med 6), då är decimerings FIR-koefficienterna

21 st. och interpolationen FIR-filter är av typ polyphase och har 48 koefficienter för att

inte förstöra signalen för mycket, decimeringsindex är för dessa mätningar 6 d.v.s. att

den nya nyqvistfrekvensen är 4kHz.

Hur ställs filterkoefficienter in för olika VI’s? För BF Direct Form I IIR Filter VI:

Viktigt är att alltid använda rätt datatyp. Koefficienterna som ska in i denna VI görs

med BF Convert Coefficients for DF1 IIR Filter VI. Denna ska ha A- och B-

koefficienter i direkt form, a0 ska inte inkluderas och man ska ange koefficienterna i par

a1 och a2 o.s.v. B-koefficienterna ska inkludera b0 och sedan anges i par som A-

koefficienterna (b1 och b2 o.s.v.), d.v.s. en längre än A-koefficienterna.

26

För BF FIR Decimation Filter VI:

Koefficienterna behöver bara matas in direkt från Matlab, datatypen ska vara single

precision och koefficienterna kan behöva skalas ned något.

BF FIR Interpolation Filter VI:

Filterkoefficienterna ska vara av typ polyphase.

Detta görs lättast i Matlab på följande vis:

Gör först ett lågpassfilter som man sedan gör om till polyphasefilter m.h.a. koden

nedan.

%Gör ett FIR-filter 96 koefficienter långt. Detta filter är lämpligt för interpolation.

b = intfilt(6,8,1);

%Använd gärna ett fönster på koefficienterna för att få mindre rippel

w=hann(95);

bh=b’.*w;

%Skapar ett multiratefilter

hm=mfilt.FIRinterp(6,bh);

%Gör om polyphase-filtret till polyphase

u=polyphase(hm);

för att kopiera detta till LabVIEW så ska man flytta alla kolumner till en kolumn,

eftersom det är så interpolationsfiltret vill ha sina koefficienter.

%Transponerar polyphasefiltret för att få det på rätt sätt och flyttar sedan alla kolumner

till en kolumn.

u=u';

l=u(:);

Koefficienterna är bara att använda in i LabVIEW som de är med Blackfins

dataconversions VI BF Single to Fract16 innan de matas in i interpolations VI:n. Det

man behöver göra innan man ska använda txt-filer i LabVIEW är att göra om punkter

till kommatecken då LabVIEW och Matlab inte använder samma avskiljningstecken för

decimaler. Detta görs lättast med File saver-programmet som beskrivs på sida 24.

Bilaga 2

Guide för Blackfin ADSP-BF537 med Matlab – Öppna Matlab.

– Öppna Simulink med kommandot Simulink i Command Window.

– Öppna Library browser i listan högst upp i Simulink.

27

För de två alternativen nedan krävs att Analog Devices visual DSP++ samt Matlab är

installerat på datorn.

–Alt. 1 är att under Embedded IDE link/Supported IDEs/Analog Devices VisualDSP++

välja custom board for ADI VisualDSP++

– Alt. 2 är att under Target Support Package/Supported Processors/Analog Devices

Blackfin/Board Support/ADSP-BF537 EZ-KIT lite välj ADSP-BF357 EZ-KIT lite

processorn (Rekommenderas för AD och DA ligger även här.)

– När processor är vald och placerad öppnar man konfigurationer för den genom att

dubbelklicka på den.

– Välj BF537 i processor scroll-listan (det enda som behöver ställas in).

– BF537_dac och BF537_adc blocken ska placeras ut för att kunna skicka och ta emot

signaler till processorn.

– Dessa ställs in genom dubbelklick på blocket och sedan väljer man hur stor respektive

kanal ska vara. (default är 128 sampel stor buffer totalt, rekommenderat är 512 eller

1024).

– För processning av signalen man tar emot så är det bara att välja bland många olika

block i library browser (lämpligt är Signal Processing Blockset).

– För att sedan programmera programmet ned på processorn så ska man först öppna

VisualDSP++ programmet och se till att processorn är kopplad till datorn.

– Använd kortkommandot ctrl+B i Matlab för att programmera eller tryck på

Incremental Build knappen i listen högst upp.

– Ifall det uppstår fel så behöver det inte betyda att det inte fungerar. Testa då att

programmera ned programmet direkt ifrån VisualDSP++ Environment genom att trycka

på Build projekt knappen där.

Programmera ett reverb med Matlab Detta program kommer att motsvara LabVIEW-programmet med IIR-filter fördjörning.

Fast här med hjälp av att man fördröjer signalen ett visst antal sampel och lägger till ett

ekosampel efter fördröjningen. Effekten kommer bli den samma som för LabVIEW IIR-

filter programmet. Läs rapport för mer information (se 6.6 Fördröjning med Matlab sida

11).

– Lägg till processorn och AD/DA-omvandlarna som beskrivits ovan.

– Lägg till två st. data konverteringsblock genom att söka på Data type conversion i

sökfältet i Simulink library browser (en av dem som ligger under Simulinkmenyn).

28

– Den första ska kopplas på direkt efter ADC:n och ställas in genom att dubbelklicka på

blocket. output data type:, ska ställas in på single. Input and output to have equal: ska

stå på Stored Integer (SI) och Integer roundingmode: ska stå på floor.

– Den andra ska ligga precis innan DAC:n och ställas in som den första förutom Output

data type: som ska vara int32.

– Sök på Gain i Simulink library browser och placera ut två st gainblock (det första

blocket under Simulinkmenyn). Ställ in den ena på 0,5 och den andra på 0,9

(dubbelklicka på blocken för att ställa in).

– Sök på Delay i Simulink library browser och välj den med beteckningen 𝑧−1, som

bara heter delay. Dubbelklicka på den för att ställa in Delay (sampels) till 1000.

– Sök på Sum i Simulink library browser och välj den första under Simulinkmenyn.

Placera ut två st.

– Koppla nu ihop ADC:n med det första datakonverteringsblocket.

– Koppla utgången på datakonverteringsblocket till en av ingångarna på sumblocket.

– Koppla utgången på sumblocket till ingången på delayblocket.

– Koppla utgången på delayblocket till ingångarna på båda gainblocken.

– Koppla utgången på gainblocket med 0,9 till ena ingången på det andra sumblocket.

– Koppla utgången på gainblocket med 0,5 till den andra ingången på det första

sumblocket.

– Koppla den andra utgången på det andra sumblocket till tråden mellan det första

sumblocket och datakonverteringensblocket.

– Koppla utgången på det andra sumblocket till ingången på det andra

datakonverteringsblocket.

– Koppla utgången på det andra datakonverteringsblocket till ingången på DAC:n.

29

Efter detta bör ditt program se ut såhär med reservation för skillnad i placering av

funktionsblocken.

Figur 11.4 Bilden ovan är ett Matlab program som ger samma resultat som IIR-filter med LabVIEW som

beskrivs i avsnitt 5.2 IIR-filter med LabVIEW sida 8. Skillnaden är att här fördröjer man bara alla sampel

ett visst antal sampel. De filtreras alltså inte men effekt blir den samma. Detta beskrivs i avsnitt 5.2 IIR-

filter för LabVIEW sida 8, 5.5 IIR-filter med Matlab sida 11 samt 5.6 Fördröjning med Matlab sida 11.

IIR-filter med Matlab Detta program var tänkt att göra samma sak som motsvarande program i LabVIEW.

Men då man inte kunde ha fler än ca 30 koefficienter blev effekten inte alls som väntad,

för höga filterordningar och långa fördröjningar hade gett. För mer information om IIR-

filter läs rapporten (se 5.5 IIR-filter med Matlab, sida 11).

– Öppna Reverbprogrammet som gjordes ovan och spara om det till IIR-filter

– Ta bort de block som ligger mellan datakonverteringsblockena på bilden ovan.

– Sök på Digital Filter Design i Simulink library browser och placera den mellan

datakonverteringsblocken dubbelklicka på den för att få upp inställningar.

– Ställ in på Lowpass under Response Type, IIR under Design method, minimun order

under filter options, units på Hz, fs på 48000, Fpass på t.ex. 2000, Fstop på t.ex. 4000

under Frequency specifications. Klicka på designa filter och stäng ned inställningarna.

– Koppla utgången på det vänstra datakonverteringsblocket till ingången på filtret.

– Koppla utgången på filtret till ingången på det högra datakonvertingsblocket.

Efter detta bör ditt program se ut såhär med reservation för skillnad i placering av

funktionsblocken.

Figur 11.5 bilden ovan är ett Matlab program som tar in ljudet från AD-omvandlaren gör om datatypen

och sedan utför IIR-filtrering på signalen. Sedan görs datatyp om till ursprunglig datatyp och skickas ut

igen på DA-omvandlaren. Just detta IIR-filter är ett enkelt lågpassfilter.

30

FIR-filter görs på samma sätt och kan som i LabVIEW ha högre ordningstal än IIR-

filter. Det finns andra metoder att implementera ett filter men detta är förmodligen det

lättaste.

För och nackdelar med Matlab jämfört med LabVIEW En fördel med Matlab är att man snabbt får upp filter. Det är smidigt att designa och

använda filter direkt i Matlab.

Några nackdelar med Matlab är att man inte kan använda lika många koefficienter som i

LabVIEW. I ett IIR-filter kan man ha ca 30 koefficienter, därefter hinner processorn

inte med. Främst beror det på att man exekverar den i debugmode, vilket saktar ned

processorn. Val av debugmode bör kunna ändras, men en lösning på detta har tyvärr

inte hittats.

Bilaga 3

RS232 UART kommunikation med LabVIEW Seriell kommunikation implementeras för att under exekvering kunna ändra parametrar

som kan påverka bearbetningen av signalen som sker på processorn. För mer

information (se 6.4 Bearbetning av data via RS232 UART i LabVIEW, sida 10)

Utgå från den VI som gjordes i introduktionslaborationen som bara skickar ljudet

genom processorn (se figur 11.1 och Introduktionslaboration i LabVIEW, sida 20)

Utgående kommunikation med LabVIEW -Förstora while-loopen nedåt.

-Placera en case structure, Programming/Structures/Case Structure, inne i while-loopen.

-Lägg till en BF Is Button Pushed. Blackfin/EZ-KIT/Button/BF Is Button Pushed. Den

ska ligga utanför casestrukturen men i while-loopen.

-Koppla en constant 1 till button number ingången på BF Is Button Pushed. Välj även i

listan BF537 Is Button Pushed.

-Lägg till en andgrind i while-loopen ovanför BF Is Button Pushed.

Programming/Boolean/And.

-Högerklicka på den övre ingången och välj create constant. Placera den utanför while-

loopen och ställ in den på false.

-Lägg till en notgrind. Programming/boolean/not. Koppla utgången till den övre

ingången på andgrinden.

-Koppla konstanten till ingången på notgringen. Gör om tunneln till ett

shiftregister(högerklicka replace with shiftregister).

31

-Koppla utgången på BF Is Button Pushed till den undre ingången på andgrinden.

-Koppla utgången på andgrinden till Case Selector på casestrukturen.

-Lägg till en BF UART close, BF UART write, BF UART Control och en BF UART open

i casestrukturen (true). Blackfin/Driver/Buses/UART/~

-Koppla samma dessa fyra VI’s genom att koppla error out till error in och även device

reference till device reference in på nästkommande VI.

-Koppla BF UART open till BF UART Control till BF UART write till BF UART close.

-Koppla en constant 0 till port number på BF UART open, genom att högerklicka på

ingången och välja create constant.

-Koppla även en constant till direction som ska ställas in på Outbound.

-Lägg till en cluster constant i casestrukturen(true). Programming/Cluser, class, &

Variant/Cluster constant

-Placera en numeric constant i klustret Programming/Numeric/Numeric constant

-Högerklicka på den numeriska konstanten och välj representation u32.

-Placera en Enum constant i klustret Programming/Numeric/Enum Constant

-Placera ytterligare två st numeric constant till klustret detta kan göras enklast genom att

hålla in ctrl+vänster muspekare och sedan dra från den första numeric constant.

-Högerklicka på Enum constant och tryck på Edit item…, klicka på Insert och skriv in

None, tryck på returnknappen och skriv in Odd, tryck på returnknappen igen och skriv

in Even, klicka på OK knappen.

-Den första numeric constanten ska ha värdet 8, den andra 1 och den tredje 57600.

-Högerklicka på klusterramen och välj AutoSizing/Arrange Vertically.

-Högerklicka på klusterramen än en gång och välj Reorder Controls in cluster... Se till

att de har rätt nummer, första konstanten 0, enumen 1, andra konstanten 2, tredje

konstanten 3. Stäng reorderfönstret genom att klicka på bocken uppe i menylisten.

-Koppla klustrets utgång till UART config på BF UART Control.

-Lägg till en Number To Decimal String i casestrukturen(true).

Programming/String/Number Conversion.

-Koppla Left out eller Right out från BF Separate Audio Channels till Number ingången

på Number To Decimal String.

-Lägg till en Array To Speadsheet String i casestrukturen(true).

Programming/String/Array To Speadsheet String

32

-Koppla en constant till format string ingången (högerklicka create constant) skriv %d i

konstanten.

-Koppla en constant till Delimiter, gör ett mellanslag i konstanten.

-Koppla utgången på Number To Decimal String till arrayingången på Array To

Spreadsheet String.

-Lägg till en Concatenate Strings i casestrukturen(true).

Programming/String/Concatenate Strings.

-Koppla utgången från Array To Spreadsheet String till den övre ingången på

Concatenate Strings.

-Lägg till en Line Feed Constant i casestrukturen(true). Programming/String/Line Feed

Constant.

-Koppla Line Feed Constant till den undre ingången på Concatenate Strings.

-Koppla utången på Concatenate Strings till bufferingången på BF UART Write.

-Lägg till en boolean-constant i casestrukturen (true) långt till höger.

Programming/Boolean/True Constant.

-Koppla konstanten till shiftregistret som implementerades tidigare.

-Växla till false case i casestrukturen.

-Koppla den booleanska utgången till button puched utången på BF Is Button Pushed.

Nu bör din VI se ut ungefär så här med reservation för skillnad i placering av

funktionsblocken.

Figur 11.6 I bilden ovan är ett program som skickar upp det som finns på AD:n till RS-232 UART porten.

Användbart för att t.ex. logga data.

33

Ingående kommunikation med LabVIEW Utgå från introduktionslaborationen där ett IIR-filter gjordes (se Implementation av ett

IIR-filter, sida 21. Se även IIR-filter med LabVIEW, sida 8 för beskrivning av det

programmet).

-Gör while-loopen större nedåt.

-Lägg till en case structure precis som i utgående kommunikation med LabVIEW i

while-loopen.

-Lägg till en numeric constant utanför while-loopen till vänster.

Programming/Numeric/Numeric Constant. Sätt den till 0.

-Koppla konstanten till Case Selecter på casestrukturen. Dubbelklicka i caseväljaren

och gör om 1 caset till 200.

-Gör om tunneln i while-loopen till ett shiftregister (högerklicka och välj replace with

shiftregister).

-Lägg till en array constant utanför while-loopen till vänster. Programming/Array/Array

Constant. Ctrl+vänster musknapp och dra den tidigare gjorda numeriska konstanten till

arraykonstanten. Sätt de tre första värdena till 1.

-Koppla arraykonstanten till casestrukturens vänstra sida. Gör om tunneln i while-

loopen till ett shiftregister.

- Lägg till en BF UART Close, BF UART Read, BF UART Control och en BF UART

Open i casestrukturen (200). Blackfin/Driver/Buses/UART/~

-Placera BF UART Open utanför while-loopen till vänster. Koppla en constant 0 till port

number. Koppla en constant till direction, ställ in den på Inbound.

-Placera BF UART Close utanför while-loopen till höger.

-Växla case till 0,default.

-Koppla arrayen genom casestrukturen till shiftregistret på höger sida av while-loopen.

-Lägg till en Increment(+1) i casestrukturen (0,default).

Programming/Numeric/Increment.

-Koppla en tråd från utången på Case Selector till ingången på increment och utgången

på increment till shiftregistret på höger sida av while-loopen.

-Koppla error out och device reference från BF UART Open genom while-loopen och

vidare genom casestrukturen sedan ut ur while-loopen till error in och device reference

in på BF UART Close.

-Växla till 200 caset i casestrukturen.

34

-Gör en constant till den smala tråden på högersida av casestrukturen. Sätt den till 0.

-Placera BF UART Control till vänster i casestrukturen. Gör en cluster constant på

samma sätt som för utgående kommunikation med LabVIEW. Alternativt kopiera den

från den VI:n.

-Koppla klusterkonstanten till UART config på BF UART Control.

-Koppla även in device reference och error out trådarna till BF UART Control och

vidare till BF UART Read, från BF UART Read vidare till utgångarna på högra sidan av

casestrukturen.

-Koppla en constant 8 till num bytes genom att högerklicka och välja create constant.

-Lägg till en Spreadsheet String To Array i case strukuren (200).

Programming/String/Spreadsheet String To Array.

-Gör en constant till format string (högerklicka create constant). Skriv %f i den.

-Koppla buffer utgången från BF UART Read till spreadsheet string ingången på

Spreadsheet String To Array.

-Kopiera arraykonstanten vänster om while-loopen genom att hålla in ctrl + vänster

musknapp och dra in den i casestrukturen(200).

-Koppla den till array type ingången på Spreadsheet String To Array.

-Högerklicka på 0an i arraykonstanten välj Data Operations Emptry Array.

-Koppla utgången på Spreadsheet String To Array till arrayshiftregistret på while-

loopens högra sida.

-Lägg till en Index Array utanför casestrukturen till höger. Programming/Array/Index

Array.

-Koppla Arrayren ut från casestrukturen till n-dimension array-ingången på Index

Array.

-Koppla en constant 0 till index ingången på Index Array (högerklicka create constant).

I programmet som precis skapats enligt figur 11.7 nedan. Så tas det första värdet i

arrayen ut som skickats till kortet som kan användas för att manipulera signalen. Lägg

förslagsvis till en Multiply efter filtret och koppla utgången från Index Array till en av

ingångarna och filtrets utgång till den andra. Lägg till fler Index Array med andra

indexnummer för att ta ut andra index.

35

Ungefär så här bör delen med kommunikation se ut med reservation för skillnad i

placeringen av funktionsblocken. (Detta är alltså en utbyggnad på tidigare gjorda

program t.ex. det i figur 11.1)

Figur 11.7 I bilden ovan visas ett program som körs på Blackfinprocessorn. Syftet är att från COM-porten

kunna ta emot data skickat från en dator som kan manipulera signalen som tas in på AD:n.

Skicka data till kortet – Öppna en Blank VI utan att ha något befintligt Blackfinprojekt öppet(då blir den nya

VI:n en Blackfin blank VI).

– Lägg till en slide på frontpanelen. Modern/Numeric/Vertical Pointer Slide.

Dubbelklicka på det minsta värdet i sliden för att ändra det till 1, ändra även det översta

värdet på samma sätt till 10.

– Gör den lagom stor. Kopiera den sedan genom att hålla in ctrl+vänster musknapp och

dra från sliden (tre st ska finnas).

– Lägg till en OK Button på frontpanelen. Ändra texten på den genom att klicka och

radera befintlig text och skriv Send EQ.

– Högerklicka sedan på knappen och välj Mechanical Action och välj Latch When

Pressed.

– Gå till blockdiagramet genom att trycka ctrl+e.

– Lägg till en while-loop och gör en control till stopvillkoret genom att högerklicka och

välj create control. Programming/Structures/While Loop

– Lägg till en casestruktur i while-loopen. Programming/Structures/Case Structure.

– Koppla OK Button till Case Selector ingången.

– Placera de tre slidsen i casestrukturen(true).

– Lägg till tre st Number To Decimal String i casestrukturen(true).

Programming/String/Number Conversion/Number To Decimal String.

36

– Lägg till en Concatenate Strings i casestrukturen(true).

Programming/String/Concatenate Strings. Gör den till 5 ingångar genom att dra ut den

nedåt.

– Lägg till en tab constant i casestrukturen(true). Programming/String/Tab Constant.

– Lägg till en VISA Write, Visa Close och en VISA Configurate Serial Port utanför

while-loopen. Instrument I/O/Serial/~

– Placera VISA Write i casestrukturen(true).

– Placera VISA Configurate Serial Port till vänster om while-loopen.

– Högerklicka på termination char ingången på VISA Configurate Serial Port och gör

en constant, Sätt den till 10. Gör även en constant på samma sätt för timeout och sätt

den till 10000.

– Gör en constant för VISA resource name och välj den COM-port du skickar ifrån.

– Gör en constant för baud rate ingången sätt den till 57600.

– Koppla alla slides i casestrukturen till varsin Number To Decimal String till number

ingången.

– Koppla en constant 2 till alla width ingångar på Number To Decimal String.

– Koppla den första Number To Decimal String till översta ingången på Concatenate

Strings.

– Koppla Tabkonstanten till andra och fjärde ingången på Concatenate Strings.

– Koppla den andra Number To Decimal String till tredje ingången på Concatenate

Strings.

– Koppla den tredje Number To Decimal String till den femte ingången på Concatenate

Strings.

– Koppla Concatenate Strings till VISA Write.

– Koppla VISA resource name out från VISA Configurate Serial Port till VISA resource

name på VISA Write.

– Koppla utgången från VISA Write till VISA Close utanför while-loopen.

I programmet som precis skapats kan man skicka 3 tal via serieport till kortet genom att

ställa in slidsen där man vill ha dem och sedan klicka på Send EQ-knappen medans

programmet kör förutsatt att programmet som gjordes tidigare (Ingående

kommunikation med LabVIEW, sida 33) kör på processorn.

37

Ditt program bör se ut ungefär så här nu med reservation för skillnad i placering av

funktionsblocken.

Figur 11.8 Bilden ovan är ett program som ska köras på en dator som har en COM-port för att skicka ned

data till Blackfinprocessorn. Syftet att kunna skicka data till processorn är att manipulera signalen.