Distance Laser Measurements

(1)

INOM

EXAMENSARBETE TEKNIK, GRUNDNIVÅ, 15 HP

STOCKHOLM SVERIGE 2018 ,

Distance Laser Measurements

En undersökning i hur en lasersensor

automatiskt kan rikta sin stårle mot ett önskat objekt

EMMA EHRLIN

(2)

(3)

Distance Laser Measurements

En undersökning i hur en lasersensor automatiskt kan rikta sin stårle mot ett önskat objekt

EMMA EHRLIN

Bachelor’s Thesis at ITM Supervisor: Nihad Subasic

Examiner: Nihad Subasic

(4)

(5)

Referat

A LIDAR that measures distance to an object in motion must be directed with precision. This is something that can be done automatically. In this project, a construction where two LIDAR sensors are attached to each step motors is built. One LIDAR scans the environment in 2D and a second LIDAR is directed based on the information from the scanning sensor. In order to get rid of incorrect values and to find a central position on an object, different variants of moving average filters are used and tested. The result shows that a filter with fewer values included in the average analysis of the filter, resulting in a more stable result, especially when the object being tracked is located far

(6)

Referat

En undersökning i hur en lasersensor automatiskt kan rikta sin stråle mot ett

önskat objekt

En LIDAR-sensor som mäter avstånd till ett objekt i rörelse måste riktas med bra precision. Detta är något som kan göras automatiskt. I detta projekt byggs en konstruktionen där två stycken LIDAR-sensorer fästs vid var sin stegmotor. En sensor skannar omgivningen i 2D och en andra sensor riktas sedan utifrån informationen från den skannande sensorn. För att får bort felaktiga värden samt för att hitta en position mer centralt på ett sökt objekt an- vänds och testas olika varianter av glidande medelvärdes- filter. Resultatet visar att ett filter där färre värden tas med i filtrets medelvärdesberäkningar ger ett stabilare resultat, framförallt då objektet som följs befinner sig på län- gre avstånd. Resultaten visar att principen går att använda för att rikta en sensor mot ett objekt i rörelse.

(7)

Förord

Jag vill tacka: Erik Ehrlin för kontruktiv kritik och rådgivning, Tomas för hjälp

med att bygga konstruktionen, Staffan, samtliga assistenter, Nihad Subasic, samt

(8)

Innehåll

1 Introuduktion 1

1.1 Bakgrund . . . . 1

1.2 Syfte . . . . 1

1.3 Omfattning . . . . 2

1.4 Metod . . . . 2

2 Teori 3 2.1 Upptäcka och följa objekt med laserskanner . . . . 3

2.2 Algoritm och Filter . . . . 4

2.3 LIDAR . . . . 5

2.4 Stegmotorer . . . . 6

2.4.1 Motorspänning . . . . 7

3 Demosystem 9 3.1 Elektronik . . . . 9

3.1.1 Arduino Uno . . . . 9

3.1.2 Lidarsensorer . . . . 9

3.1.3 Motorer . . . . 9

3.2 Mjukvara . . . . 9

3.3 Konstruktion . . . . 10

4 Resultat 13

5 Slutsats och diskussion 19

6 Utvecklingsmöjligheter i framtida projekt 21

Litteraturförteckning 23

Bilagor 24

A Resultat 25

B Kod 33

(9)

C Octave script 41

(10)

Figurer

2.1 ToF-LiDAR [6] . . . . 6

2.2 Laserstråle [5] . . . . 6

3.1 Flödesschema, ritat i draw.io . . . . 10

3.2 Konstruktionen, egen bild . . . . 11

4.1 6 värden i filterkärnan, skapad med GNU Octave . . . . 14

4.2 15 värden i filterkärnan, skapad med GNU Octave . . . . 15

4.3 6 värden i filterkärnan, , skapad med GNU Octave . . . . 16

4.4 15 värden i filterkärnan, skapad med GNU Octave . . . . 17

A.1 10 värden i fiterkärnan, skapad med GNU Octave . . . . 25

A.2 20 värden i filterkärnan, skapad med GNU Octave . . . . 26

A.3 10 värden i filterkärnan, skapad med GNU Octave . . . . 30

A.4 20 värden i filterkärnan, skapad med GNU Octave . . . . 31

(11)

Tabeller

(12)

(13)

Förkortningar

LIDAR Light Detection and Ranging ToF Time of flight

USB Universal Serial Bus

PC Personal Computer

(14)

(15)

Kapitel 1

Introuduktion

1.1 Bakgrund

För att mäta avstånd med en lasersensor krävs det att laserstrålen riktas med bra precision. Det kan därför vara svårare att mäta hastighet och avstånd till något som rör sig och ändrar riktning, till exempel en person som springer, än att mäta avstånd till något som är stilla eller rör sig helt rakt. Sensorn kan alltså behöva vridas. Detta kan göras manuellt, som vid polisens hastighetskontroller, men det kan även göras automatiskt. Ett användningsområde för en sådan sensor är inom idrotten. Att kunna följa hastigheten steg för steg hos någon som springer kan vara värdefullt för den som vill utveckla sin löpteknik. För att förbättra sådana mätningar skulle sensorns laserstråle kunna riktas automatiskt. LIDAR-teknik (Light detection and ranging) kan användas för att skanna omgivningen och det används bland annat på självkörande bilar eller för att skanna av landskap. Tekniken kan även användas för att mäta avståndet till ett visst objekt och följa dess rörelse [1],[2].

1.2 Syfte

Syftet med detta projekt är att undersöka hur objekt kan upptäckas genom att med LIDAR-sensor (Light detection and ranging) skanna ett område i 2D. Detta för att sedan utifrån skannerns information kunna följa objektets rörelser med en hasthetsmätande sensor. Följande forskningsfrågor ska besvaras:

• Hur ska en lasersensors laserstråle automatikst kunna riktas mot ett objekt samt följa dess rörelser?

• Kan stegmotorer vrida på sensorerna tillräckligt precist och snabbt?

• Kan avstånds- och hastighetsmätning av något som rör sig och ändrar rik-

tning förbättras genom att automatiskt rikta en lasersensors laserstråle mot

föremålet?

(16)

KAPITEL 1. INTROUDUKTION

1.3 Omfattning

Lasersensorer som kan mäta upp till 12m kommer att användas i experiment då en budget begränsar inköp av mer avancerade sensorer. Det finns sensorer som har bättre noggranhet, fokus ligger emellertid inte på att få en så perkekt bild som möjligt av avstånd och hastighet, det handlar istället om att få sensorns laserstråle att riktas korrekt. Principen skulle sedan kunna användas med sensorer med bättre räckvidd och noggranhet.

1.4 Metod

För att automatiskt kunna rikta en sensors laserstråle mot önskat objekt byggs en konstruktion där ytterligare en lasersensor används. Med hjälp av en stegmotor skannar den ena sensorn omgivningen i 2D. En andra motor används för att vrida en sensor så att dess laserstråle kontinuerligt riktas mot önskat föremål, detta för att denna sensor hela tiden ska kunna mäta exempelvis en människans position och hastighet. Den avståndsmätande sensorn riktas utifrån informationen från den skannande sensorn.

2

(17)

Kapitel 2

Teori

Detta avsnitt omfattar teori om LIDAR-teknik och dess användningsområden, de ingående komponeterna och hur de fungerar, olika testade filter, samt hur algoritmen för skanning och styrning fungerar.

2.1 Upptäcka och följa objekt med laserskanner

Lasersensorer kan användas för att skanna omgivningen, upptäcka objekt samt för att följa ett objekts rörelser. Detta görs genom att ett område upprepat skannas. In- formationen från tidigare sökningar ger information om objektets rörelse och en ap- proximation av objektets nuvarande position kan göras.[8] För att avgöra vilken typ av föremål som upptäcks kan LIDAR-sensorer användas. Detta kallas klassifierng och kan alternativt göras med hjälp av bildanalys. En fördel med LIDAR-teknik kontra bildanalys är att ljusförhållanden får mindre betydelse [14]. Vid klassifering med avståndsmätande lasersensorer kan det vara nödvändigt att det görs i 3D. Att upptäcka och flöja människor kan emellertid göras med lasersensorer i 2D. Skan- nande lasersensorer med uppgift att upptäcka och spåra männiksor är ofta placerade i höjd med en människas torso och arbetar med fördel enbart i två dimensioner då det är enklare att bearbeta sådan information. Människans kontur kan då avläsas som en klunga av punkter där punkterna represneterar de uppmätta avstånden.

För klassifiering av objekt utan att använda en 3D-skanner kan exempelvis kom- pletterande sensorer i benjöd användas, detta för att kunna dra slutsatser om det är en människa eller inte. Sådana slutsatser kan även dras utifrån vilken typ av rörelser som upptäcks [9].

I [14] används LIDAR-sensorer i 2d för att upptäcka och följa objekt, samt ett

Monte Carlo filter, vilket är ett så kallat partikelfilter. Partikelfilter gör predek-

teringar om framtiden och möjliga alternativ delas upp i så kallade partiklar. I

[13] används ett Kalmanfilter, vilket är besälktat med Monte carlo-metoden, och

här används LIDAR-sensorer i 2d i två olika plan. Med hjälp av ett Kalmanfilter

kan tillståndet i ett någon typ av system beräknas och estimeras, detta utifrån

brusiga mätningar. Det finns många olika typer av Kalmanfilter, och det kan till

(18)

KAPITEL 2. TEORI

exempel användas till att utifrån sådana mätningar beräkna och förutspå ett ob- jekts position och hastighet. Det handlar om att skatta och korrigeringa nuvarande tillstånd utifrån tidigare mätningar och skattningar. I dessa exempel handlar det om LIDAR-skanners på självkörande bilar där hinder måste upptäckas och dess rörelser förutspås samtidigt som fortondets egna position förutses. Filter används även för att få bort brus och felaktiga mätningar. I [12] motiveras användning av LIDAR i enbart två dimensiner med ett grundläggande antagande om att objekten i många miljöer är rätlinjiga vertikalt. Den mest intressanta informanion fås då i det horisontella planet. Ett sådant antagande kan även göras när det handlar om att upptäcka och följa männiksor, såsom i detta projekt.

2.2 Algoritm och Filter

Målet med algoritmen är i det här projektet att den ska vara stabil i många siua- tioner. Objektet ska kunna befinna sig var som helst inom skannerns synfält. Nära, långt bort, långt ut på kanterna och i mitten. Det ska även kunna röra sig mot eller bort från sensorn i hastigheter som en människa förväntas kunna förflytta sig.

Algoritm och filter kan alltså inte optimeras att fungera utmärkt i specifika fall.

Algoritmen som bestämmer hur sensorerna ska riktas, bygger på att för varje steg motorn tar läses ett mätvärde från sensorn. I listan med dessa mätvärden söks sedan ett objekt och en position som är så central som möjligt på objektet. Varje mätvärde får ett korrresponderande motorsteg som beräknas utifrån motorernas ut- gångsläge. Då de båda motorerna har samma utgångsläge kan positionen från den skannande motorn och sensorn användas för att vrida en andra sensor till rätt po- sition med den andra motorn. Listan med mätvärden uppdaters kontinuerligt och varje gång skannern vänder väljs en ny position. För att lättare hitta positionen på objekt filtreras mätvärden från sensorn, sedan estimeras objektets position med de filtrerade värdenas minpunkt. Olika filter har testas och jämförs för att få en så korrekt position som möjligt. Algoritmer utan filter, ett glidadnde medelvärdes- filter samt ett viktat glidande medelvärdesfilter används i olika testfall. Glidande medelvärdesfilter kan utnyttja att värden innan och efter ett aktuellt värde är kända då medelvärdet av ett antal värden innan och efter beräknas[10]. Exempel på hur en beräkning ser ut där två värden innan och efter används visas i ekvation 2.1

Y

^F

[i] = Y [i − 2] + Y [i − 1] + Y [i] + Y [i + 1] + Y [i + 2])

4 (2.1)

, där Y är en vektor och i är vektorns index och Y

^F

är den filtrerade vektorn.

Ett annat sätt att beräkna ett glidande medelsvärdesfilter är genom faltning [10], vilket är en princp där det kan justeras hur mycket fokus som ska ligga på akutellt värde och de närliggande. Elementen multipliceras med en viktfunktion enligt ekvation 2.2

Y (n) = h(n) ∗ x(n) (2.2)

4

(19)

2.3. LIDAR

, där x är insignalen, h är är den så kallade filterkärnan som kan anpassas efter behov, och y är utsignalen. Om summan av h överstiger 1 fås en förstärkning av signalen, om den understiger 1 fås en dämpning. Med ett glidande medelvärdes filter kan minvärdets position i någon mån antas hamna mer centralt på ett ob- jeket med anledning av kringliggande större värdens påverkan på medelvärdet. Då mätvärdena från senosor söks igenom efter varje skann behövs med den metoden ingen förutsägning i realtid av kommande värden, då de redan är kända. Något som skulle kunna tillämpas om nödvändigt är prediktioner om kommande skann, exempelvis med hjälp av ett Kalmanfilter. För att effektivt testa och anpassa filtret sparas testdata som sedan används och plottas i matlab. Se matlabkoder i Bilaga C.

Den hastighetsmätande sensorn använder ett diskret första ordningens lågpass- filter, detta för att få bort brus och för att få mer stabila hastighetsvärden. Låg- passfilter släpper igenom låga frekvenser upp till en viss gräns och dämpar höga frekvenser. Lågpassfiltret som används ges av ekvation 2.3

d

^F

= α ∗ d + (1 − α) ∗ d; (2.3)

, där d

^F

är ett filtretat värde, ett motsvarande ofiltrerat värde och α en konstant som bestämmer hur kraftigt filtret är. Värdet på alpha bestäms av ekvation 2.4

α = (1/f )/k (2.4)

, där f är värdenas frekvens och k en konstant,[11].

Hastigheten beräknas utifrån lasersenorns avståndsmätningar genom att mul- tiplicera avstånd med tid. Detta görs genom att sensorns mätfrekvesn (100Hz) multipliceras med skilladen mellan två avståndsmätningar enligt ekvation 2.5

v = (d

1

− d

⁰

) ∗ f

^s

(2.5)

, där v är hastigheten, d

¹

och d

⁰

är avståndsmätningar från sensorn och f

^s

är mätfrekvens. Koder finns att se i bilaga B.

2.3 LIDAR

Det finns olika typer av LIDAR-teknik (Light detection and ranging) såsom tri- angulation och ToF (time-of-flight). Sensorerna som kommer att användas i detta experiment är av typen ToF. Tekniken bygger på att små pulser av laserljus skickas ut, refelkteras mot ett objekt och sedan skickas tillbaka. Då ljusets hastighet är känd kan tiden det tar för reflektionen att komma tillbaka användas för att beräk- na avståndet enligt ekvation 2.6

d = cτ

2 (2.6)

, där c är ljusets hastighet, τ är tiden, och d är sträckan [2]. Principen är

snabb och exakt. Standardfelet kan vara så litet som 10mm vid mätningar på 10m.

(20)

KAPITEL 2. TEORI

Något som påverkar laserns våglängd och därmed resultaten är temperaturen, ToF- sensroer kan emellertid vanligtvis kompensera för temperaturskillnader på ett bra sätt. Figur 1 visar hur en ToF-Lidar är uppbyggd. [6]

Figur 2.1.ToF-LiDAR [6]

Laserstrålen är något konformad. Figuren visar hur strålen hos en Seeed TF Mini Lidar ser ut.[5]

Figur 2.2.Laserstråle [5]

Formen medför att det blir något enklare att träffa objekt på längre avstånd.

2.4 Stegmotorer

En stegmotor styrs med likström och när motorns lindningar, som alla ligger i statorn, spänningssätts i pulser körs rotorn stegvis. Hur stor vinkel varje steg har varierar och beror på motorns poltal. Denna princip gör att motorn inte kräver någon återkoppling. Eftersom den körs i steg kan positionen hela tiden beräknas om utgångsläget är känt.[7] En nackdel med stegmotorer är att vinkelhastigheten kan vara otillräcklig. Om höga hastigheter krävs kan exempelvis servomotorer vara ett alternativ.

6

(21)

2.4. STEGMOTORER

En liten stegvinkel kommer att krävas för att kunna rikta en lasersensor mot en person i rörelse. Särskilt om personen som lasersensorn ska riktas mot befinner sig på längre avstånd. Om en person som befinner sig på exempelvis 10 meters avstånd från sensorn förflyttar sig 30cm vinkelrätt blir vinkeln som måste justeras 1.71 grader, vilket kan beräknas med ekvation 2.7

α = arctan( l

d ) (2.7)

, där α är vinkeln, d är avstånd till sensorn och l är vinkelrät förflyttning.

Eftersom det handlar om små vinklar kommer en växel att behövas för att kunna positionera korrekt.

2.4.1 Motorspänning

Magnetfältet i motorn altras av strömmen i lindningarna. Motormomentet beror på

magnetfältets styrka och för att strömmen i motorn ska vara tillräcklig krävs en viss

spänning. Som i alla spolar tar det en viss tid att bygga upp ström i lindningarna,

därför blir det svårare att hinna bygga upp tillträckligt med ström för varje steg vid

höga vinkelhastigheter. Vid en tyngre last krävs mer ström [3],[4].

(22)

(23)

Kapitel 3

Demosystem

I detta avsnitt presenteras all utrustning som används.

3.1 Elektronik

3.1.1 Arduino Uno

Arduino Uno är microkontrollern som används för att behandla data från den skan- nande sensorn samt för att styra motorerna. Microkontrollerns processor har en en klockhastighet på 16Mhz och kan matas med spänningar på 7-12V. [16]

3.1.2 Lidarsensorer

Till konstruktionen används två stycken TF Mini LiDAR ToF-sensorer med en räck- vidd på 5m vid en refeklektion på 10%. Normalt innebär det en räckvidd på 12m inomhus och 7m utomhus. Sensorerna har en har en frekvens på 100 mätningar per sekund med en noggranhet på 1% vid 0-6m och 2% vid 7-12m. Laserns sprid- ningsvinkel är 2.3 grader. Den genomsnittliga energiförbrukninen är 0.6W och kräver en inspänning på 4.5-6V. [5]

3.1.3 Motorer

Sensorerna vrids med två tvåfasiga bipolära stegmotorer med en stegvinkel på 1.8 grader. För bättre precision och kontroll används även en stegmotordrivare DDR8825 som bidrar till att motorn kan justeras med en mindre stegvinkel, hela steg, halva steg, 1/4-steg, 1/8-steg samt 1/16-steg samt 1/32-steg. 1/4-steg används i detta projekt. [17]

3.2 Mjukvara

För programmering används Arduinos utvecklingsmiljö Arduino IDE. Programmer-

ingsspråket är C++. [16] Ett program som behandlar informationen från den skan-

(24)

KAPITEL 3. DEMOSYSTEM

nande sensorern och styr stegmotorerna körs på arduinokortet. Programmet är upp- byggt emligt figur

Figur 3.1. Flödesschema, ritat i draw.io

Den hastihetesmätanden senorn koppas till direkt till en PC (Personal Comput- er) via USB (Universal Serial Bus). Ett program skrivet i C++ körs för att beräkna och filtrera hastighetsvärden körs på PC:n. Hur sensorvärden kan läsas från datorns USB-port fås från [15]. Kod finns att se i Bilaga B. För att illustrera sensordata och testning av olika filter används GNU Octave, vilket är en fri programvara med många av MATLAB:s funktioner. MATLAB-script kan köras i GNU octave och programmeringsspråket liknar MATLAB.

3.3 Konstruktion

Lidarsensorsena fästs på varsin motoraxel och motorerna placeras ovanför varandra i en konstruktion, se bild.

10

(25)

3.3. KONSTRUKTION

Figur 3.2.Konstruktionen, egen bild

(26)

(27)

Kapitel 4

Resultat

Vid experiment körs skannern 100 motorsteg per skann vilket motsvarar 45 grader.

Följande plottar visar ofiltrade sensorvärden, filtrerade sensorvärden samt positio- nen som väljs till den andra motorn. Figur 4.1-4.4 visar två olika sekvenser sparade mätvärden testade med olika filter. Y-axeln visar avstånd i centimeter. Vad som sätts till sensorns maxavstånd uppdateras varje gång motorn vänder och beror på de föregående 100 värdenas minvärde.

Tiden det tar för motorn att utföra ett svep på 45 grader och samtidigt läsa från

sensorn är ca 1.2 sekunder. Den positionerande motorn roterar med hastigheten 120

rpm (Revolutions Per Minute). För några ytterligare jämnförselser av olika viktade

filter finns att i se Bilaga A. I bilaga A finns även värden från sensorn samt filtrets

värden att se i tabellform.

(28)

KAPITEL 4. RESULTAT

0 200 400 600 800 1000

0 200 400 600 800

Inget Filter Filter Minvarde

Figur 4.1.6 värden i filterkärnan, skapad med GNU Octave

14

(29)

0 200 400 600 800 1000 0

200 400 600 800

(30)

KAPITEL 4. RESULTAT

0 100 200 300 400 500 600 700

200 400 600 800 1000 1200 1400

Figur 4.3.6 värden i filterkärnan, , skapad med GNU Octave

16

(31)

0 100 200 300 400 500 600 700 200

400 600 800 1000 1200 1400

(32)

(33)

Kapitel 5

Slutsats och diskussion

I resultaten kan ses att filter där många värden tas med i medelvärdesberäkningarna ger positioner mer centralt på objektet om objektet befinner sig nära sensorn. Då objeket befinner sig längre bort blir dalarna som kan ses i figur 4.1-4.4 mycket min- dre. Med en lång filterkärna påverkas de filtrerade värdet mycket av kringliggande värderna och man riskerar att missa objektet. Då mindre dalar är betyligt vanligare för en sensor med uppgift att följa objekt som rör sig i större områden blir ett filter med kortare filterkärna ett mer stabilt alternativ.

Att motorn rör sig långsamt beror inte på den använda motorns begränsningar.

Motorn roterar långsamt då den körs ett steg i taget, detta för att kunna läsa ett värde från sensorn för varje steg. En annan möjlig lösning för att få den skannande motorn att rotera snabbare hade varit att läsa värden från sensorn "i bakgrunden", det vill säga samtidigt som motorn körs, för att sedan räkna och läsa dessa värden samt härleda dem till en motorposition. Denna metod var inte möjlig med Arduinos bibliotek Software Serial där en buffert på enbart 64 bytes är möjlig att lagra. Då ett sensorvärde är 9 bytes kan alltså endast ett fåtal lagras. Den hastighetsmätande sensorn justeras därför drygt varje sekund. En människa som springer kan röra sig i hastiheter omkring 10m per sekund. Om människan försöker springar rakt men driver i någon riktning kan justeringarna ändå vara användbara. Det skulle däremot inte vara möjligt för sensorn att följa en människa som medvetet springer i zick- zack mönster. Med en snabbare skanner skulle även förutsägelser om hur nästa skan kommer se ut lättare kunna göras utifrån antaganden om hur snabbt en människa kan röra sig.

För att sedan i praktiken kunna använda koncepet till att mäta hastighet och avtånd till en människa som springer skulle vidare undersökningar med sensorer med bättre räckvidd även behöva göras, då algoritmen inte kunnat testas i sådana fall. Med de testade sensorerna blir inte heller hastighetsvärdena speciellt intressanta på grund av den begränsade räckvidden.

Något som också kan ses som en begränsning är att algoritmen alltid väljer det närmaste objektet. Därför ska inte större områden än nödvändigt skannas.

Utvecklingsmöjligheter finns, men resultaten visar att algoritmen som används

(34)

KAPITEL 5. SLUTSATS OCH DISKUSSION

ger korrekta positioner och att principen går att använda för att vrida en LIDAR- sensor så att dess laserstråle alltid riktas mot ett objekt i rörelse.

20

(35)

Kapitel 6

Utvecklingsmöjligheter i framtida projekt

En utvecklingsmöjlighet vore att få sensorn att läsa värden samtidigt som motorn

körs. Detta för att få skannern att röra sig snabbare och för att undersöka hur

det skulle påverka resultatet. Något som även kan testas är att använda någon typ

av Kalmanfilter för med hjälp av sannolikhetsberäkningar kunna rikta laserstrålen

ännu mer precist. En annan vidareutveckling kan vara att anpassa sensorns höjd

efter objektet som sensorns laserstråle ska riktas mot.

(36)

(37)

Litteraturförteckning

[1] A Luis Montealegre, M Lamelas, and J Riva ”A Comparison of Open-Source Li- DAR Filtering Algorithms in a Mediterranean Forest Environment"IEEE Jour- nal of Selected Topics in Applied Earth Observations and Remote Sensing, vol.8, 2015, pp.4072-4085.

https://tinyurl.com/y95yzghy

[2] Anas Alhashimi. ”Statistical Calibration Algorithms for Li- dars", Luleå University of Technology, 2016 http://www.diva- portal.se/smash/get/diva2:1194288/FULLTEXT01.pdf

[3] Johansson H. Elektroteknik. KTH, Instutitionen för maskinkostruktion, Meka- tronik, 2013

[4] Motorer [Online] Tillgängligt:

http://www.machinedesign.com/motorsdrives/closer-look-motors-motion [Hämtad 07-04-2018]

[5] Tf mini LIDAR [Online] Tillgängligt:

https://www.seeedstudio.com/Seeedstudio-Grove-TF-Mini-LiDAR-p-2996.html [Hämtad 07-04-2018]

[6] Alhashimi A, Varagnolo D och Gustafsson "Joint Temperature-Lasing Mode Compensation for Time-of-Flight LiDAR Sensors"

Department of Computer Science, Luleå University of Technology ,2015. http://www.mdpi.com/1424-8220/15/12/29854/htm

[7] Acarnley P. STEPPING MOTORS a guide to theory and practice. 4th edition, The Institution of Electrical Engineers, 2002

[8] 8 B Klunge mfl. ”Fast and Robust Tracking of Multiple Moving Objects with a Laser Range Finder"IEEE International Conference on Robotics and Automa- tion, vol.2, 2001, pp.1683-1688.

https://tinyurl.com/ya48s2c3

[9] T Taipalus och J Ahtiainen. "Human Detection and Tracking With Knee-High Mobile 2D LIDAR"IEEE International Conference on Robotics and Biomimet- ics, 2011, pp.1672 - 1677.

https://tinyurl.com/ybs3p7xp

(38)

LITTERATURFÖRTECKNING

[10] Smith S W The Scientist and Engineer’s Guide to Digital Signal Processing Moving Average Filters California technical publishing, 1997

https://tinyurl.com/qafa6qp https://tinyurl.com/yb4std2c

[11] Haugen FDerivation of a Discrete-Time Lowpass Filter ,2008 https://tinyurl.com/n3n4xgb

[12] Z. J. Chong1 mfl. ”Synthetic 2D LIDAR for Precise Vehicle Localization in 3D Urban Environment"IEEE International Conference on Robotics and Automa- tion, 2013, pp.1554-1559.

https://tinyurl.com/ybyq748a

[13] Miyasaka T, Ohama Y, och Ninomiya Y "Ego-Motion Estimation and Mov- ing Object Tracking using Multi-layer LIDAR"IEEE Intelligent Vehicles Sym- posium , 2009, pp.151 - 156.

https://tinyurl.com/y8ezf5u9

[14] Thuy M, Puente Leon F ”Non-Linear, Shape Independent Object Tracking based on 2D Lidar Data"IEEE Intelligent Vehicles Symposium, 2009, pp. 532 - 537.

https://tinyurl.com/ybybkmoa [15] Sensor setup [Online] Tillgängligt:

https://stackoverflow.com/questions/6947413/

how-to-open-read-and-write-from-serial-port-in-c [Hämtad 10-05- 2018]

[16] Arduino [Online] Tillgängligt:

https://www.arduino.cc/ [Hämtad 14-04-2018]

[17] Stegmotordrivare datablad [Online] Tillgängligt:

https://www.pololu.com/file/0J590/drv8825.pdf [Hämtad 25-04-2018]

24

(39)

Bilaga A

Resultat

0 100 200 300 400 500 600 700

200 400 600 800 1000 1200 1400

Figur A.1.10 värden i fiterkärnan, skapad med GNU Octave

(40)

BILAGA A. RESULTAT

0 200 400 600 800 1000

0 200 400 600 800

Figur A.2.20 värden i filterkärnan, skapad med GNU Octave

Tabell A.1. Värden från sensorn samt filtrerade värden

Tabell A.1 Inget filter Filter

1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00

26

(41)

Fortsättning av tabell Inget filter Filter

1173.00 1173.00

1173.00 1162.17

1108.00 1162.17

1173.00 1162.17

1173.00 1173.00

1173.00 1133.83

1173.00 1082.50

938.00 1032.17

865.00 982.67

871.00 932.50

876.00 932.50

872.00 971.67

1173.00 1023.00

1173.00 970.83

1173.00 900.17

558.00 830.00

452.00 709.83

451.00 589.50

452.00 469.00

451.00 451.00

450.00 450.50

450.00 450.17

449.00 451.33

449.00 453.83

459.00 457.50

466.00 485.33

472.00 606.00

617.00 726.67

1173.00 845.67

1173.00 963.50

1173.00 1032.67

1173.00 1125.33

887.00 1075.83

1173.00 1025.17

(42)

BILAGA A. RESULTAT

Fortsättning av tabell

Inget filter Filter 876.00 972.83 869.00 919.00 859.00 912.33 850.00 912.33 847.00 961.83 1173.00 1012.50 1173.00 1064.83 1173.00 1118.67 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00 1173.00

28

(43)

Fortsättning av tabell Inget filter Filter

1173.00 1173.00

1173.00 1159.17

1090.00 1159.17

(44)

BILAGA A. RESULTAT

0 100 200 300 400 500 600 700

200 400 600 800 1000 1200 1400

30

(45)

0 100 200 300 400 500 600 700 200

400 600 800 1000 1200 1400

(46)

(47)

Bilaga B

Kod

1 /∗

2 KTH Royal i n s t i t u t e o f Technology

3 B a c h e l o r T h e s i s a t ITM S c h o o l : D i s t a n c e L a s e r Measurments

4 Emma E h r l i n

5 TRITA−ITM−EX 2 0 1 8 : 75

6 The Code Function : s c a n n i n g and t r a c k i n g

7 8 ∗/

9

10 u n s i g n e d c h a r dta [ 1 0 0 ] ;

11 u n s i g n e d c h a r l e n = 0 ;

12

13 #i n c l u d e <DRV8825 . h>

14

15 #i n c l u d e <Arduino . h>

16

17 #i n c l u d e <S o f t w a r e S e r i a l . h>// s o f t s e r i a l p o r t h e a d e r f i l e

18 //# i n c l u d e <S t e p p e r . h>

19 #d e f i n e MOTOR_STEPS 200

20 #d e f i n e RPM 120

21 #d e f i n e DIR 2

22 #d e f i n e STEP 3

23

24 #d e f i n e RPM1 120

25 #d e f i n e DIR1 6

26 #d e f i n e STEP1 7

27

28 S o f t w a r e S e r i a l S e r i a l 1 ( 4 , 5 ) ; // d e f i n e t h e s o f t s e r i a l p o r t a s S e r i a l 1 , p i n 2 a s RX, and p i n 3 a s TX

29 // c r e a t e an i n s t a n c e o f t h e s t e p p e r c l a s s u s i n g t h e s t e p s and p i n s

30 #i n c l u d e " DRV8825 . h "

31 #d e f i n e MODE0 10

(48)

BILAGA B. KOD

37 DRV8825 s t e p p e r (MOTOR_STEPS, DIR , STEP, MODE0, MODE1, MODE2) ;

38 DRV8825 s t e p p e r 1 (MOTOR_STEPS, DIR1 , STEP1 , MODE01, MODE11, MODE21) ;

39

40 c o n s t i n t n s t e p = 1 0 0 ;

41 i n t a s t e p = 1 ;

42 i n t s t e p p e r 1 p o s =0;

43 i n t step_count = 0 ;

44

45 b o o l s t a r t=f a l s e ;

46

47 f l o a t s e n s o r d a t a [ n s t e p ] ;

48 f l o a t f i l t e r d a t a [ n s t e p ] ;

49 f l o a t minsta =1000;

50

51 v o i d s e t u p ( )

52 {

53 S e r i a l 1 . b e g i n ( 1 1 5 2 0 0 ) ;

54 S e r i a l . b e g i n ( 1 1 5 2 0 0 ) ;

55 s t e p p e r . b e g i n (RPM) ;

56 s t e p p e r 1 . b e g i n (RPM1) ;

57 s t e p p e r . s e t M i c r o s t e p ( 4 ) ;

58 s t e p p e r 1 . s e t M i c r o s t e p ( 4 ) ;

59 S e r i a l 1 . f l u s h ( ) ;

60 S e r i a l . f l u s h ( ) ;

61 }

62 v o i d l o o p ( )

63 {

64 // B o r j a nar man t r y c k e r q

65 i f ( ! s t a r t && S e r i a l . r e a d ( ) != ’ q ’ ) {

66 r e t u r n ;

67 } e l s e {

68 s t a r t = t r u e ;

69 }

70 71

72 w h i l e ( S e r i a l 1 . a v a i l a b l e ( ) >=9) // s e n s o r message a r b y t e s

73 {

74 i f ( ( 0 x59 == S e r i a l 1 . r e a d ( ) ) && ( 0 x59 == S e r i a l 1 . r e a d ( ) ) ) //

Byte1 & Byte2

75 {

76

77 // S e n s o r

78 u n s i g n e d i n t t 1 = S e r i a l 1 . r e a d ( ) ; // Byte3

79 u n s i g n e d i n t t 2 = S e r i a l 1 . r e a d ( ) ; // Byte4

80

81 t 2 <<= 8 ;

82 t 2 += t 1 ;

83

84 u n s i g n e d i n t d i s t = t 2 ;

85 // S e r i a l . p r i n t ( d i s t ) ;

86 // S e r i a l . p r i n t ( ’ \ t ’ ) ;

87

88 s e n s o r d a t a [ step_count ] = d i s t ; // s p a r a s e n a s t e s e n s o r v a r d e

89

34

(49)

90 t 1 = S e r i a l 1 . r e a d ( ) ; // Byte5

91 t 2 = S e r i a l 1 . r e a d ( ) ; // Byte6

92

93 t 2 <<= 8 ;

94 t 2 += t 1 ;

95 u n s i g n e d s t r e n g t h = t 2 ; // s i g n a l s t y r k a

96 // S e r i a l . p r i n t l n ( s t r e n g t h ) ;

97

98 f o r ( i n t i =0; i <3; i ++)

99 {

100 S e r i a l 1 . r e a d ( ) ; // Byte7 , 8 , 9 k a s t a s b o r t

101 }

102

103 // Motor

104

105 step_count += a s t e p ; // Uppdatera hur manga s t e g svepande

motorn har t a g i t

106

107 i f ( step_count == −1 | | step_count == nstep −1)

108 {

109 // byt h a l l pa motorn e f t e r ’ nstep ’ a n t a l s t e g

110 a s t e p = −a s t e p ;

111 // S e r i a l . p r i n t l n ( " vand " ) ;

112 113

114 i n t minpos = 0 ;

115 // i n t l a s t v a l u e =s e n s o r d a t a [ 0 ] ;

116 117

118 f o r ( i n t i =0; i <n s t e p ; i ++) {

119 120

121 i f ( s e n s o r d a t a [ i ]> minsta +700) // c u t h i g h v a l u e s depending on l a s t minimum

122

123 s e n s o r d a t a [ i ]= minsta +700;

124 }

125

126 minsta = 1 0 0 0 0 ; // then f i n d new minimum

127

128 f o r ( i n t i =0; i <n s t e p ; i ++) { // moving a v e r a g e f i l t e r . j i s a d j u s t a b l e

129

130 f l o a t f = 0 ;

131

132 f l o a t N = 0 ;

133

134 f o r ( i n t j =−8; j <9; j ++) {

135

136 i f ( ( i+j )>=0 && ( i+j )<n s t e p ) {

137

138 f += s e n s o r d a t a [ i+j ] ;

139

140 N++;

(50)

BILAGA B. KOD

141

142 }

143

144 }

145

146 f i l t e r d a t a [ i ] = f /N;

147

148 }

149

150 f o r ( i n t i =0; i <n s t e p ; i ++) { // f i n d minimum and i t s p o s i t i o n

151

152 i f ( f i l t e r d a t a [ i ]< minsta && f i l t e r d a t a [ i ] > 0 ) {

153 minsta = s e n s o r d a t a [ i ] ;

154 minpos = i ;

155 }

156 157

158 }

159 160

161 // S e r i a l . p r i n t ( " minpos : " ) ;

162 // S e r i a l . p r i n t ( minpos ) ;

163 // S e r i a l . p r i n t ( ’ \ t ’ ) ;

164 // S e r i a l . p r i n t ( " s e t p 1 p o s " ) ;

165 // S e r i a l . p r i n t ( s t e p p e r 1 p o s ) ;

166 // S e r i a l . p r i n t ( ’ \ t ’ ) ;

167 // S e r i a l . p r i n t ( " minval : " ) ;

168 // S e r i a l . p r i n t l n ( minsta ) ;

169 // S e r i a l . p r i n t ( " v a l : " ) ;

170 171

172 s t e p p e r . move(−minpos+s t e p p e r 1 p o s ) ; // f l y t t a motor 2 t i l l s e n a s t e minpos

173 s t e p p e r 1 p o s=minpos ;

174 f o r ( i n t i =0; i <n s t e p ; i ++) {

175 S e r i a l . p r i n t ( " \ n " ) ;

176 // S e r i a l . p r i n t ( f i l t e r d a t a [ i ] ) ;

177 // S e r i a l . p r i n t ( " \ t " ) ;

178 S e r i a l . p r i n t ( s e n s o r d a t a [ i ] ) ;

179

180 }

181 S e r i a l . p r i n t l n ( " " ) ;

182 }

183

184 s t e p p e r 1 . move ( a s t e p ) ; // f l y t t a svepande mortorn e t t s t e g

185 186

187 w h i l e ( S e r i a l 1 . a v a i l a b l e ( ) >9) // k a s t a b o r t gamla s e n s o r v a r d e n

188 {

189 S e r i a l 1 . r e a d ( ) ;

190 }

191 }

36

(51)

192 }

193 }

194 195 /∗

196 KTH Royal i n s t i t u t e o f Technology

197 B a c h e l o r T h e s i s a t ITM S c h o o l : D i s t a n c e L a s e r Measurements

198 Emma E h r l i n

199 TRITA−ITM 2 0 1 8 : 7 5

200 The Code Function : v e l o c i t y measurements

201 ∗/

202 203

204 #i n c l u d e <s i g n a l . h>

205 #i n c l u d e <e r r n o . h>

206 #i n c l u d e <t e r m i o s . h>

207 #i n c l u d e <u n i s t d . h>

208 #i n c l u d e < f c n t l . h>

209 #i n c l u d e <c f e n v >

210 #i n c l u d e <c s t r i n g >

211 #i n c l u d e <s t d i o . h>

212 #i n c l u d e <i o s t r e a m >

213 #i n c l u d e <math . h>

214

215 i n t f d e s ;

216 b o o l close_now ;

217 v o i d S i g i n t H a n d l e r ( i n t s i g ) { // Hantera s t a n g n i n g av program

218 c l o s e ( f d e s ) ;

219 close_now = t r u e ;

220 }

221

222 // I n s t a l l n i n g a r f o r s e r i a l p o r t

223

224 i n t s e t _ i n t e r f a c e _ a t t r i b s ( i n t fd , i n t speed , i n t p a r i t y ) {

225 s t r u c t t e r m i o s t t y ;

226 memset (& t t y , 0 , s i z e o f t t y ) ;

227 i f ( t c g e t a t t r ( fd , &t t y ) != 0 ) {

228 r e t u r n −1;

229 }

230

231 c f s e t o s p e e d (& t t y , s p e e d ) ;

232 c f s e t i s p e e d (& t t y , s p e e d ) ;

233

234 t t y . c _ c f l a g = ( t t y . c _ c f l a g & ~CSIZE ) | CS8 ; // 8− b i t c h a r s

235 // d i s a b l e IGNBRK f o r mismatched s p e e d t e s t s ; o t h e r w i s e r e c e i v e break

236 // a s \000 c h a r s

237 t t y . c _ i f l a g &= ~IGNBRK; // d i s a b l e break p r o c e s s i n g

238 t t y . c _ l f l a g = 0 ; // no s i g n a l i n g c h a r s , no echo ,

239 // no c a n o n i c a l p r o c e s s i n g

240 t t y . c _ o f l a g = 0 ; // no remapping , no d e l a y s

241 t t y . c_cc [VMIN] = 0 ; // r e a d doesn ’ t b l o c k

242 t t y . c_cc [VTIME] = 5 ; // 0 . 5 s e c o n d s r e a d t i m e o u t

243

244 t t y . c _ i f l a g &= ~(IXON | IXOFF | IXANY) ; // s h u t o f f xon / x o f f c t r l

245

(52)

BILAGA B. KOD

246 t t y . c _ c f l a g |= (CLOCAL | CREAD) ; / / i g n o r e modem c o n t r o l s ,

247 // e n a b l e r e a d i n g

248 t t y . c _ c f l a g &= ~(PARENB | PARODD) ; // s h u t o f f p a r i t y

249 t t y . c _ c f l a g |= p a r i t y ;

250 t t y . c _ c f l a g &= ~CSTOPB;

251 t t y . c _ c f l a g &= ~CRTSCTS;

252

253 i f ( t c s e t a t t r ( fd , TCSANOW, &t t y ) != 0 ) {

254 r e t u r n −1;

255 }

256 r e t u r n 0 ;

257 }

258

259 v o i d s e t _ b l o c k i n g ( i n t fd , i n t s h o u l d _ b l o c k ) {

260 s t r u c t t e r m i o s t t y ;

261 memset (& t t y , 0 , s i z e o f t t y ) ;

262 i f ( t c g e t a t t r ( fd , &t t y ) != 0 ) {

263 r e t u r n ;

264 }

265

266 t t y . c_cc [VMIN] = s h o u l d _ b l o c k ? 1 : 0 ;

267 t t y . c_cc [VTIME] = 5 ; // 0 . 5 s e c o n d s r e a d t i m e o u t

268

269 i f ( t c s e t a t t r ( fd , TCSANOW, &t t y ) != 0 ) {

270 }

271 }

272

273 //Oppna s e r i a l p o r t

274

275 v o i d open_port ( v o i d ) {

276

277 w h i l e ( ! close_now ) {

278

279 f o r ( i n t i = 0 ; i < 5 ; i ++) {

280 s t d : : s t r i n g p o r t = " / dev /ttyUSB " + s t d : : t o _ s t r i n g ( i ) ;

281 i f ( ! close_now ) {

282 f d e s = open ( p o r t . c _ s t r ( ) , O_RDWR | O_NOCTTY | O_SYNC) ;

283 i f ( f d e s < 0 ) {

284 s t d : : c o u t << " e r r o r "<< " \ n " ; / / e r r o r

285 } e l s e {

286 s e t _ i n t e r f a c e _ a t t r i b s ( f d e s , B115200 , 0 ) ;

287 s e t _ b l o c k i n g ( f d e s , 1 ) ; // s e t b l o c k i n g

288

289 t c f l u s h ( f d e s , TCIFLUSH ) ;

290 r e t u r n ;

291 }

292 }

293 }

294 }

295 }

296

297 i n t main ( i n t argc , c h a r ∗∗ argv ) {

298 s i g n a l ( SIGINT , S i g i n t H a n d l e r ) ;

299 close_now = f a l s e ;

38

(53)

300 c o n s t f l o a t f r e q = 1 0 0 . 0 ;

301

302 // Setup

303 open_port ( ) ;

304 f l o a t d i s t 1 = 0 . 0 ;

305 f l o a t d i s t 0 = 0 . 0 ;

306 f l o a t speed_f = 0 . 0 ;

307 s t d : : c o u t << " go " << " \ n " ;

308

309 w h i l e ( ! close_now ) { // S t a r t r e a d

310 c h a r buf = ’ ’ ;

311 i n t nc = 1 ;

312 f l o a t num = 0 . 0 ;

313 s t d : : s t r i n g num_str = " " ;

314

315 // L e t a r e f t e r b o r j a n pa e t t n y t t s e n s o r v a r d e

316 w h i l e ( nc == 1 && buf != 0 x59 ) {

317 nc = r e a d ( f d e s , &buf , 1 ) ;

318 }

319

320 nc = r e a d ( f d e s , &buf , 1 ) ;

321

322 i f ( buf != 0 x59 ) {

323 c o n t i n u e ;

324 }

325

326 // Las i n e t t n y t t s e n s o r v a r d e , byte e f t e r byte

327 nc = r e a d ( f d e s , &buf , 1 ) ;

328 i n t bc = 3 ;

329 u n s i g n e d i n t t 1 ;

330 u n s i g n e d i n t t 2 ;

331 w h i l e ( nc == 1 && bc <10) {

332

333 i f ( bc == 3 ) {

334 t 1 = buf ;

335 }

336

337 i f ( bc == 4 ) {

338 t 2 = buf ;

339 t 2 <<=8;

340 t 2 += t 1 ;

341 }

342

343 nc = r e a d ( f d e s , &buf , 1 ) ;

344 bc++;

345 }

346

347 num = t 2 ;

348

349 num /= 1 0 0 ; // Dela s e n s o r v a r d e t pa 100 f o r a t t f a meter

350

351 // s t d : : c o u t << " d i s t : "<< num << " \ n " ;

352

353 i f ( nc != 1 ) { // Forsok a n s l u t a i g e n om l a s n i n g m i s s l y c k a s

(54)

BILAGA B. KOD

354 c l o s e ( f d e s ) ;

355 open_port ( ) ;

356 }

357

358 d i s t 1 = num ;

359

360 i f ( d i s t 1 > 2 0 ) { /Om d i s t a n s a r s t o r r e an 2 0 , p r i n t a i n g e t

361 c o n t i n u e ;

362 }

363

364 f l o a t a l p h a = ( 1 / f r e q ) / 0 . 2 ; // a l p h a t i l l l a g p a s s f i l t e r

365

366 //Rakna ut h a s t i g h e t

367 f l o a t s p e e d = ( d i s t 1 −d i s t 0 ) ∗ f r e q ;

368

369 // F i l t r e r a h a s t i g h e t med l a g p a s s , s k r i v i n t e ut h a s t i g h e t e r s t o r r e an 20 m/ s

370 i f ( d i s t 0 !=0 && d i s t 1 !=0 && s p e e d < 2 0 ) {

371 speed_f = a l p h a ∗ s p e e d+(1−alpha ) ∗ speed_f ;

372 }

373

374 d i s t 0 = d i s t 1 ;

375

376 i f ( abs ( speed_f ) > 2 0 ) {

377 speed_f = 0 ;

378 c o n t i n u e ;

379 }

380

381 // s k r i v ut h a s t i g h e t e n

382 s t d : : c o u t << " d i s t : "<< d i s t 1 << " \ t "<<" s p e e d : " << abs ( speed_f ) <<

" \ n " ;

383 }

384 r e t u r n 0 ;

385 }

40

(55)

Bilaga C

Octave script

1 c l e a r a l l

2 c l o s e a l l

3 h o l d on

4 l o a d ( ’ u t e . mat ’ ) ; #l o a d data i n Y

5

6 n s t e p = 1 0 0 ;

7

8 s t a r t a = 4 0 0 1 ; #c h o o s e r a n g e t o p r i n t

9 s t o p p a =4100;

10 Y=Y( s t a r t a : s t o p p a ) ;

11

12 #s o r t s e n s o r v a l u e s i n t o m a t rix

13 s e n s o r d a t a=r e s h a p e (Y( 1 : round ( l e n g t h (Y) / n s t e p ) ∗ n s t e p ) , nstep , l e n g t h (Y) / n s t e p ) ;

14 f i l t e r d a t a = [ ] ;

15 minval = [ ] ;

16 minpos = [ ] ;

17

18 #f o r e v e r y sweep

19 f o r i = 1 : numel ( s e n s o r d a t a ( 1 , : ) )

20

21 svep = s e n s o r d a t a ( : , i ) ; #g e t data from one sweep

22 # f i l t e r = [ 0 . 2 5 0 . 2 5 0 . 2 5 0 . 2 5 0 . 2 5 0 . 2 5 0 . 5 0 . 5 1 1 1 1 0 . 5 0 . 5 0 . 2 5 0 . 2 5 0 . 2 5 0 . 2 5 0 . 2 5 0 . 2 5 ] / 9 ; %a n p a s s a r f i l t r e t

23 # f i l t e r = [ 0 . 5 0 . 5 0 . 5 0 . 5 0 . 5 1 1 1 1 1 0 . 5 0 . 5 0 . 5 0 . 5 0 . 5 ] / 1 0 ;

24 # f i l t e r =[1 1 1 1 1 1 1 1 1 1 ] / 1 0 ;

25 f i l t e r =[1 1 1 1 1 1 ] / 6 ; #f i l t e r k a r n a / w e i g h t s f o r f a l t n i n g / moving a v e r a g e

26 rad = conv ( svep , f i l t e r , ’ v a l i d ’ ) ; #f a l t n i n g f i l t e r

27 rad =[ rad ; rad ( end −(numel ( svep )−numel ( rad ) −1) : end ) ] ; #save f i l t e r d v a l u e s

28 f i l t e r d a t a = [ f i l t e r d a t a ; rad ] ;

29

30 [ v a l , pos ] = min ( rad ) ; #Find minimum v a l u e and p o s i t i o n

31 minval = [ minval ; v a l ] ;

32 minpos = [ minpos ; pos +( i −1)∗ n s t e p ] ;

33 end

(56)

BILAGA C. OCTAVE SCRIPT

34

35 #f i l t e r d a t a = conv ( s e n s o r d a t a , f i l t e r , ’ same ’ ) ;

36

37 #s o r t and p r i n t f i l t e r d and u n f i l t r e r d v a l u e s

38 f i l t e r d a t a=r e s h a p e ( f i l t e r d a t a , 1 , numel ( f i l t e r d a t a ) ) ;

39 s e n s o r d a t a=r e s h a p e ( s e n s o r d a t a , 1 , numel ( s e n s o r d a t a ) ) ;

40 n=1: numel ( s e n s o r d a t a ) ;

41 p l o t ( n , s e n s o r d a t a , n , f i l t e r d a t a )

42 p l o t ( minpos , minval , ’ ro ’ ) ;

43 l e g e n d ( " I n g e t F i l t e r " , " F i l t e r " , " Minvarde " )

42

(57)

(58)

TRITA-ITM-EX 2018:75