Lego Mindstorms NXT til robotter - DTU Electronic …etd.dtu.dk/thesis/221228/Bachelorprojekt_1_juli_2008_Nimalendiran.pdf · ii Lego Mindstorms NXT til robotter, Interface til kommunikation

BScE-studerende, Nimalendiran Kailasanathan BScE-studerende, Alan P. Rajendram

Lego Mindstorms NXT til robotter Interface til kommunikation med eksterne sensorer

Bachelorprojekt, juli 2008

ii

Lego Mindstorms NXT til robotter, Interface til kommunikation med eksterne sensorer

Rapporten er udarbejdet af: BScE-studerende, Nimalendiran Kailasanathan BScE-studerende, Alan P. Rajendram Vejledere: Lektor, Nils Axel Andersen, DTU Elektro: Institut for Elektroteknologi Lektor, Ole Ravn, DTU Elektro: Insitut for Elektroteknologi Elektro•DTU Automation Danmarks Tekniske Universitet Elektrovej Bygning 326 2800 Kgs. Lyngby Denmark www.eletro.dtu.dk/forskning/au.aspx Tel: (+45) 4525 3550 Fax: (+45) 4588 1295

Udgivelsesdato:

1 juli 2008

Klasse:

1 (offentlig)

Bemærkninger:

Denne rapport er indleveret som led i opfyldelse af kravene for opnåelse af graden Bachelor i teknisk videnskab (BScE) på Danmarks Tekniske Universitet. Rapporten repræsenterer 15 ECTS point.

Rettigheder:

© Nimalendiran Kailasanathan, Alan P. Rajendram, 2008

iii

FORORD

Denne rapport er skrevet med det formål at undersøge, om det er muligt at skabe en forbindelse mellem Lego Mindstorms NXT og eksterne sensorer. Rapporten henvender sig til personer med interesse for deltagelse i RoboCup og de, som ønsker at konstruere nye sensorer til NXT’en. Det forventes, at læseren har kendskab til reguleringsteknik samt en basal viden om mikrocontrollere og en teknisk indsigt i analog elektronik. Rapporten består af 10 kapitler, hvor det første kapitel er en indledning til projektet, og det sidste er konklusionen. Kapitlerne er skrevet således, at de kan læses uafhængigt af hinanden.

Referencerne kan findes sidst i rapporten. Det skal bemærkes at når der refereres til en kilde, vil der stå [Bx], [Px] eller [Hx], hvor B står for bøger, P for PDF og H for hjemmeside. X’et refererer til hvilket nummer det er svarer til i referencelisten. Kildekoden til Atmel Atmega8 og NXT’en er på den vedlagte cd. Vi vil gerne benytte lejligheden til at takke vores vejleder, lektor Niels Axel Andersen, for hans vejledning og hjælp, når behovet opstod.

iv

ABSTRACT

Over the past couple of years robot technology has developed from only having indus-trial application to become a technology that is used in consumer products. In 2006 Lego introduced the latest edition in the Mindstorms line, Lego Mindstorms NXT. Since there are a limited number of sensors in the basic Lego Mindstorms package, it may be necessary to construct some new sensors to be able to handle larger autonomous tasks. During the project we managed to construct an interface to the NXT, which made it possible to communicate with external sensors. As a prototype we made a line sensor that could follow a black line. The communication between line sensor and the NXT was through an I2C-bus, which is a communication protocol. Because the NXT has improved regulation abilities compared to the RCX, it was possi-ble to implement a PD-controller. The improved regulation abilities are seen in the im-proved motors. Where the RCX has a 9V geared motor without a rotation sensor the NXT has a servomotor with build in encoders. To program the NXT a C like program was chosen, NXC, in place of NXT-G, the soft-ware that comes with the NXT. NXT-G was not suited for heavier tasks because larger programs become confusing. Furthermore a program created in NXT-G takes up more than 10 times the space of a program created in NXC. The constructed line sensor was examined by entering it in DTU RoboCup competition. RoboCup has a lot of different challenges, which provided the possibility of making regulation examinations of the Lego Mindstorms NXT. The RoboCup’s lighting condition was different from where we had tested our robot, but since our light sensor was constructed to remove the ambient light, the influence of the powerful lighting condition was not as significant. To our great disappointment the robots line sensor was damaged under the test run. Hence it was not possible to enter the qualification round for the RoboCup. Under last test run the robot had too much speed coming down a ramp. Even though we didn’t enter the RoboCup we accomplished our main goal of constructing a fully functional line sensor.

v

RESUMÉ

I løbet af de seneste par år har robotteknologien udviklet sig fra kun at være anvendt i industrien til at være en teknologi, som anvendes i produkter til forbrugere. I 2006 introducerede Lego deres nyeste produkt i Minstorms-serien, nemlig Lego Mindstorms NXT. Da der kun følger et begrænset antal sensorer med i Lego Mindstorms NXT grundsæt, kan der opstå behov for konstruktionen af nogle nye sensorer for at kunne klare større autonome opgaver. I forbindelse med projektet er det lykkedes at konstruere et interface til NXT’en, hvilket har muliggjort kommunikation med eksterne sensorer. Som prototype er der lavet en linjesensor, som kan følge en sort linje. Kommunikationen mellem linjesensoren og NXT’en forgår over en I2C-bus, som er en seriel kommunikationsprotokol. Da NXT’en har fået forbedret reguleringsegenskaberne i forhold til RCX’en, var det muligt at implementere en PD-regulatator. De forbedrede reguleringsegenskaber kommer til udtryk i en forbedret motor. Hvor RCX’en har en 9V gearet motor uden rotationssensorer, har NXT’en en servomotor med indbygget enkoder. Til at programmere NXT’en valgtes NXC, som er et C-lignende program, der erstatter det medfølgende software, NXT-G. Det viste sig, at NXT-G ikke er velegnet til større programmeringsopgaver, da større programmer hurtigt bliver uoverskuelige. Desuden fylder et program lavet i NXT-G mere end 10 gange så meget som et program lavet i NXC. Den konstruerede linjesensor til NXT’en blev anvendt under deltagelsen i DTU RoboCup konkurrencen. RoboCup havde en lang række forskellige udfordringer, som gav muligheder for at lave reguleringstekniske undersøgelser af Lego Mindstorms NXT’en. RoboCup-banens lysforhold var anderledes fra dem, vi tidligere havde testet robotten under, men da vores linjesensor var konstrueret til at frafiltrer det omgivende lys, var påvirkning fra det kraftige lys mindre betydeligt. Til vores store skuffelse blev robottens linjesensor beskadiget under testkørselen, så det var ikke muligt at stille op til kvalifikationsrunden til RoboCup. Under den sidste testkørsel havde robotten for meget fart på ned af rampen. Selvom vi ikke stillede op til RoboCup, opfyldte vi vores hovedmålsætning, som var at konstruere en fuldt funktionsdygtig linjesensor.

vi

INDHOLDSFORTEGNELSE

Forord ............................................................................................................................. iii

Abstract ........................................................................................................................... iv

Resumé ............................................................................................................................. v

Indholdsfortegnelse ........................................................................................................ vi

1 Indledning ..................................................................................................................... 1 1.1 Problemstilling ........................................................................................................ 1 1.2 Problemformulering ................................................................................................ 2 1.3 Afgrænsning og forudsætninger .............................................................................. 2 1.4 Metode ..................................................................................................................... 3

2 Lego NXT ...................................................................................................................... 5 2.1 NXT klodsen ........................................................................................................... 5 2.2 Motor ....................................................................................................................... 6 2.3 Sensorer ................................................................................................................... 6 2.4 NXT vs RCX ........................................................................................................... 7 2.5 Software til NXT’en ................................................................................................ 7

3 Motortest ..................................................................................................................... 11 3.1 Test af motorens hastighed .................................................................................... 11 3.2 Stepresponser......................................................................................................... 11

4 Introduktion til Digital I2C-bus kommunikation .................................................... 17 4.1 Inter-Integrated Circuit bus, I2C, kommunikation................................................. 17

5 Interface modul til NXT’en til kommunikation med eksterne sensorer ............... 23 5.1 Atmel ATmega8 mikrocontroller .......................................................................... 23 5.2 Hardwaredesign af I2C kommunikations interface ............................................... 25

6 Design af Linjesensor til NXT’en .............................................................................. 31 6.1 Lyssensorer ............................................................................................................ 31 6.2 Afstand mellem sensorerne ................................................................................... 38 6.3 Frafiltrering af omgivende lys og hastighedsbegrænsning .................................... 40 6.4 Kalibrering af linjesensoren .................................................................................. 41 6.5 Del konklusion ...................................................................................................... 44

7 Hardwaredesign af linjesensor .................................................................................. 45 7.1 Valg af komponenter ............................................................................................. 45

Indholdsfortegnelse

vii

7.2 Fototransistorer og dioder ..................................................................................... 45 7.3 Prototype af linjesensor ........................................................................................ 49

8 Programmering af ATmega8 og NXT ..................................................................... 51 8.1 Programmering af ATmega8 ................................................................................ 51 8.2 Programmering af NXT’en ................................................................................... 53

9 RoboCup ..................................................................................................................... 55 9.1 Banen .................................................................................................................... 55 9.2 Strategier og Løsninger ......................................................................................... 57 9.3 Regulator ............................................................................................................... 63 9.4 Robotdesign .......................................................................................................... 64 9.5 Odometri ............................................................................................................... 65 9.6 RoboCup deltagelse .............................................................................................. 66

10 Konklusion ................................................................................................................ 67 10.1 Resultater ............................................................................................................ 67 10.2 Perspektiver ........................................................................................................ 68 10.3 Videre arbejde ..................................................................................................... 69

Referencer ........................................................................................................................ I

A Beregning af max hastighed ..................................................................................... IV

B Kredsløbsdesign af prototypen af linjesensoren ..................................................... V

ix

LISTE OVER FIGURER

Figur 2-1: NXT’ens system arkitektur ............................................................................ 6

Figur 2-2: Screenshot af et simpel NXT-G program ....................................................... 8

Figur 2-3: Screenshot af et simpelt NXC program. ......................................................... 9

Figur 3-1: Plot af alle stepresponser på motorens position. .......................................... 12

Figur 3-2: Plot af stepresponser på motorens position for hastigheden 50 %. .............. 13

Figur 3-3: Plot af stepresponser på motorens position for hastigheden 100 %. ............ 13

Figur 4-1: I2C-bus forbindelse. ..................................................................................... 18

Figur 4-2: Tidspunkter hvor SDA data linjen har mulighed for at ændre sig mens SCL er høj, er givet ved start, gentagende start og stop tilstande. .............. 19

Figur 4-3: Stabil tilstand af SDA i de tilfælde SCL er høj. .......................................... 19

Figur 4-4: Overførelse af data over I2C-bussen, hvor data er placeret i SDA linjen og hvor SCL linjen ændre sig mellem høj og lav ....................................... 20

Figur 4-5: En typisk datatransmission .......................................................................... 21

Figur 4-6: Bit sekvensen for læsning fra en slaveenhed. ............................................... 22

Figur 5-1: Atmel ATmega8 mikrocontroller pin konfiguration ................................... 24

Figur 5-2: Indgangsport på Lego Mindstorms NXT. ................................................... 26

Figur 5-3: Skematisk oversigt af den interne hardware for input 1. .............................. 27

Figur 5-4: Data overførelse, hvor ATmega8’en er sat op til at være slave transmitter mode. ................................................................................................... 28

Figur 6-1: Linjesensor konfiguration, som består af sendere og modtagere. ............... 32

Figur 6-2: Benyttelse af en sensor til at følge kanten af en linje. .................................. 33

Figur 6-3: Benyttelse af 2 sensorer til at følge kanterne ................................................ 33

Figur 6-4: Benyttelse af 3 sensorer til at følge en linje.................................................. 34

Figur 6-5: Overstyring ved at køre gennem et sving. .................................................... 35

Figur 6-6: Eksempel på, at robotten har mistet linjen når den kører i svinget. ............. 36

Figur 6-7: Benyttelse af 5 sensorer til at følge en linje.................................................. 37

Figur 6-8: Placering af sensorer ..................................................................................... 38

Indholdsfortegnelse

x

Figur 6-9: Illustration af lysdiodernes lys område og fototransistorernes måleområde ............................................................................................................ 40

Figur 6-10: Udgangsstrømmen med og uden påvirkning af det omgivende lys. ........... 41

Figur 6-11: Graf af intensiteten af sensorerne før kalibrering ....................................... 43

Figur 6-12: Graf af intensiteten af sensorerne efter kalibrering ..................................... 44

Figur 7-1: Sender/modtager kredsløb ............................................................................. 45

Figur 7-2: Grafen illustrer den relative spændingsændring, som afhænger af pull-up modstandsværdien ..................................................................................... 48

Figur 7-3: Prototype af linjesensor ................................................................................. 49

Figur 7-4: Skematisk oversigt over prototypen af linjesensoren .................................... 50

Figur 8-1: DTU RoboCup 2008 forhindringsbane. ....................................................... 57

Figur 8-2: Med IR-CUT filter og uden IR-CUT filter (til højre) ................................... 61

Figur 9-1: Adskilles af I2C-interfacet og linjesensoren .................................................. 69

xi

LISTE OVER TABELLER

Tabel 3-1: De karakteristiske parametre for stepresponset for hastighederne 50 % og 100 %. .......................................................................................................... 14

Tabel 6-1: Udfaldsrummet ved benyttelse af en sensor ................................................. 33

Tabel 6-2: Udfaldsrummet ved benyttelse af 2 sensorer ............................................... 34



Tabel 7-1: Symbolliste til beregning af pull-up modstandsværdien .............................. 46

Tabel 8-1: Sandhedstabel for massemidtpunktsalgoritmen for 4 sensorer, hvor 0 repræsenterer sort og 1 repræsenterer hvid. ....................................................... 59

Tabel 8-2: Sandhedstabel for massemidtpunktsalgoritmen for 4 sensorer, hvor 1 repræsenterer sort og 0 repræsenterer hvid. ....................................................... 60

Tabel 8-3: Regulatorparametre efter Ziegler-Nichols lukket-sløjferegler. .................... 63

1

1 INDLEDNING

1.1 Problemstilling Robotteknologi er en af de nyeste videnskabsgrene, som er ved at blive mere og mere udbredt i det moderne samfund. Fra at være udelukkende anvendt i industrien er robotter kommet tættere på vores hverdag, til løsning af de mest basale dagligdagsproblemer såsom støvsugning og græsslåning. Lego var en af de første, som introducerede en brugervenlig robot, der var anvendelige af alle lige fra børn til folk med en teknologisk baggrundsviden. Lego Mindstorms NXT er det nyeste skud på stammen. NXT’en skulle ifølge Lego have forbedrede reguleringsegenskaber i forhold til RCX’en. I Lego Mindstorms NXT-pakken følger der kun et begrænset antal sensorer med. Det kan derfor være påkrævet, at der konstrueres nogle nye sensorer for at sætte robotten i stand til at klare større autonome opgaver. F.eks. leveres den med kun en lyssensor. Dermed begrænses mulighederne for at følge en linje, og det vil f.eks. være meget svært at detektere forgreninger. For at programmere NXT’en er den udstyret med programmeringsprogrammet NXT-G. NXT-G er meget brugervenligt, men det har sine ulemper. Programmet, som implementeres i NXT-G til NXT’en, kan blive meget større end et program, der er kompileret i et 3. parts programmeringssprog. Større programmer implementeret i NXT-G kan nemt blive meget uoverskuelige, og desuden kan programmerne let have en større eksekveringstid end et det ville være tilfældet, hvis de var skrevet i et 3. parts programmeringssprog. For at håndtere mange parallelle opgaver kræves en hurtig eksekveringstid.

Indledning

2

1.2 Problemformulering Ovenstående problemstilling leder frem til en problemformulering med følgende spørgsmål:

1. På hvilke måder er reguleringsegenskaberne forbedret på NXT’en set i forhold til RCX’en?

2. Hvilket programmeringssprog er hensigtsmæssigt til NXT’en, set fra et

reguleringsteknisk perspektiv?

3. Hvordan skabes der en forbindelse mellem NXT’en og eksterne sensorer? 4. Hvordan konstrueres nye sensorer, som kan kommunikere med NXT’en?

1.3 Afgrænsning og forudsætninger I nærværende projekt konstrueres en linjesensor til NXT’en, som benyttes ved deltagelse ved DTU RoboCup konkurrencen. RoboCup har en lang række forskellige udfordringer, som giver mulighed for at lave reguleringstekniske undersøgelser af Lego Mindstorms NXT’en. Som nævnt i problemstillingen er det ikke muligt at følge en linje ordentligt og detektere forgreninger med kun en lyssensor. Fra tidligere erfaringer i kurset: ”31385 Autonome robotsystemer” ved vi, at det kræver mindst 3 lyssensorer for at følge en linje optimalt. Da det i RoboCup er vigtigt at kunne følge en linje med en stor præcision, er det derfor nødvendigt at købe eller konstruere flere lyssensorer. Da NXT’en kun har et begrænset antal porte til rådighed, vælges det at lave en flere kanals linjesensor, hvor et antal lyssensorer forbindes i et kredsløb. Der vil således kun blive anvendt en port til alle lyssensorerne. For at linjesensoren kan kommunikere med NXT’en, kan det være nødvendigt at konstruere et interface. Da RoboCup indeholder mange forskellige udfordringer, kræver det et omfattende program, som er i stand til at håndtere flere parallelle opgaver. Som anført i problemstillingen er NXT-G’en ikke velegnet til RoboCup, da programmeringssproget er uoverskueligt og har en langsom eksekveringstid. Til at programmere NXT’en vælger vi et højniveausprog, som er baseret på C, da vi har gode erfaringer hermed fra reguleringskurset: ”31340 datamatbaseret regulering”. For at konstruere en lyssensor til NXT’en, er en del komponenter påkrævet. Det forudsættes, at DTU laboratoriet i byg. 326 har de nødvendige komponenter, eller at der investeres i de øvrige komponenter.

Indledning

3

1.4 Metode For at løse ovenstående problemstilling under hensyntagen til de nævnte afgrænsninger vil projektet være inddelt i følgende hovedafsnit:

1. Hvordan Lego Mindstorms NXT’en er opbygget og hvilke software, den er udstyret med

2. Forbindelse mellem eksterne sensorer og NXT’en

3. Konstruktionen af en linjesensor

4. Deltagelse ved DTU’s RoboCup konkurrence

Første fase af opgaveløsningen vil indebære et litteraturstudie med henblik på at opnå kendskab til den grundlæggende teori bag Lego Mindstorms NXT. Kendskabet til den grundlæggende teori skal danne baggrund for en forståelse af, hvordan det er mest hensigtsmæssigt at konstruere en linjesensor og programmere NXT’en. Derudover undersøges de reguleringstekniske egenskaber for Lego Mindstorms NXT’en. På baggrund af litteraturstudiet vil der i anden fase blive fremstillet en linjesensor. De nødvendige komponenter til at fremstille sensorerne tilvejebringes gennem ingeniørassistent Bertil Morelli på DTU. Der laves en skematisk oversigt af linje-sensorens kredsløb i Eagle. I tredje fase lægges en strategi for, hvilke løsninger der ønskes, på baggrund af teorien og udformningen af RoboCup-banen. Desuden testes den konstruerede linjesensor i forbindelse med konstruktionen af en robot til RoboCup. Sidste del af fasen består udelukkende i at deltage i selve RoboCup konkurrencen.

5

2 LEGO NXT

Lego Mindstorms NXT er den nyeste i Mindstorms-serien. Lego Mindstorms er et programmerbart robotbyggesæt, hvor NXT er en videreudvikling af forgængeren RCX. I dette kapitel vil NXT og dens hardware blive beskrevet. Endvidere vil der blive set på, hvordan NXT’en er forbedret i forhold til RCX’en.

2.1 NXT klodsen ”Hjernen” i en Mindstorms robot er den intelligente NXT klods, som kan programmeres og kontrolleres af en PC. NXT’en består af en 32-bit ARM7 mikrocontroller med 256 Kb flash hukommelse og 64 Kbytes RAM. Udover dette har den en 8-bit AVR mikrocontroller med 4 KB flash hukommelse og 512 Bytes RAM. I princippet er der 7 I/O porte, men opbygningen af firmwaren er således, at 4 af input portene er beregnet til sensorer og 3 af output portene er beregnet til motorer. RJ12 kabler anvendes til at forbinde sensorer og motorer til NXT’en. Kablerne ligner RJ11 telefon stik. Lego har valgt at lade firmwaren til NXT være open source. Det er derfor muligt at lave eget hardware og software til NXT’en. Til at programmere NXT’en er et grafisk LabVIEW baseret software, der hedder NXT-G, inkluderet. Til brug for upload og download har NXT en USB port og Bluetooth. Med Bluetooth kan der også kommunikeres med andre NXT’er. NXT klodsen har et 100x64 pixel LCD display, og der er 4 knapper til at navigere et brugerinterface. Den har også højtaler. NXT får strøm enten fra 6 AA batterier eller ved brug af et genopladeligt litium batteri. Af figur 2-1 fremgår det, at kommunikationen mellem den primære mikrocontroller ARM7 og sensorerne/motorerne foregår via den sekundær mikrocontroller, dog undtaget ultralydssensoren og aflæsningen af rotationen af servomotorerne. [H6]

Lego NXT

6

Figur 2-1: NXT’ens system arkitektur [12]

2.2 Motor De medfølgende motor til NXT’en er servomotorer med indbyggede enkoder, som gør det muligt at styre positionen og hastigheden af motorerne meget præcis. Enkoderne har en opløsning på 1 grad. I NXT’ens firmware er der implementeret en PID-regulator til at kontrollere hastigheden og position af motorerne ved at anvende den beregnede position fra enkoderne.

2.3 Sensorer I dette afsnit beskrives de sensorer, der følger med ved køb af NXT grundsættet. Lyssensoren kan måle lys intensiteten i en retning, og har desuden en LED til at oplyse objekter. Med LED slukket kan lyssensoren måle det omgivende lys. Med LED tændt måles det reflekterede lys. Opløsning af lyssensoren er på 10 bit. Dermed antager den målte lysintensitet værdier mellem 0-1023. Lyssensoren er lavet således, at den viser høje værdier ved mørke og lave værdier ved lys. Tryksensoren har ligesom lyssensoren en 10 bits opløsning. Tryksensoren viser lave værdier, når den er trykket, og høje værdier, når den ikke er. Lydsensoren kan måle lydniveauer i dB med en maksimumgrænse på 90 dB, hvilket svarer til en plæneklippers støjniveau. Lydens volumen angives i procenter, hvor 100 % udgør 90 dB. Ultralydssensoren kan anvendes til at måle afstande og detektere bevægelse. Ultralydssensoren virker ved, at den udsender en højfrekvent ultralydsbølge og måler

Lego NXT

7

tiden, det tager for bølgen til at blive tilbagereflekteret. Ultralydssensoren kan måle afstande mellem 0-255 cm og har en præcision på +/- 3 cm. I modsætning til de andre nævnte sensorer er ultralydssensoren digital. Sensoren har en integreret komponent til at analyser og sende data til NXT’en. Kommunikationen mellem NXT’en og ultralydssensoren foregår over I2C-bus. I kapitel 4 vil I2C blive behandlet mere dybtgående.

2.4 NXT vs RCX NXT’en har både fået et nyt design og forbedret hardware i forhold til RCX’en. Udseendemæssigt er Lego gået væk fra deres kendetegnene klodsdesign til et mere strømlinet udseende, og der er blevet plads til en større og bedre LCD skærm. RCX’ens 8 bit mikrocontroller er blevet opgraderet til en 32 bit. Det giver NXT en større hukommelse, og i forhold til RCX’en er NXT’en udstyret med en ekstra sensor port. Det er nu også muligt at tilslutte digitale sensorer til NXT, hvorimod RCX kun havde mulighed for at tilslutte analoge sensorer. Hvor kommunikationen med RCX før forgik via infrarød kommunikation, finder den nu sted over USB og Bluetooth. Ud fra et reguleringsmæssigt perspektiv er den store forbedring at finde i motoren. RCX havde en 9V gearet motor uden rotationssensor, hvor NXT’en er udstyret med en servomotor med indbygget enkoder. For at måle rotationen af en RCX motor, havde Lego lavet en rotationssensor, som kunne tilsluttes til RCX. Rotationssensoren havde en opløsning på en 1/16 af del af en rotation, mens NXT’ens enkoder kan måle helt ned til en nøjagtighed af 1 grad – en forbedring i præcision på over 20 gange i forhold til RCX’en. Udover en større nøjagtighed har den indbyggede enkoder også givet anledning til at implementere en PID-regulator i NXT’ens firmware. På grund af den forbedrede processor og heraf større regnekraft i NXT’en, giver dette mulighed for selv at implementere bedre regulatorer. Den sammenfattede konklusion er, at NXT har stærkt forbedrede reguleringsegenskaber. [H6]

2.5 Software til NXT’en Firmwaren til NXT klodsen er open source, og der er derfor blevet udviklet forskellige software til NXT’en baseret på forskellige programmeringssprog. Programmerings-sprogene til NXT’en omfatter alle de mest populære programmeringssprog – java, C, C++, Matlab mv. På grund af, at der findes meget forskellige software, er det en smagssag, hvilket programmeringssprog der vælges. Da vi er mest fortrolige med C, har vi valgt at begrænse os til kun at se på de mest C-lignende programmer og Legos eget program NXT-G. I de efterfølgende afsnit vil disse software blev beskrevet og der vil blive redegjort for vores endelige valg af software.

Lego NXT

8

2.5.1 NXT-G NXT-G er et grafisk programmerings miljø udviklet af National Instruments til Lego og er baseret på National Instruments’ LabVIEW. Programmet følger med ved køb af NXT’en. At skrive et NXT-G program foregår ved at trække kodeblokke og forbinde dem med linjer. En kodeblok beskriver en handling, f.eks.: Tænd for motor A og sæt den til 50 % af fuld kraft. Ved hjælp af en mangfoldighed af kodeblokke, kan motorerne styres, lave delays, afspille lyde, anvende sensorer mv. Ligesom i almene programmeringssprog er det muligt lave IF statements vha. blokke. Et simpelt program, som tænder motor A og C, sætter den til 50 % af fuld kraft og venter 10 s inden programmet slutter, kan ses på Figur 2-2.

Figur 2-2: Screenshot af et simpel NXT-G program Da NXT-G er rettet mod børn og voksne uden programmeringskundskaber, er det meget brugervenligt og let tilgængeligt. Den største ulempe ved NXT-G er, at et stort program kan blive meget uoverskueligt. For at gøre programmet mere overskueligt kan der med fordel anvendes den nyttige blok Myblock. Ligesom det er muligt med C at lave funktioner, kan der med Myblock laves egne blokke.

2.5.2 NXC NXC (Not exactly C) er et C-lignende højniveau programmeringssprog for NXT’en og er desuden gratis. Et NXC program laves ved at anvende softwaren Bricx. Oprindeligt

Lego NXT

9

var Bricx udviklet til Legos RCX, men sidenhen er Bricx blevet udvidet til også at omfatte NXT’en. [P1] Da NXC bruger samme firmware som NXT-G, kan der umiddelbart skiftes mellem at bruge NXC og NXT-G. I modsætning til NXT-G, har NXC en realtidsdebugger, hvilket gør fejlfinding lettere. Den største ulempe ved NXC er, at den ligesom NXT-G ikke kan regne med floating-points. Det tilsvarende program i NXC til NXT-G programmet på Figur 2-2 ses på Figur 2-3. NXT-G programmet på Figur 2-3 fylder 5420 bytes på NXT’en, mens NXC programmet på Figur 2-2 fylder 346 bytes. At et simpelt program lavet med NXT-G, kan fylde mere end 10 gange så meget som NXC viser tydeligt, at programmer lavet med NXT-G fylder væsentligt mere.

Figur 2-3: Screenshot af et simpelt NXC program.

2.5.3 ROBOTC Med ROBOTC kan NXT’en programmeres i C. Softwaren er et kommercielt produkt udviklet af Robotics Academy på Carnegie Mellon universitetet. På grund af at programmet er kommercielt har det ikke været muligt at teste programmet. Ligesom NXC har ROBOTC også en realtids debugger. Den klare fordel ved ROBOTC er at den kan regne med floating points. En ulempe ved ROBOTC er at den anvender en anden firmware end NXT-G. Dvs. at der kun kan anvendes ROBOTC programmer på NXT’en. [H7]

Lego NXT

10

2.5.4 Valg af Software Til at starte med blev NXT-G udelukket, da programmer lavet på NXT-G til NXT’en hurtigt kan blive uoverskuelig og fylder meget i forhold til et program lavet af et C-lignende program. Valget stod mellem NXC og ROBOTC. ROBOTC og NXC kan mange af de samme ting. En af de store fordele ved ROBOTC er imidlertid, at det kan regne med floating points. Vi har i tidligere kurser lært at programmere uden floating points, og det vil derfor ikke være noget problem. Da NXC samtidigt er gratis og ROBOTC er kommercielt, mente vi, at NXC ville være tilstrækkelig til at opfylde vores behov. Med NXC ville vi desuden have mulighed for at skifte mellem at bruge NXC og NXT-G, da de bruger samme firmware.

11

3 MOTORTEST

Da NXT’en har fået forbedret reguleringsegenskaber grundet servomotoren og indbygget PID regulator, vil en nærmere undersøgelse være af interesse. For at undersøge PID-regulatoren, laves stepresponser på motorens position. Udover at lave stepresponser, vil motorens maksimale hastighed også blive testet i dette kapitel.

3.1 Test af motorens hastighed For at testet motorens hastighed, lavede vi et simpelt program i NXC. Programmet lod motoren køre på fuld hastighed i 30 sekunder for at starte op. Derefter kørte programmet 5 gange i en løkke, hvor rotation af motoren måltes efter 1 minut. Med 5 resultater for omdrejningshastigheden, blev denne bestemt til 149 rpm. For at sikre os, at der ikke var forskel på omdrejningsretningen, kørte vi programmet igennem igen i modsat retning og fik samme resultat. Som yderligere sikring testede vi også med andre motorer og fik stadig samme resultat. Da hastigheden af motoren er afhængige af batteriniveauet, målte vi spændingen på batteriet før hver måling. Batteriets spænding blev målt til 8,22V. Resultatet på 149 rpm ved 8,22V er ikke så overraskende, da omdrejningshastigheden ved 9V er angivet til 170 rpm. [H8]

3.2 Stepresponser Til at lave stepresponset på position udviklede vi et NXC program, som drejede motoren en omgang og loggede data samtidigt i en logfil. Data bestod af målenummeret og positionen af motoren. For at få så mange data som muligt, var der ingen delays i programmet mellem hver måling. Sample tiden var derfor den tid, det tog mellem hver måling. For at beregne sampletiden, måltes tiden i programmet lige inden og efter stepresponset. Ved at sammenholde tidsforskellen før og efter med antal målinger, blev sample tiden beregnet. Efter gentagne forsøg blev sample tiden bestemt til 2,12 ms. I NXC måles hastighed i procent af maksimum hastighed. Stepresponset på position blev lavet for 3 forskellige hastigheder: 10 %, 50 % og 100 % af den maksimale hastighed. For hver hastighed blev der foretaget 3 forskellige stepresponser: Positiv omdrejningsretning (ccw), negativ omdrejningsretning (ccw) og med belastning.

Motortest

12

Belastningen bestod i at lave stepresponset på en køreklar robot på gulvet, hvor der vil være friktion mellem hjul og gulv. For at sikre nøjagtigheden af stepresponset med belastning, blev målinger foretaget 2 gange for hver hastighed. Resultaterne af alle stepresponser ses på Figur 3-1. Ud fra plottet ses en tydelige regulering ved 50 % og 100 %, mens grafen ved den lave hastighed 10 % næsten er lineær. Ved 10 % med belastning er belastning for stor til, at motoren kan dreje.

Figur 3-1: Plot af alle stepresponser på motorens position.

Da regulering kun ses på stepresponserne ved hastigheder 50 % og 100 %, er det interessant at se nærmere på disse. På Figur 3-2 er stepresponset på motorens position for hastigheden 50 % plottet, og på Figur 3-3 er stepresponset ved 100 % plottet. Det fremgår tydeligt af graferne, at der ikke er forskel på omdrejningsretningen af motoren.

0

50

100

150

200

250

300

350

400

450

0 500 1000 1500 2000 2500 3000

rotation

/grade

r

Sample nummer

Steprespons på positionen for alle hastigheder

rotation ccw ‐ speed 50


rotation ccw with load 1‐speed 100


rotation cw ‐ speed 50



Motortest

13

Figur 3-2: Plot af stepresponser på motorens position for hastigheden 50 %.

Figur 3-3: Plot af stepresponser på motorens position for hastigheden 100 %.

0

50

100

150

200

250

300

350

400

450

0 200 400 600 800 1000

rotation

/grade

r

Sample nummer

Steprespons på positionen for hastigheden 50




rotation ccw with load 2 ‐speed 50

0

50

100

150

200

250

300

350

400

450

0 200 400 600 800

rotation

/grade

r

Sample nummer

Steprespons på positionen for hastigheden 100




rotation ccw with load 2 ‐speed 100

Motortest

14

For at sammenligne stepresponset for hastighederne 50 % og 100 %, er de karakteristiske parametre for disse opsummeret i tabel 3-1. Ved stigtid forstås den tid, det tager responset at vokse fra 10 % til 90 % af den stationære slutværdi, og indsvingningstid er den tid det tager for responset at nå inden for et bånd på ± 2 % af den stationære slutværdi.

Tabel 3-1: De karakteristiske parametre for stepresponset for hastighederne 50 % og 100 %.

Rotation/

fart

cw ‐50 ccw

‐50

ccw med

belastnin

g 1 ‐ 50

ccw med

belastning 2

‐ 50

cw ‐

100

ccw ‐

100

ccw med

belastni

ng 1 ‐

100

ccw med

belastni

ng 2 ‐

100

Hastighed 50 50 50 50 100 100 100 100

Oversving 5,5% 5,2% 0,0% 1,6% 14,

2%

13,9% 5,3% 8,4%

Stigtid/ms 676 693 1266 1041 337 352 488 449

Indsvingning

stid/

ms

1107 1126 1602 1346 131

4

1312 833 814

Stationære

fejl/

grader

1% 1% 2% 2% 0% 0% 4% 3%

Af tabellen ses, at ved maksimum hastighed var oversvinget ca. 3 gange større end ved 50 %. Ved både 50 % og 100 % faldt oversvinget markant med belastning, men belastning havde også forsaget, at reguleringen blev langsommere, samt at den stationære fejl også blev større. Uden belastning er den stationære fejl meget lav ved 50 % og 0 ved 100 %. Dette var også forventet, da regulatoren er PID-regulator, som har et integralled, der reducere den stationære fejl. Uden belastning blev stigetiden halveret ved 100 i forhold til 50. Overraskende blev indsvingningstiden større for 100 % end ved 50 %. Det skyldes, at der ved 100 var mere oscillation. Ved at betragte indsvingningstiden med belastning ved 100 %, kan det se ud som om, at regulatoren er blevet hurtigere, men den lavere indsvingningstid i forhold til uden belastning skyldes, at reguleringen stopper forholdsvis tidligt med at regulere, og derfor bliver den stationære fejl også væsentligt større. Ud fra stepresponserne kan det konkluderes at ved middel hastigheder, vil reguleringen være god både med og uden belastning. Her var oversvinget lavt og den stationære fejl

Motortest

15

lille. Ved lave hastigheder kan en belastning forårsage, at ingen regulering vil finde sted. Ved høje hastigheder uden belastning vil den stationære fejl være meget lille og oversvinget stor. Med belastning reduceres oversvinget, men den stationære fejl bliver også væsentligt større. Det er ofte tilfældet, at den bedst regulator ved en given hastighed ikke er den bedste ved en anden hastighed. Lego kan derfor bevidst have dimensioneret PID-regulatoren til at fungere optimalt ved 50 % hastighed. Udover stepresponset på motorens position, prøvede vi også at lave et steprespons på hastigheden, hvor hastighedssteppet var fra 0 til 100 %. Det viste sig, at dette ikke var muligt. Da steppet gik alt for stærkt, kunne der ikke samples hurtigt nok. Logfilen viste allerede 100 ved første måling. [B2]

17

4 INTRODUKTION TIL DIGITAL I2C-BUS KOMMUNIKATION

For at skabe en forbindelse mellem Lego NXT’en og eksterne sensorer, har vi valgt at benyttes os af et digitalt interface, som skal skabe forbindelsen over en I2C-bus. Grunden til vi har valgt at benytte os af et digitalt interface er, at de digitale enheder har flere fordele over analoge enheder. Ved hjælp af et digitalt interface kan de slaveenheder, som skal kommunikere med NXT’en, individuelt udføre deres egen funktionalitet, hvorefter de kun sender data videre til NXT’en. En stor fordel ved NXT’en er den effektivitet, som I2C-bussen giver. Dermed er der næsten ubegrænsede muligheder for at udvide indgangene og udgangene på NXT’en. For at skabe en forbindelse mellem NXT’en og andre hardware enheder, som benytter sig af en I2C- bus, kræves der kun to ledninger, i og med at data bliver serielt transmitteret, dvs. 1 bit ad gangen. Den ene ledning sender og modtager data (SDA), og den anden transmitterer et klok signal (SCL).

4.1 Inter-Integrated Circuit bus, I2C, kommunikation I slutningen af 70’erne blev brugen af små mikroprocessorer og digitale IC’er (Intergrated Circuit) i produkter til forbrugere og til industrien, meget udbredt med anvendelse i alt fra fjernsyn til analoge kredsløb. Som en af de største producenter af forbruger elektronik ønskede Philips et billigt og hurtigt interface, der kunne få IC’erne til at kommunikere med hinanden. Den mest anvendte metode for ”inter- IC communication” på daværende tidspunkt var en parallel bred 8 bit bus. Denne 8 bit bus struktur kræver ikke mindre end 8 data linjer for at overfør data og adskillige linjer for at adressere de enkelte ICere. Philips havde behov for at reducere antallet af kommunikationslinjerne i områder på et printet kredsløb. Det lykkedes dem at reducere antallet af datalinjer fra 8 til 2. Denne kommunikation er kendt som Inter-Integrated Circuit bus, IIC eller I2C (udtales: ”eye-square-see") og blev anvendt i situationer, hvor pris og plads var vigtigere end data hastighed. Ved at skifte fra parallel til synkron seriel kommunikation, lykkedes det Philips, at reducere antallet af data linjer. I2C bussen benytter sig kun af 2 forbindelser, kaldet SCL og SDA. SCL er den serielle klok linje. Klokken benyttes til at synkronisere alle

Introduktion til digital I2C-bus kommunikation

18

dataoverførelserne over I2C bussen. SDA er den serielle data linje. SCL og SDA linjerne er forbundet til alle enheder på I2C bussen. Udover SDA og SCL linjerne kræves der en tredje forbindelse, som er en jord eller 0 volt. Endvidere kan der også være en 5 volt forbindelse, hvis der skal distribueres strøm til I2C enheden. Både SCL og SDA linjerne er ”open drain” enheder, hvilket betyder, at enheden kan drive enhedens output lavt, men ikke højt. For at linjerne kan gå højt, benyttes der pull-up modstande til 5V forsyningen. Desuden skal der være en modstand fra SCL linjen til 5V linjen og en anden modstand fra SDA linjen til 5V linjen. Der kræves kun to ”pull-up” modstande for hele I2C bussen og ikke for hver enhed.

Figur 4-1: I2C-bus forbindelse. [P3]

Modstandsværdierne er ikke af kritisk betydning, og alt fra 1K Ohm til 47 K Ohm burde virke, men det skal bemærkes, at en lavere modstandsværdi giver det bedst mulige resultat. Det er vigtigt, at modstandene er forbundet. Ellers vil SCL og SDA linjerne altid være lave, næsten 0 volt, og derfor vil I2C bussen ikke virke. Standard klok hastigheden, SCL, for I2C er op til 100 kHz. Ved Fast mode er hastigheden op til 400 kHz og ved High speed mode er hastigheden op til 3.4 MHz. [H2] og [P3]

4.1.1 Master og Slaves Enhederne på I2C bussen er masters eller slaves. Masteren er altid den enhed, som driver SCL klok linjen, og slaverne er enhederne, som reagerer på masteren. En slaveenhed kan ikke påbegynde en overførelse af data over I2C bussen. Det er udelukkende kun masteren, som kan begynde en overførsel af data. Der kan være flere slaveenheder, hvilket der i de fleste tilfælde er på den sammen I2C bus. Derimod er der normalt kun en master. Mastere, som kan være en mikrocontroller, vil være kontrolenheden og slaverne vil være modulenheder. Både masteren og slaven kan overfører data over I2C bussen, men overførelsen er altid kontrolleret af masteren. [H2]

Intro

4.1NårI2C bussdet SCL

Figuer h

Nårlængover

Dataøverog lselvoveralt slavmod

oduktion til

.2 Den fysr masteren ø

bussen. Stasen. Den aneneste tidsp

L (klok linjen

ur 4-2: Tidshøj, er givet v

r data bliver ge SCL er hrførelse mel

Fig

a bliver overst er de MSlav. Som detve modstandrført, vil dener der enlig

veenheden redtaget data o

digital I2C-b

siske I2C pønsker at taleartsekvensen nden er en stpunkt, hvor n) er høj.

spunkter hvoved start, gen

overført oveøj. Start- og lem mastere

gur 4-3: Stab

erført i sekvSB (Most Sit tidligere blden, som drn slaveenhedgt 9 SCL keturnerer en og er klar til

bus kommun

protokol e med en sler en af de

topsekvens. SDA’en (da

or SDA data ntagende sta

er SDA linjenstop sekven

en og en slav

bil tilstand a

venser af 8 bignificant Bilev nævnt, kriver SCL ld, som modtklok pulse lav ACK bat acceptere

nikation

aveenhed, se to speciale

Start- og stata linjen) ha

linjen har mart og stop til

n, skal SDA

nserne angiveveenhed.

af SDA i de t

bits. Bitseneit). SCL linjkan selve chilinjen høj. tager data, sefor at overf

bit til mastere en yderlige

ender mastee sekvenser, opsekvensenar mulighed

mulighed for lstande. [P3]

A forblive staer begyndels

tilfælde SCL

e er placereten vil hereftippen ikke dFor hver 8 ende en ACKføre hver 8ren, betyder ere byte. Hv

eren en startsom er defi

n er specielld for at ænd

at ændre sig]

abil og må iksen og afslut

L er høj. [P3]

t i SDA linjfter ændre sigdrive linjen h

bits som mK (acknowle

8 bit byte adet, at slave

vis slaveenhe

tsekvens oveineret for I2Cle, idet det e

dre sig, imen

g mens SCL

kke ændres stningen af en

]

jen, hvor deg mellem høhøj, og det emasteren haedge) bit, såaf data. Hvieenheden haeden derimo

er C er ns

å n

er øj er ar å i is ar od

Introduk

returneredette tilf[P3]

Figur 4-hvor SCL

4.1.3 I2

Hver I2Caf 10 bitbetyder, nummer overført masterenskriver tbits er pSignificaPlaceringbetyder, til venstrog [P3]

4.1.4 I2

Det førsslaveenhSlaveenhDesudende pågævil masteadresse, som bliv

ktion til digit

er en høj bitfælde, skal m

-4: OverføreL linjen ænd

2C-enhedsC slave enhets er meget s

at man kankan antagei sekvenser

n skriver elltil slaven, ogplaceret øveant Bit). gen af de 7 at for at skr

re. For at læ

C softwarste skridt i heder er, ahederne på In skal de værldende slaveeren sende svil forsætte

ver fortaget a

tal I2C-bus k

t, indikerer masteren stan

lse af data odre sig melle

s adresseed skal have sjældent, og n have op tie værdier frar af 8 bits. Dler læser til g omvendt, erst i data b

adresse bit rive til adresse, skal adre

re protokokommunik

at masterenI2C bussen sre forbedret eenheder, soslaveenhede

e med transaaf den pågæ

kommunikat

slaven, at dndse overfør

over I2C-bussem høj og lav

ering en unik adrderfor har dil 128 slavea 0 til 127. Den 8. bit bslaven. Hv

hvis den er byten, og R

øverst i datse 21, skal messen være 4

ollen ationsproces

n sender ekal være oppå, at maste

om er forbunens adresse. aktionen, ogældende tran

ion

den ikke kanrelsen ved at

sen, hvor datv [P3]

resse. I2C er de mest almie enheder på

Som det tibenyttes til is den 8 bit1, læser ma

Read/Write b

ta byten kanman faktisk 43. Dvs. at læ

ssen mellemen startsekvmærksomme

eren ønsker andet på I2CDen salveen de øvrige ssaktion, og

n acceptere yt sende en s

ta er placere

7 bits eller ndelige chipå I2C bussenidligere blevat informer

t er 0, betydasteren fra sbiteen er pla

n være lidt fsende 42 somæse/skrive b

m masteren vens ud pe på, at en trat starte en trbus linjen.

nhed, som sslaveenhedervente til der

yderligere dtopsekvens.

et i SDA linje

10 bits. Benps 7 bit adresn, eftersom

v nævnt, blire slaveenheder det, at mslaven. De 7aceret i LSB

forvirrende, m er 21 shif

bit er ulige/li

og de pågå I2C busransaktion eransaktion mEfter startsesvarer til der vil ignorerr bliver start

data, og i [H2] og

en og

nyttelsen sser. Det et 7 bit

iver data eden, om masteren 7 adresse B (Least

men det fted 1 bit ige. [H2]

gældende s linjen. er startet. med en af ekvensen n sendte r alt det, tet en ny

Intro

trantranellerNumintede fmassendmedefteden en sønsk

4.1Før slavmasslavbiteHeradremasen s

oduktion til

nsaktion, dvsnsaktionen mr et register mmeret afhærne registre fleste har. Esteren sende dte bytes vil d at sende, rsom slavenhar modtag

stopsekvens,ker at skrive

1. Send en 2. Send sla3. Send det4. Send dat5. (eventue6. Send sto

.5 Læsninmasteren k

veenhedens isteren med aven, sendes dn lav (lige

refter sendesessen igen –steren læse lstopsekvens.

digital I2C-b

s. når mastemellem maste

nummer i sænger selvføl

den har. DeEfter at havden ønskedenormalt starog efterfølg

n automatiskget. Når mast, som fuldene til en slavee

startsekvensaveenhedens t interne regtabyten elt, send flereopsekvensen

Figu

ng fra en skan læse dainterne regi

at skrive til sder følgendeadresse) og

s en anden s– men denneige så mang

bus kommun

eren igen seeren og slaveslaveenhedelgelig af, hv

e meget simpve sendt I2Ce data byte (rte med at bgende vil dek vil forøge teren er færdnder transaktenhed, skal f

s I2C adresseister numme

e data bytes)

r 4-5: En typ

slaveenheata fra en strer masterslaven. Som e: en start seg det internstartsekvens gang med R

ge data bytes

nikation

ender en nyeenheden skn, som mast

vilken slaveeple slaveenh

C adressen o(eller bytes, live placerete øvrige bytden interne

dig med at stionen mellefølgende pun

med en lav er, som mast

)

pisk datatran

ed slaveenhed,

ren vil læsedet er tilfæl

ekvens, slavne registrer

(som i nogR/W biten ss, som den ø

y startsekvenal masteren teren ønsker

enhed, der erheder har ingog de interndet behøver t i det registetes blive ge

e register adende data tilem masterennkter opfyld

R/W bit (ligteren ønsker

nsmission [P

skal mastee fra. For atldet, når masvens I2C adrnummer, m

gle tilfælde kat til høj (lig

ønsker, og af

ns. Som detsende en intr at skrive er anvendt, oggen interne rne register aikke kun at

er, som mastemt i de øvdresse efter hl slaven, senn og slaven. des: [H2] og

ge adresse) at skrive til

P3]

eren fortællt læse fra ssteren ønskeresse efterfu

man ønsker kaldes en rege adresse). fslutte transa

t næste led tern placerineller læse frag hvor mangregistrer, meadresser, kavære en). Dteren started

vrige registrehver ny bytender mastere

Så hvis ma[P3]

e, hvilket alaven, starte

er at skrive tlgt med R/Wat skrive ti

estart) og I2CHerefter ka

aktionen me

i ng a.

ge en an De de e, e,

en an

af er til W il. C

an ed

Introduk

Hidtil ermasterenmasterenDer kan opgaver,interruptønsker aregister. at sende protokolhvilket mmasterendata fra mat pull-uarbejde, vil I2C p

ktion til digit

Figu

r det vist, at n læser fra sn, der kontroopstå proble, ikke er klat rutine, gemat læse fra, Denne procklok pulser

len løser detman også kan, vil slavenmasteren, pl

up modstandså længe slaortene autom

tal I2C-bus k

ur 4-6: Bit s

etablering aslaven, er deollere klokkeemer, når slaar til at sendmme de arbeog modtage

ces kan tage r på SCL lintte problem. alder for ”cl

n holde klok lacerer den ien kan træk

aveenheden hmatisk fortag

kommunikat

ekvensen fo

af en I2C koet slaven, soen. Hvad nu

aveenheder sde data. Mikejdende regie data og plamange μs, onjen, som sSlaveenhed

lock strechinsignal linje

i transmissiokke klokken holder klok ge denne pro

ion

or læsning fra

mmunikatioom placerer u hvis slavensåsom mikrokrocontrolleristre, finde uacere dem i

og i mellemtlaveenheden

den har muligng”. Når slaen lav. Mikrons registrerehøj. Mastersignal linjen

oces. [H2] og

a en slaveen

on ikke har vdata på SDAn ikke er kl

ocontroller, dren skal derfud af, hvilkei den pågæltiden vil masn ikke kan gghed for at haven får en rocontrollereet og frigøreren kan sålen lav. I det flg [P3]

nhed.

været vanskeA linjen, melar til at sender skal udføfor benytte sen adresse mdende transmsteren blive give responsholde SCL lilæse komm

en modtager e klok linjenedes ikke forleste mikroc

elig. Når en det er

nde data? øre andre sig af en masteren missions ved med

s på. I2C njen lav,

mando fra herefter

n, således rsætte sit ontroller

23

5 INTERFACE MODUL TIL NXT’EN TIL KOMMUNIKATION MED EKSTERNE SENSORER

Som nævnt i forrige kapitel, har vi valgt at benytte en I2C -forbindelse for at forbinde de eksterne sensorer med NXT’en. For at skabe en forbindelse kræves et interface, som kan kommunikere med NXT’en og med de eksterne sensorer, som ønskes koblet til NXT’en. Interfacet, som skal kommunikere med NXT’en over I2C-bus, skal mindst have 3 kanaler A/D-convertere, således at de analoge signaler fra de eksterne sensorer kan blive digitaliseret. Grunden til, at der minimum skal være 3 kanaler, er, at vi har valgt at lave en analog linjesensor, der består af tre phototransistorer, som skal kommunikere med NXT’en. Interfacet, som skal kommunikere med NXT’en, skal derfor opfylde nogle specifikke krav. Følgende krav skal være opfyldt:

1. Digital I2C-bus kommunikation med NXT 2. Minimum 3 kanaler A/D-convertere

Udover opfyldelsen af ovennævnte krav vil der ved designet af interfacet blive taget hensyn til følgende:

3. Lave omkostninger 4. Høj effektivitet 5. Nemt at programmere 6. Mulighed for udvidelse 7. Et lille design

5.1 Atmel ATmega8 mikrocontroller Fra kurset ”31371 Industriel og indlejret automation”, havde vi erfaring med Atmels 8 bits ATmega-serie mikrocontroller og programmering af mikrocontrollere med programmeringsboardet STK500. Således vidste vi, at disse mikrocontrollere ville opfylde vores krav. Det var derfor oplagt, at benytte en af disse mikrocontroller og STK500. ATmega-serien indeholder adskillige varianter af forskellige konfigurationer af digitale I/O-ben, 8 og 16 bit tællere/timere, pulsbreddemodulering(PWM:Pulse Width

Interface modul til NXT’en til kommunikation med eksterne sensorer

24

Modu-lation), TWI (også kendt som I2C) og SPI for interfacing til andre enheder, UART til seriel kommunikation, 10-bit A/D-omsætter m.v. ATmega-serien udgøres af ATmega 8, 16, 32, 64 og 128. Tallet referer til mængden af flash-hukommelse (i kB). Valget blev Atmels ATmega8 mikrocontroller. ATmega 8 har 1 kB ram og fås som 28 – pin DIL eller i TQFP-32 til overflademontering. Vi valgte at benytte os af 28-pin DIL modellen, idet de er lettere at håndtere, når man skal lodde dem, og endvidere kan TQFP-32 modellen umiddelbart ikke monteres i STK-udviklingskittet. Til dette kræves et udvidelses-modul (STK501), der har en særlig ZIF-sokkel til TQFP- modellerne. Her skal nævnes nogle af de egenskaber ATmega8 har:

• 8-Kbyte self-programming Flash Program Memory • 1-Kbyte SRAM • 512 Byte EEPROM • JTAG interface for on-chip-debug • Tre PWM kanaler • 6 kanaler 10-bit ADC • Master/Slave SPI • TWI (I2C) interface • 2 External Interrupts

Figur 5-1: Atmel ATmega8 mikrocontroller pin konfiguration [P3]

Atmels ATmega-serie mikrocontroller kan programmeres ved hjælp af Assembler eller C. Assembler kan virke ret uoverskueligt til programmering på en PC, hvorimod C er mere overskueligt. Vi har valgt at benyttes os af C som programmeringssprog. Det skyldes, at C åbner muligheder for på en lettere måde at implementere mere avancerede


25

algoritmer, og samtidige gør anvendelsen af C det lettere at vedligeholde og genbruge koden. Valget af Atmega8 mikrocontrolleren skyldes, at den er billig, lille og vigtigst af alt, at den opfylder vores krav. [P3]

5.2 Hardwaredesign af I2C kommunikations interface Som tidligere nævnt er det vort ønske, at interfacet kan kommunikere med andre sensorer end en sensor til blot at registrere en linje. På grund af RoboCup var der en tidsmæssig begrænsning, som gjorde, at kontrolleren og sensorerne til linjedetektering blev designet på den samme printplade. Desuden var det nemmere at håndtere linjesensoren ved at have kommunikationsinterfacet på den samme printplade. Prototypen af interfacet er derfor afhængig af linjesensoren. Det skal dog bemærkes, at det der nogle få ændringer, som skal til for at adskille linjesensoren og interfacet i 2 forskellige hardwareenheder. Derfor spiller det ikke så stor en rolle, at linjesensoren og kommunikationsinterfacet er på det samme print. I afsnittet: ”Videre arbejde” vil vi kort beskrive, hvorledes interfacet og linjesensoren kan adskilles, således at andre eksterne sensorer kan kobles til interfacet, og derved kommunikere med NXT’en. Designet af interfacet kræver en række hardware oplysninger om NXT’en og ATmega8. I de følgende kapitler beskrives vigtige hardwarespecifikationer, som der skal tages hensyn til ved designet af interface modulet.

5.2.1 Lego NXT I2C hardwarespecifikation Siden lanceringen af Lego Mindstorms NXT havde Lego allerede fra dag et, både åben kildekode og udviklingsværktøjer til rådighed for alle, der måtte have lyst til at pille, rode, rage og skille tingene ad. Man er endda gået så vidt, at Lego-brugere opfordres til selv at udvikle hardware og sensorer med videre. Lego har valgt at gøre NXT’en til ”open source”. På Legos hjemmeside kan man downloade, kildekoden samt hardwaredesignet af NXT’en. Desuden har Lego lavet en hardwarespecifikation til de medfølgende sensorer og NXT-klodsen. Denne hardwarespecifikation af NXT’en gør vores arbejde lettere med at designe et interface, som kan kommunikere med NXT’en. Et af de interface, NXT’en har, er dens I2C - bus. Ved hjælp af I2C - bussen kan NXT’en blive forbundet til en række intelligente sensorer, og i praktisk kan NXT’ens inputs og outputs udvides til uendelige mange. I2C - bussen er placeret på input porten. Da der er 4 input porte, har NXT’en 4 I2C - kommunikations kanaler, en for hver port. Som nævnt i I2C – teorien kræves der kun to ledninger, eftersom data bliver serielt overført. Den ene ledning sender og modtager data, SDA, og den anden er en klok SCL.


26

På input porten, er SDA pin 6 (DIGx1) og SCL er pin 5 (DIGx1), på NXT inputkablet er det henholdsvis den blå og gule ledning. Desuden kræves der en jord for at benytte I2C bussen. Jorden er pin 2 og 3, og henholdsvis sort og rød ledning i NXT kablet.

Figur 5-2: Indgangsport på Lego Mindstorms NXT. [P5]

Den digitale I2C kommunikations bus er implementeret således, at NXT’en kun kan optræde som master på I2C bussen, dvs. at det er NXT’en, som kontrollerer datatilstrømningen i hver af de 4 kommunikations kanaler. Et vigtigt aspekt for at få I2C kommunikationen til at virke mellem to enheder er hardware konfigurationen for hver af enhederne. Forneden ses en skematisk oversigt over hardwaren for det interne input port 1 i NXT’en. Den skematiske oversigt er den samme for de øvrige input porte 2, 3 og 4, set fra et I2C kommunikations synspunkt.


27

Figur 5-3: Skematisk oversigt af den interne hardware for input 1. [P5]

1. Der er en 4,7 K modstand i serie med data linjen, SDA. Det sikrer, at der ikke sker nogen kortslutning på data linjen.

2. Der er ikke nogen pull-up modstande internt i NXT’en, og det anbefales at benytte en 82 K modstand som pull-up modstand på både SDA linjen og SCL linjen.

3. I2C ‐ kommunikationshastigheden er på 9.600 bit/s

4. Hver kanal har en 16 byte input buffer og en 16 byte output buffer. Derfor er den maksimale data, som kan sendes og modtages ved hver overførelse, på 16 bytes.

5. Hvis der er forbundet flere sensorer i sekvens til den samme sensor port, skal den resulterende pull-up modstanden være på 82 K. Derfor skal der foretages overvejelser, når der forbindes flere sensorer i sekvens i den samme port.


28

Det skal nævnes, at hver slaveenhed har en unik 7 bit adresse. I I2C-teorien blev det nævnt, at der ved benyttelse af en 7 bit adresse kan der kobles op til 127 slaveenheder på I2C-bussen. Men der er en praktisk hardware begrænsning, som kun gør det muligt at koble op til omkring 8 slaveenheder til NXT’en [B3]. Når NXT’en vil kommunikere med en slave enhed, sender NXT’en en adresse og en enkelt bit for at fortælle, om NXT’en vil læse eller skrive. Herefter returnerer slaveenheden en bekræftelses bit. Når NXT vil læse fra slaveenheden, forventer NXT’en, at data straks bliver overført efter at bekræftelsesbiten er modtaget. [P5]

5.2.2 TWI interface modul på Atmel ATmega8 mikrocontroller Da Philips har patent på I2C - forbindelsen, kræves det, at Philips udsteder licens til Atmel. Af økonomiske årsager har Atmel valgt at kalde deres to-lednings bus for TWI (Two Wire serial interface). De er vigtigt at bemærke, at det er muligt at bruge TWI-systemet til at kommuniker med eksterne enheder efter Philips I2C - standard. Gennem denne rapport vil betegnelsen I2C benyttes i stedet for TWI. Atmega8 mikrocontrolleren kan både være master og slave på I2C - bussen, men da NXT’en kun kan være master, vælges ATmega8 til at være slave, da ATmega8 skal sende data til NXT’en.

Figur 5-4: Data overførelse, hvor ATmega8’en er sat op til at være slave transmitter mode. [P3]

Pin 27 er SDA linjen og pin 28 er SCL linjen på ATmega8. Det skal bemærkes, at pin 27 og 28 også er A/D-converter kanal 4 og 5. Det bevirker, at benyttelsen af I2C forbindelsen begrænser antallet af A/D-converter kanaler til 4 i stedet for de 6, der ville havde været til rådighed, hvis I2C - forbindelsen ikke havde været anvendt. For at skabe en I2C forbindelse mellem NXT’en og ATmega8’en skal følgende krav være opfyldt:


29

• Pull-up modstande fra SDA og SCL linjerne installeres til forsyningsspændingen

Vcc, hvor det anbefales at benytte en 82 KΩ modstand

• ATmega8 skal fungere som slave, da NXT’en altid er master Nu, hvor der er skabt en forbindelse mellem NXT’en og ATmega8 mikrocontrolleren, er det muligt at sende data fra mikrocontrolleren til NXT’en. Som det næste led i kontrollerdesignet skal de eksterne sensorers analoge signaler konverteres til digitale værdier. Til dette benyttes ATmega8s indbyggede A/D-omsætter. [P3]

5.2.3 A/D omsætter på Atmel ATmega8 mikrocontroller A/D-omsætteren tager et analogt signal i form af en spænding, og konverterer det til en digital værdi i mikrocontrolleren. A/D-omsætteren i ATmega8 mikrocontrolleren har en maksimal opløsning på 10 bit, og kan aftaste et signal op til 15.000 gange pr sekund (15 kSPS). Hvis det analoge signal ikke er en spænding, må signalet først omsættes. Strømme kan måles som spændingsfald over en lille målemodstand. A/D-omsætteren på ATmega8 har 6 indgange, som fører til den analoge multiplexer (analog Mux). Den bruges til at vælge hvilken af de analoge indgange, der skal forbindes til A/D-omsætteren. Som tidligere nævnt, skal det bemærkes, at A/D-converter kanalerne er begrænset til 4, da 2 af indgange benyttes til I2C-forbindelsen. Når det analoge signal skal konverteres, vælges der et reference-signal, dvs. en spænding, som definerer området for A/D-omsætteren. Dette signal kan enten vælges som den analoge spændingsforsyning (AVCC), en intern spændingsreference, som for ATmega8 er på 2.56V, eller en ekstern referencespænding på AREF – benet. I normal (single ended) mode er den anden reference for det analoge signal 0V (GND). Således giver en spænding på 0V på den valgte analoge indgang en værdi på 0 fra A/D-omsætteren, mens spændingen svarende til den analoge reference vil resultere i maksimalt udslag. For en 10 bit opløsning vil det være 1.023, og for en 8 bit opløsning vil det være 255. Som det tidligere blev nævnt, kan ATmega8 mikrocontrollerens 4 ud af 6 A/D - omsætter kanaler anvendes, nemlig pin ADC0 til ADC3, da ADC4 og ADC5 pindene anvendes til I2C-forbindelsen. Det skal bemærkes, at kanal ADC4 og ADC5 er begrænset til en 8 bit opløsning, hvorimod de øvrige kanaler har en opløsning på 10 bit. For at kunne anvende ATmega8’s A/D-omsætter, skal der tages stilling til hvilken referencespænding, der ønskes anvendt. Den interne reference spænding er egentlig fin


30

nok at anvende, men vi har valgt at benyttes os af spændingsforsyningen AVCC som referencespænding. Desuden er det vigtigt at formindske støjen på A/D-omsætter indgangene. For at formindske støjen og forbedre A/D konverteringen anbefales det i ATmega8 databladet, at AVCC pinen forbindes til VCC gennem en 10µH spole og en 100 nF kapacitor, som er et LC-filter (lavpas filter). AREF pinen skal tilsluttes gennem en kapacitor, som vælges til at være på 0,1uF. [P3]

31

6 DESIGN AF LINJESENSOR TIL NXT’EN

Detektering af en linje er en vigtig egenskab i robottens verden. Det giver robotten en præcis og fejlfri navigation. Desuden er det vigtig for robotter, som deltager i diverse robotkonkurrencer, at kunne detektere en linje, siden der tit bliver anvendt en linje, som robotten skal følge. Det er også tilfældet ved RoboCup. Det centrale i RoboCup-banen består i, at robotten kan følge en sort tape-linje på gulvet. Ved køb af Lego Mindstorms NXT, følger der kun en lyssensor med, som kan avendes til at detekter en linje. At der kun er en lyssensor til at detektere en linje giver nogle væsentlige ulemper, som vi kommer ind på senere i kapitlet. Vi har derfor besluttet os for at konstruere en linjesensor, som kan kobles til vores I2C-bus interface og derved kommunikere med NXT’en. I dette kapitel vil der være en beskrivelse af, hvordan en linjesensor virker og kon-strueres.

6.1 Lyssensorer En linjesensor er en sensor, som samler informationer fra en linje, der er placeret på jorden under robotten med det formål at hjælpe robotten med at navigere. For at robotten kan følge linjen, er det vigtigt, at robotten får så mange oplysninger som muligt om linjen fra linjesensoren. En linjesensor består af et eller flere par af sender(e) og modtager(e). Senderen sender lys, som skal blive reflekteret af linjen for at blive detekteret. Alle de sender/modtagere par, som er i stand til at differentiere mellem en linje og resten af jorden eller en anden farve end linjen, kan anvendes til en linjesensor.

Design a

Figu

Når en llinjen ogmetode tsiger nemlyset meen linjesunder batapelinjedioder so Uover koaspekt fofølger dpakken. informatlyssensoog 5 lyse

6.1.1 EDet mindlyssensomåle ovevil den e

af linjesensor

ur 6-1: Linje

linjesensor sg jorden. Mtil at bygge emlig, at en fad den sammsensor, som anen er lysege og reflekterom sendere.

ontrast mellefor kvalitetenen kun en Én lyssenso

tionskilde tilrers betydniensorer. [H4

n lyssensdste antal lyr, er man kuergangen fraene motor b

r til NXT’en

esensor konf

skal designeen i de tilfæen linjesensoarvet overfla

me farve somkan detekte

gråt, ved at ret af den lys

em linjen ogn og præcislyssensor (e

or er dog ogsl at kunne ing, beskrive]

sor (The Eysensorer forun i stand tila linje og ikkblive aktiver

n

figuration, so

s, er det altiælde, hvor dor, der kan hade vil absor

m overfalden.ere en sort udsende rødsegrå gulvfa

g overfaldensionen af linet par sendeså nok til at detektere lines mulighed

Edge Finder at kunne dl at følge kanke linje. Hviet når linjen

om består af

id lettest, atder ikke er håndtere lavrbere lys med. Eksempelvtape-linje p

dt lys, vil lysarve. Derfor

n af gulvet, enjesensoren. er/modtagerkunne følge

njen. For kderne ved an

er): detektere en nten af linjeis man benyn bliver dete

f sendere og m

t der er en sstor en kont

v kontrast. End forskellige

vis kunne opgpå RoboCupset blive abshar vi valgt

er antallet afSom det ti

r) med Legoe en linje, mort at anskunvendelsen a

linje er 1. Ben. Linjen føytter sig af 2ekteret, og d

modtagere.

stor kontrasttrast, er der n gammel fye farver og rgaven være

p-banen, hvosorberet af dat benytte o

f sensorpar eidligere blevo Mindstorm

men det er enueliggøre anaf henholdsv

Benytter manølges ved ko motors kør

den anden n

[H4]

t mellem en nem

ysisk lov eflektere at bygge

or gulvet den sorte s af røde

et vigtigt v nævnt, ms NXT n dårlige ntallet af vis 1,2,3

n blot én nstant at esystem,

når linjen

Design af linjesensor til NXT’en

33

ikke ses. Ved at benytte sig af en enkelt lyssensor, kan man få en robot til at følge en linje, men kun ved lave hastigheder. Detektoren vil derfor være ubrugelig ved høje hastigheder Hvis lyssensoren krydser den anden side af linjen, vil robotten kører i den modsatte retning, og hvis lyssensoren ikke kan se linjen, vil den begynde at snurrer i en cirkel. Det er derfor sjældent, at man benytter sig af en enkelt linjesensor. Hvis man ser det rent binært, vil der kun være 2 informationsmuligheder, nemlig 1 eller 0 (linje eller ingen linje), som sensoren kan detektere og sende videre til robotten, i vores tilfælde NXT’en. Dermed er udfaldsrummet begrænset til: [H3]

Tabel 6-1: Udfaldsrummet ved benyttelse af en sensor. [H3]

Figur 6-2: Benyttelse af en sensor til at følge kanten af en linje. [H3]

6.1.2 To lyssensorer (The Line Avoider): Anvendelsen af 2 lyssensorer svarer i praksis næsten til kun at benytte en enkelt sensor, dog med den forskel, at hver sensor kontrollerer sin egen motor (ved benyttelsen af et 2 motor køresystem). Sensorerne stækker sig over linjen, og prøver hovedsagligt at undvige linjen. 2 sensorer er derfor bedre end en, men robotten vil stadig tage sig en slentretur, hvis linjesensoren mister linjen. Det skyldes, at robotten ikke kan skelne mellem at være over linjen og miste linjen. [H3]

Figur 6-2: Benyttelse af 2 sensorer til at følge kanterne

1 sensor

Væk fra linjen

0

Over linjen 1


34

Tabel 6-1: Udfaldsrummet ved benyttelse af 2 sensorer. [H3]

6.1.3 Tre lyssensorer (The Line Seer): Ved at tilføje en ekstra sensorer til det forrige design med 2 sensorer, vil robotten kunne se linjen og kanterne. Robotten har nu den fordel, at den kan se, om den har mistet linjen. Desuden kan robotten lettere håndtere, hvis linjen ændrer form, såsom en kurve. Ydermere kan Robotten øge hastigheden på lige strækninger og ændre styringen mere subtilt. Det er således også dette design, som ofte er anvendt. Følgende muligheder eksisterer for detektering af linjen: [H3]


1 sensor 2 sensor 3 sensor

Bevæger sig væk fra linjen mod venstre

0 0 1

Centret over linjen 0 1 0 En smule væk fra linjen mod venstre

0 1 1

Bevæger sig væk fra linjen mod højre

1 0 0

Benyttes ikke 1 0 1 En smule væk fra linjen mod højre

1 1 0

Benyttes ikke 1 1 1

Figur 6-3: Benyttelse af 3 sensorer til at følge en linje. [H3]

1 sensor 2 sensor

Over eller mistet linjen 0 0

Fundet højre side af linjen

0 1

Fundet venstre side af linjen

1 0

Benyttes ikke, med mindre sensorerne er placeret fra hinanden med en afstand som er mindre end linjens bredde.

1

1


35

6.1.4 Fem lyssensorer (The Line Danser): Hvis 3 sensorer er effektive nok til at følge en linje, hvorfor så benyttes 2 ekstra sensorer? Svaret er hastighed. Ved yderligere at tilføre 2 sensorer, forøges linjesensorens sensitivitet med hensyn til at detektere linjens placering. Når robotten ikke bevæger sig med en stor hastighed, er der masser af tid til at justere retningen til at følge linjen. Men hvad sker der, når hastigheden forøges? I stedet for at følge linjen graciøst, vil robotten begynde at overstyrer og overskride en linjekurve.

Figur 6-4: Overstyring ved at køre gennem et sving. [H3]

Der er to måder at løse overstyring og overskridelse af linjen på:

1. Reducering af hastigheden, indtil at robotten bevæger sig graciøst 2. Kompenserer for overstyring og overskridelse af linjen

I nogle situationer vil robottens hastighed overskride dens evne til at kontrollere sig selv. Når man ved, det vil ske, kan man programmere robotten til rette sig op ved overstyring, så den kan finde linjen igen.


36

Figur 6-5: Eksempel på, at robotten har mistet linjen når den kører i svinget. [H3]

På Figur 6-5, er der givet et eksempel på, at robotten har mistet linjen, når den kører gennem et sving. Når robotten begynder at dreje til venstre i begyndelsen af svinget, ved robotten, at den skal blive ved med at dreje til venstre, indtil den finder linjen. Den yderste sensor til venstre vil først finde linjen før de øvrige sensorer. Normalt vil sensoren til venstre, som kan se linjen prøve at rette kraftigt op mod venstre. Men i dette tilfælde vil det medføre, at robotten krydser linjen, og ikke retter sig ind i svinget. Når man kender til denne overstyring, kan man ændre sensoren til venstre til at dreje kraftigt til højre i stedet for venstre. Derved vil robotten rette sig tilbage til linjen i stedet for at krydse den. Det er derfor en fordel at benytte sig af 2 sensorer ydereligere. Disse 2 sensorer bidrager med en finere kontrol og hurtigere respons ved overstyring og overskridelse af linjen. Ved anvendelse af 5 sensorer er de logiske muligheder for at detektere en linje følgende:


37


Figur 6-6: Benyttelse af 5 sensorer til at følge en linje. [H3]

Hvilket design er så det optimale og mulige for vores Lego NXT med henblik på deltagelsen i RoboCup? Det afhænger først og fremmest af antallet af A/D-omsætter kanaler, der er til rådighed på vores I2C interface, som skal konvertere de analoge signaler fra sensorerne til digitale og sende dem videre over I2C-bussen til NXT’en. Til

1 sensor 2 sensor 3 sensor 4 sensor 5 sensor

Linjen er mistet, ved overskridelse af linjen ellers er der ingen linje

0 0 0 0 0

Næsten væk fra linjen, rette sig kraftigt mod højre og reducere hastigheden

0 0 0 0 1

Tæt på højre kant af linjen, ret op mod højre

0 0 0 1 1

Højre for centrum af linjen, ret op mod højre

0 0 0 1 0

Lidt til højre for centrum af linjen, ret lidt op mod højre

0 0 1 1 0

Centrum af linjen, forøge hastigheden ved lige strækning

0 0 1 0 0

Lidt til venstre for centrum af linjen, ret lidt op mod venstre

0 1 1 0 0

Venstre for centrum af linjen, ret op mod venstre

0 1 0 0 0

Tæt på venstre kant af linjen, ret op mod venstre

1 1 0 0 0

Næsten væk fra linjen, rette sig kraftigt mod venstre og reducere hastigheden

1 0 0 0 0

Krydsning af flere linjer eller evt. en cirkel

1 1 1 1 1

Design a

det digitbesluttet hvilket p4 sensoren linje, grunden udelukkeman har laves, vproduktifordel i a Anvendegraciøst Det er dsom linjesensorer

6.2 AfsDet andemellem følge en

Figur 6-hvor senyderst tisensoren

af linjesensor

tale interfaceos for at b

på mange måer indtræffer og desudentil, at vi h

ende, at jo fen velfungeil vi kun bonen af linjat benytte 4 s

es få lyssensgennem linjerfor næstenesensor til R. [H3]

stand meet, man skallyssensorernlinje, er nem

-7: Figuren tnsorerne er pl højre. Den

n har den sam

r til NXT’en

e, vi har konbenytte 4 senåder næsten r i de situatin kan man har valgt at flere sensoreerende linjesbenyttes os esensoren. Usensorer i ste

sorer, er regujen. Flere sen umuligt at

RoboCup. På

ellem senl tage hensynne. Hvilken mmest at fork

til yderst til placeret medn midterste fmme afstand

n

nstrueret, er nsorer. Vi kgiver sammeioner, hvor dfølge linjenbenytte os

er jo bedre. Densor. Men n

af 3 sensoUd fra en økedet for 3,

ulatoren ikkeensorer giver

benyttes sigå den baggru

nsorerne n til, ved koindflydelse

klare ved et

venstre vise

d en længerfigur illustre

d mellem hin

der 4 A/D-kunne også e resultat somder er tale om

n lidt hurtigeaf 4 senso

Desuden påknår det endeorer, da vi konomisk be

e er i stand tir bedre styrig af den lyssund, har vi va

onstruktionene afstanden eksempel.

er, hvor robore afstand mer en drejnin

nanden som f

omsætter kahave benyttm 4. Fordelem oversvingere. Det skaorer i prototkræver deltaelige design

har lagt vetragtning e

il at få roboting af robottsensor, der falgt at lave e

n af en linjemellem lyss

otten er cent

mellem hinanng på 10 grfiguren yder

analer. Vi hatet os af 3 sen ved anveng og overskral dog bemætypen og ikagelse i Robaf linjesenso

vægt på prier der ikke d

tten til at bevten gennem følger med Nen linjesenso

esensor, er asensorene h

tret med to snden end påad af robottst til venstre

ar derfor sensorer, ndelse af ridelse af ærkes, at kke 3, er oCup, at oren skal isen ved den store

væge sig en linje.

NXT’en, or med 4

afstanden har på at

sensorer, å figuren ten, hvor e.


39

Figur 6-7 viser en differentielt drevet robot, hvilket er en 2 hjuls drevet robot med hver sin styremotor. Robotten har en linjesensor med, bestående af 4 sensorer, som er nummeret fra 1 til 4 fra venstre mod højre. Figuren illustrerer 3 forskellige situationer. Første illustration viser, at sensor 2 og 3 detekterer linjen, hvilket indikerer, at robotten er i centrum af linjen. I første tilfælde er afstanden mellem sensorerne ikke så kritisk, men hvis robotten foretager sig en drejning på 10 grader væk fra linjen, hvilket illustration 2 viser, så er det kun sensor 3, som detekterer linjen. I dette tilfælde, vil regulatoren kun få information fra sensor 3, når der er en afvigelse på 10 grader. Det betyder, at en fejl på under 10 grader ikke vil blive registreret. Derimod viser illustration 3 et samme tilfælde, men hvor sensorerne er placeret tæt på hinanden. Når robotten i dette tilfælde afviger 10 grader fra linjen, vil sensor 3 og 4 detektere linjen. Derved vil regulatoren få information fra sensor 3 og 4 om, at robotten afviger 10 grader fra linjen. Jo tættere sensorerne er på hinanden, desto større vil opløsningen af sensorerne være. Udover afstanden mellem hver sensor, har placeringen af linjesensoren også indflydelse på regulering af robotten. Det er vigtigt at placere linjesensoren så langt fremme som muligt fra styringscentrummet, som ved en differentiel styring er placeret i bageste del af robotten. Grunden er, at regulatoren får en længere reaktionstid til at rette sig op på et evt. udsving fra robotten. [H4]

6.2.1 Placering af sensorerne Som tidligere nævnt, har vi valgt at benytte 5 Li13740 lysstærke røde diffuse dioder med en halvvinkel på ±38 grader og en lys intensitet på 16 mcd som sendere. Som modtagere har vi valgt at benytte 4 BPY 62 fototransistorer. En anden mulighed var at benytte CSC photoresitores, men på grund af deres lave reaktionshastighed, har vi valgt at benytte os af fototransistorer. Fototransistorer har en hurtigere reaktionstid og en opløsning, som er 100 til 700 gange større end photo resistor. BPY 62 fototransistoren kan ”se” lys mellem 420nm og 1.130nm og har en halvvinkel på ±8 grader.

Design a

Figur 6

Da vi ønafstand paf simpefor en af7mm fra

6.3 FraNår en lilyset frastrømmemuligt aproducer

af linjesensor

6-8: Illustrat

nsker, at de mpå 14mm frael trigonomefstand på 14

a fototransist

afiltreringinje skal detea dioderne ben bliver konat bestemmrer en optisk

r til NXT’en

tion af lysdio

midterste to a hinanden, etri bestemm4mm mellemtorerne. [H4]

g af omgiekteres og føbliver refleknverteret til

me tærskelvæk strøm, er til

n

odernes lys o

sensorer er da den sorte

mes afstandenm hver senso]

ivende lysølges, benyttkteret fra gspænding v

ærdien af slføjet til udg

område og f

i centrum afe tape-linje in mellem linor. Lysdiode

ys og hastes fototrans

gulvet og nåved hjælp afspændingen,gangsstrømm

fototransistor

f linjen, skali RoboCup enjesensoren erne placere

tighedsbistorer. Der år fototransf en seriemo, da det om

men.

rernes måleo

l de placereser 38mm. Vog jorden t

es med en af

egrænsngenereres st

sistorerne. Uodstand. Detmgivende l

område

s med en ed hjælp il 68mm fstand af

ning trøm, når Udgangs-t er ikke ys, som


41

Figur 6-9: Udgangsstrømmen med og uden påvirkning af det omgivende lys. Hvor illustrationen til venstre viser udgangsstrømmen af fototransistoren uden påvirkning af det omgivende lys. Illustrationen til højre viser påvirkningen af det omgivende lys på udgangsstrømmen af fototransistoren. [H13]

Ved konstruktionen af en linjesensor er det vigtigt at kunne frafiltrer det omgivende lys. Med det formål har vi valgt at benytte os af pulserende lys, dvs. at vi tænder og slukker for dioderne og sampler, når dioderne er tændt og slukket. Differencen mellem de to sample er den optiske strøm som produceres af dioderne, hvor den optiske strøm fra det omgivende lys er frafilteret. [P4]

6.3.1 Hastighedsbegrænsning Sample-frekvensen har en afgørende betydning for, hvor hurtigt robotten kan følge en linje. Vi ved, at rise/fall tiden for BPY-62 transistoren er på 7µs [P9]. Desuden ved vi, at A/D-omsætteren har en konverteringstid, som ligger mellem 65-260µs [P3]. I værste tilfælde vil sample-frekvensen for en sensor være på:

1267 3,8 (6.1)


42

Ved at sample alle 4 sensorer før og efter dioderne bliver slukket, sker der 8 konverteringer. Desuden bliver dioderne tændt og slukket med et interval på 2 gange 1000μs . Rent teoretisk er samplefrekvensen i værste tilfælde givet ved:

1

8 · 267 2 · 1000 241,78 ( 6.2)

Vores robot har en maksimal hastighed på 77cm/s. Med den givne hastighed foretages der rent teoretisk en måling hver 3,18 mm.

0,77241,78 3,18 ( 6.3)

Resultatet viser, at sample-frekvensen ikke begrænser den maksimale hastighed, Lego robotten kan køre med, da 3,18mm er et meget godt resultat for at følge en linje.

6.4 Kalibrering af linjesensoren Et andet vigtigt aspekt ved linjesensoren er at foretage en kalibrering. Kalibreringen af linjesensoren foretages ved at placere et hvidt papir og tage en måling og derefter et sort papir og tage en måling. Det er vigtigt at kalibrere linjesensoren til det aktuelle lysforhold, da det, som lyssensorerne “ser”, afhænger af mange faktorer, såsom farven på gulvet, hvor meget gulvet “skinner”, den eksakte højde, som linjesensoren er placeret fra gulvet og endelig mængden af det omgivne lys.


43

Figur 6-10: Graf af intensiteten af sensorerne før kalibrering

Det ses tydeligt, at der er en stor variation mellem de enkelte sensorers intensitet. Det er derfor vigtigt, at sensorerne bliver kalibreret. Figur 6-11 viser sensorernes intensitet efter kalibreringen, og at differencen mellem hvidt og sort er på ca. 150 bit.

‐50

0

50

100

150

200

250

300

0 50 100 150 200

Sensor iten

sitet /

bit

Målinger

Intensiteten af sensorerne før kalibrering

Sensor 1

Sensor 2

Sensor 3

Sensor 4


44

Figur 6-11: Graf af intensiteten af sensorerne efter kalibrering

6.5 Del konklusion Gennem en teoretisk forståelse af en linjesensor, er vi kommet frem til at:

1. Legos medfølgende ene lyssensor er ubrugelig til at følge en linje til RoboCup 2. Jo flere sensorer, jo bedre regulering af robotten til at, følge en linje. 3. Afstanden mellem hver sensor har indflydelse på, om robotten overstyrer eller

overskrider linjen. 4. Placeringen af linjesensoren skal helst være så langt fremme som fra

styringscentrummet, som ved en differentiel styring er i den bageste del af robotten.

5. Fra-filtrering af det omgivne lys er vigtigt for pålideligheden af de målte data fra sensorerne.

6. Sample-frekvensen af målingerne har betydning for den maksimale hastighed 7. Kalibrering af linjesensoren er vigtig, da det er vigtigt at sensorerne ”ser” det

samme.

Nu, hvor denne teoretiske baggrund for, hvordan en linjesensor bedst konstrueres, skal den hardwaremæssige del af konstruktionen finde sted.

‐20

0

20

40

60

80

100

120

140

160

180

0 50 100 150 200

Sensor iten

sitet /

bit

Målinger

Intensiteten af sensorerne efter kalibrering

Sensor 1

Sensor 2

Sensor 3

Sensor 4

45

7 HARDWAREDESIGN AF LINJESENSOR

7.1 Valg af komponenter Som der blev nævnt i kapitel 6, har vi valgt at benytte 5 Li13740 lysstærke røde diffuse dioder, som sendere, og 4 BPY 62 fototransistorer som modtagere til linjesensoren. Den hardwaremæssige konstruktion af linjesensoren er forholdsvis simpel og i følgende kapitel vil det blive beskrevet.

7.2 Fototransistorer og dioder Som navnet fototransistor antyder, er en fototransistor et lysfølsomt element. Når fototransistorerne bliver belyst af dioderne, bliver der genereret en strøm, der er afhængig af mængden af det reflekterede lys. Vi valgte at benytte BPY 62 NPN fototransistoren. Hovedårsagen til, at vi valgte netop BPY62, er, at transistoren bliver anbefalet på DTU’s junior RoboCup hjemmeside. [H11]

Figur 7-1: Sender/modtager kredsløb

Fototransistorer har næsten den same egenskab som en almindelig transistor, dog med den forskel, at basespændingen kommer fra det lys, som fototransistoren bliver belyst med. Fototransistoren virker dermed som en variable strømkilde. Jo større lys mængde, jo mere strøm bliver der produceret til at løbe gennem collector-emitter forbindelsen. Den variable strøm løber gennem seriemodstanden (R2), som udløser et spændingsfald i pull-up modstanden. Denne spænding bliver så målt som udgangen af enheden.

Hardwaredesign af linjesensor

46

Når størrelsen af pull-up modstanden (R2, Figur 2-1), som fototransistoren sidder i serie med, skal vælges, er der nogle forhold, der skal tages hensyn til. Det er således, at resistansen af fototransistoren falder, når den bliver belyst. En god fototransistor vil have en resistans på næsten 0Ω, når den bliver belyst, og en stor resistans, når den ikke bliver belyst. Vi har så benyttet den nævnte egenskab til at lave et spændings-delingskredsløb, som det ses på Figur 7-1. Udgangsspændingen vil således være givet ved:

( 7.4)

Det er vigtigt, at sensorkredsløbet giver en maksimal spændingsændring, når fototransistoren henholdsvis bliver belyst og ikke belyst. For at opnå en stor spændingsændring mellem lys og ikke lys, er det vigtigt, at modstanden (R2) vælges med omhu.

Tabel 7-1: Symbolliste til beregning af pull-up modstandsværdien

Modstandsværdien af R2 kan bestemmes, da vi ved, at der er tale op en spændingsdeling. Når fototransistoren er belyst, kan udgangsspændingen udtrykkes ved:

Symbol

Fototransistor belyst Light onR

Fototransistor ikke belyst

Light offR

Seriemodstanden 2R

Indgangsspændingen inV

Udgangsspændingen outV


47

(7.5)

Når fototransistoren ikke er belyst, kan udgangsspændingen udtrykkes ved:

(7.6)

Da vi ønsker at beregne spændingsændringen, anvendes følgende:

∆

(7.7)

Den relative spændingsændring er lig med den aktuelles spændingsændring divideret med indgangsspændingen:

æ ææ æ

(7.8)

Derved fremkommer:

æ æ (7.9)

Udtryk (7.9) viser, at fototransistorernes sensitivitet er bestemt af kredsløbsimpedansen (i dette tilfælde kredsløbsresistansen, da impedansen er ren resistiv), hvor foto-transistorerne er koblet til. Ved hjælp af udtrykket, kan en teoretisk værdi af pull-up modstanden (R2) bestemmes for den størst mulige spændingsændring.


48

Figur 7-2: Grafen illustrer den relative spændingsændring, som afhænger af pull-up modstandsværdien

For de sensorer, vi benyttede, blev følgende målt: Resistansen af fototransistoren når den ikke blev belyst var på 4,2 MΩ og når den blev belyst på 193 KΩ.

Med de angivne værdier opnås en maksimal spændingsændring ved at benytte en pull-

up modstand på 899KΩ. På Figur 7-2 ses, hvordan den relative spændingsændring varieres af pull-up mod-standen. Det skal bemærkes, at der med så stor en modstandsværdi er strømmen meget lav, hvilket bevirker, at støjen på udgangssignalet bliver påvirket. Derfor har vi valgt at benytte os af en pull-up modstand på 600 KΩ, da spændingsændringen er næsten uændret. Ved at anvende en 600 KΩ pull-up modstand med en 10 bit opløsning, opnåede vi en difference på ca. 150 bit mellem hvidt og sort, hvilket er acceptabelt. Som tidligere nævnt har vi valgt at benytte 5 Li13740 lysestærke røde diffuse dioder som sendere. En 39 Ω modstand benyttes i serie med dioderne, og derudover har vi valgt et trimmepotentiometer på 100 KΩ, så det er muligt at regulere diodernes lys intensitet. [H11] og [P4]

00.10.20.30.40.50.60.70.80.9

0 1 2 3 4 5Relativspæ

nidn

gsænd

ring

/ Volt

Pull‐up modstand /MOhm

Relativ spændingsænding

Har

7.2For modlinjeVi hDer

7.3Det 7-3 skem

rdwaredesign

.1 Yderligat forbinde

dul, så det esensoren mhar valgt at

rfor finder vi

3 Prototypendelige deses proto-t

matisk overs

n af linjesens

ge kompone NXT’en m

er muligt med NXT’en.t benytte deni det unødven

pe af linjeesign prototytypen af linsigt af design

F

sor

nenter med ATmega

at anvende n interne klndigt at anve

esensorypen af linjenjesensoren net, som er l

Figur 7-3: P

a8 mikroconNXT’ens m

lok på 1MHende en ekst

sensoren sesloddet på eavet i Eagle

rototype af l

ntrolleren, hmedfølgend

Hz, som er ftern klok.

s på Figur 7-et veroboar.

linjesensor

har vi købt e kabler til

fin nok til l

-3 og Figur rd. På Figur

et NXT R1l at forbind

linjesensoren

7-4. På Figur 7-4 ses e

2 de

n.

ur en

Hardwar

redesign af li

Figur 7

injesensor

-4: Skematissk oversigt oover prototyppen af linjessensoren

51

8 PROGRAMMERING AF ATMEGA8 OG NXT

I dette kapitel vil der være en kort beskrivelse af hvordan ATmega8 og NXT’en er programmeret. Fra at kunne måle intensiteten fra fototransistorerne og transmittere den målte data via en I2C-bus, fra ATmega8 mikrocontrolleren til NXT’en vil blive beskrevet. Kildekoden til ATmega8 og NXT’en er vedlagt på den medfølgende cd. For mere dybdegående beskrivelse af programmeringen, henvises der til Atmel’s ATmega8 datablad samt NXC’s tutorial, som også findes på cd’en. Det skal bemærkes koden til I2C opsætningen på Atmel ATmega8 mikrocontrolleren er en GPL driver, som vi har redigeret for at kunne anvende den med vores ATmega8 mikrocontroller.

8.1 Programmering af ATmega8 Atmel’s ATmega8 mikrocontroller programmeres til at konvertere det analog signal fra fototransistorerne til en digitalværdi mellem 0-1023, da vi har valgt at benyttes os af en konvertering med en 10 bit opløsning. De målte data bliver herefter transmitteret via en I2C-bus til NXT’en. Dvs. at ATmega8ens A/D-omsætter og I2C-protokollen (også kaldt TWI) skal sættes op.

8.1.1 ATmega8 slave I2C kommunikation ATmega8 mikrocontrolleren er sat op til at fungere som slave på I2C-bussen, da NXT’en skal være master. ATmega8 har en hardwaremæssig opsætning af I2C kommunikationen. Dvs. at man ikke behøver implementere I2C protokollen. I stedet skal man implementere en tilstandsmaskine, som fortæller hvad den skal foretage. For at demonstreres dette gives forneden et eksempel. Når ATmega8 mikrocontrolleren har modtaget en bit med sin egen slave adresse (som vi har valgt til at være 0x10) over I2C-bussen, vil ATmega8en kalde funktionen SIGNAL(SIG_2WIRE_SERIAL), med statuskoden 0x60, det skal bemærkes for andre events vil det være en anden statuskode. Herefter opsættes en række registre for at fortælle ATmega8 mikrocontrolleren hvad den skal foretage sig. I dette tilfælde fortæller vi, at den skal modtage det pågældende data, som sendes over I2C-bussen til ATmega8 mikrocontrolleren, og derefter sende en acknowledge bit tilbage til masteren (NXT’en).

Programmering af ATmega8 og NXT

52

Når den aktuelle data er modtaget, fås et kald med statuskoden 0x80. Efter at modtaget status koden 0x80, fortæller vi ATmega8 mikrocontrolleren at den skal læse databyten og at den skal acknowledge den næste databyte hvis der sendes flere data fra masteren til ATmega8 mikrocontrolleren. Når kommunikationen er over modtages statuskoden 0xA0, som er en stop betingelse, og herefter vides at en meddelelse over I2C-linjen er modtaget. Hele tilstandsmaskinen for I2C-slave mode og de forskellige tilstande er vel beskrevet i Atmel ATmega8 databladet på sidde 183. [P3] For at sende data foregår processen på tilsvarende måde. [P13]

8.1.2 A/D-omsætter Atmels ATmega8 mikrocontrollers analog til digital konvertering understøtter 2 forskellige metoder at konvertere signalet på. Den ene metode, som kaldes for ”free running mode”, er hvor det analoge signal bliver konstant målt, og hvor der sker et interrupt når konvertering er færdig. Ved benyttelsen af denne metode kan man benytte interruptet til hurtigt at kopiere resultatet fra to registrer til en variabel. Den anden metode, som også kaldes for ”single conversion mode”, bliver der kun foretaget en konvertering af gangen. Hvis der skiftes kanal mens der er en konvertering i gang afsluttes konverteringen før der sker et kanalskifte. En af forskellene mellem ”single conversion mode” og ”free running mode” er konverterings tiden. ”Free running mode” er hurtigere end ”single conversion mode”, men ”single conversion mode” er tilpas hurtig til at opfylde vores krav. Vi benytter os af 4 A/D-kanal, som skiftes i mellem hver konvertering. Det er derfor vigtigt at sikre os at alle konverteringer er færdige før de bliver transmitteret til NXT’en via I2C-bussen, det er derfor oplagt at anvende ”single conversion mode”. Desuden er det vigtigt at der ikke kommer et interrupt, mens der bliver sendt data over I2C linjen, hvilket kan opstå ved anvendelse af ”free running mode”. Vi har derfor valgt at benytte ”single conversion mode”. Når ATmega8 mikrocontrolleren er klar til at foretage en konvertering bliver funktionen SIGNAL(SIG_ADC) kaldt. I denne funktion bliver konverteringsresultatet gemt i en variabel. Der er en række bits som skal opsættes for at få A/D-omsætteren til at virke. En af disse bit et ADPS-biten, som er A/D-omsætterens klok pre-scaler bit. Denne bit skal opsættes således at klok frekvensen divideret med pre-scaler faktoren er mellem 50 og 200 KHz. Divisionsfaktoren er 2^ADPS. Da vi har valgt at benytte os af den interne klok på 1MHz, fås en divisionsfaktor på 16 passende. [P3]

Programmering af ATmega8 og NXT

53

8.2 Programmering af NXT’en For at foretage en transmission mellem ATmega8 mikrocontrolleren og NXT’en, skal I2C-bussen på NXT’en opsættes. Som der tidligere blev beskrevet i afsnit 4.1.1, foregår transmissionen mellem Atmega8 og NXT’en på følgende måde, hvor NXT fungerer som master:

1. Send en startsekvens 2. Send slaveenhedens I2C adresse med en lav R/W bit (lige adresse) 3. Send det interne register nummer, som masteren ønsker at skrive til 4. Send databyten 5. (eventuelt, send flere data bytes) 6. Send stopsekvensen

Når NXT’en skal sende ATmega8’s mikrocontrollerens slave adresse, som i dette tilfælde er 0x10, skal det bemærkes at adressen shiftes en gang til venstre, dvs. der bliver ikke sendt 0x10, men derimod 0x20.

55

9 ROBOCUP

Da projektet desuden omhandler en reguleringsteknisk undersøgelse af NXT’en, har vi valgt at deltage i DTU RoboCup. RoboCup har en række forskellige udfordringer, som giver gode muligheder for at teste NXT’ens reguleringsegenskaber. I dette kapitel vil der blive redegjort for strategier og løsninger til RoboCup-banen. På baggrund af teorien vil der blive redegjort for udviklingen af en robot og et realtidsprogram, som er anvendelig til RoboCup-banen. Sidste del af afsnittet omhandler deltagelsen i RoboCup.

9.1 Banen RoboCups forhindringsbane 2008, som ses på Figur 9-1, er primært udformet således, at en robot skal kunne følge en sort tape-linje på gulvet, som fører hen mod banens øvrige forhindringer. Hver forhindring giver point. En typisk udfordring er at køre gennem en gul port, som er mere eller mindre fremkommelig, hvor der gives 1 point. Guillotinen (1) er den eneste obligatoriske forhindring. Det er den første port, og den lukker efter et fastlagt tidspunkt – en gennemsnitshastighed på 25 cm/s skulle være tilstrækkelig. Efter guillotinen er passeret, kan banen gennemførers i vilkårlig rækkefølge. De øvrige forhindringer på banen er som følger:

• En rampe (2), der leder op til et plateau. På rampen er placeret en gul port. På øverste del af rampen er der på venstre side monteret en vippe (3). Der er placeret en gul port og en golfkugle (4) på vippen. Nedkørselen fra plateauet kan foregå på to måder, enten ved at køre ned af en rampe, eller ved køre ned af nogle trapper.

• (3) signal-røde golfkugler, hvor af 2 af golfkuglernes position (4)(5) kendes på forhånd. Den sidst golfkugles position (7) kan være på en af seks placeringer. To af golfkuglerne skal puttes i et hul (6), som giver et point for hver golfkugle, mens den sidste skal tages med i mål for at få et point yderligere.

RoboCup

56

• To gule porte (8), der er påmonteret røde blinkende stoplys. Til enhver tid er det kun et af lysene, der blinker, idet det lige såvel kan være den ene port som den anden. Porten der blinker, giver minuspoints, og den anden giver et point.

• En racerbane (9) der starter og slutter med en elektronisk port. Der kan opnås

mellem 0-3 point afhængig af gennemsnitshastigheden. For at få maksimum point kræves en gennemsnitshastighed på over 1 m/s. På racebanen er der endvidere end gul port (10) der skal passeres.

• En tunnel (11), som er placeret væk fra den sorte linje, der er monteret med en udadgående dør i hver ende. Døren skal skubbes op og køres igennem. Der gives 1 point for passage af hver dør.

• En rød minusport, som kun kan undgås ved at køre igennem en keglebane (12), hvor der er 2 gule porte. Det grå område (13) giver et -1 point hvis robotten bare har et hjul indenfor området.

• Målet (14) giver 2 point for at komme i mål fra forsiden og aktivere målets sirene.

RoboCup

57

Figur 9-1: DTU RoboCup 2008 forhindringsbane. [H9]

9.2 Strategier og Løsninger

9.2.1 Følge linje Det centrale i RoboCup-banen består i, at robotten kan følge en sort tape-linje på gulvet. Som beskrevet i kapitel 6 havde vi til dette formål valgt at lave en flere kanals linjesensor med 4 lyssensorer. Lyssensorne sidder i en afstand, der er tilpasset

RoboCup

58

RoboCup-banens sorte tape-linje, således at de 2 midterste lyssensorer vil være indenfor tape-linje, mens de 2 yderste vil være udenfor. For at følge en linje kræves en algoritme, der kan detektere positionen af robotten, og en regulator til at holde robotten på linjen. I regulatoren vælges en position som reference. I RoboCup er det vigtigt, at robotten kan følge linjen lidt til højre eller venstre, således at det er muligt at vælge vej i forgreninger. I programmet laves 3 referencer: Den midterste position og en position til henholdsvis højre og venstre for midten. Fejlen i forhold til den bestemte position og reference anvendes til at regulere robotten. Der er flere forskellige algoritmer til at detektere positionen på en linje ved brug af en linjesensor, men ikke alle er lige gode. Nogle forvirres af forgreninger og krydsende linjer. De mest kendte algoritmer er:

• Lavest intensitet • Massemidtpunkt • Massemidtpunkt af lavest intensitet og naboer

Som navnet antyder, undersøges der med lavest intensitet algoritmen for, hvilken sensor der har lavest intensitet. På den måde bestemmes positionen på linjen. Vores hardware er konstrueret således, at lyssensorerne viser lav intensitet ved sort og højt ved hvid. Problemet med denne algoritme er, at positionsmulighederne er begrænset til det antal sensorer, der er til rådighed. Hvis der eksempelvis er 4 sensorer til rådighed, kan kun 4 forskellige positioner på en linje bestemmes. I de tilfælde, hvor der et lige antal sensorer, kan man umiddelbart ikke få robotten til at være midt på linjen. Eksempelvis har vores linjesensor 4 lyssensorer, og for at få robotten til at forblive i midten med lavest intensitet algoritmen, kræves at reference skiftes mellem sensor 2 og 3. Det er derfor ikke hensigtsmæssigt i vores tilfælde at anvende lavest intensitet algoritmen. Massemidtpunktsalgoritmen ser således ud:

∑∑ ( 9.1)

I er intensiteten, x positionen og i er sensornummeret. I massemidtpunktsalgoritmen vægtes sensorernes værdi afhængig af deres position. Ud fra dette er det muligt at bestemme robottens position.

RoboCup

59

I vores hardware forholder det sig således, at lyssensorerne viser højt ved hvid og lavt ved sort. Værdien af sort og hvid er afhæng af lysforholdet. En typisk værdi af sort med vores sensorer ligger på 0-5 og for hvid ligger værdien på omkring 150. På Tabel 9-1 ses sandhedstabellen for massemidtpunktsalgoritmen for 4 sensorer, hvor 0 repræsenterer sort og 1 hvid. Kun de logiske kombinationer er opført. De 5 første kombinationer viser 5 forskellige positionsmuligheder for robotten på en linje. Tabel 9-1: Sandhedstabel for massemidtpunktsalgoritmen for 4 sensorer, hvor 0 repræsenterer sort og 1 repræsenterer hvid.

Sensor 1 Sensor 2 Sensor 3 Sensor 4 Massemidtpunkt

0 1 1 1 3 0 0 1 1 3,5 1 0 0 1 2,5 1 1 0 0 1,5 1 1 1 0 2

Ude fra sandhedstabellen ses, at massemidtpunktet ikke forholder sig lineært. Når de to yderste sensorer er på linjen, er massemidtpunktet og fejlen større, end når kun en sensor er på linjen. Dette medfører, at regulatoren vil regulere kraftigere, når de to yderste sensorer er på linjen, end når kun en sensor er på linjen, hvilket ikke giver mening. For når kun en af de yderste sensorer er på linjen, vil robotten være længere væk fra linjen, end når de to yderste sensorer er på linjen, og dermed skal regulatoren regulere kraftigere, for at få robotten tilbage til midten af linjen. I massemidtpunktsalgoritmen er det nemlig påkrævet, at lyssensorerne viser højt ved sort og lavt ved hvid. Men da det forholder sig omvendt i vores hardware, skal der i programmet anvendes den reciprokke værdi af lyssensorerne. På den måde fås en høj værdi ved sort og lav værdi ved hvid. I programmet skal der tages hensyn til, at sensorerne ved sort kan vise 0. I dette tilfælde skal sensorværdien sættes høj. Der skal desuden i programmet tages hensyn til, at NXC ikke kan regne med floating points og ikke umiddelbart kan beregne den reciprokke værdi. En løsning til problemet kan være, at dividere sensorværdierne op i 1000, og i de tilfælde, sensorværdierne er 0, sættes disse til 1000. Da lyssensorerne er tilpasset således, at der vises lavt ved hvid og højt ved sort, laves der en sandhedstabel, hvor 1 repræsenterer sort og 0 repræsenterer hvid. På Tabel 9-2 ses sandhedstabellen for massemidtpunktsalgoritmen for 4 sensorer. Ligesom den forrige tabel, er kun de logiske kombinationer anført. De 5 første kombinationer viser 5 forskellige positionsmuligheder for robotten på en linje. Det fremgår tydeligt af tabellen, at massemidtpunkt forholder sig lineært i forhold til positionen. Når en

RoboCup

60

lyssensor kun delvist er på en linje, vil dette også blive registeret. Der vil derfor også være positioner, som ligger imellem de 5 nævnt kombinationer, og dette vil så give et utal af positionsmuligheder med massemidtpunkts-algoritmen. De sidste 3 kombinationer viser nogle særtilfælde, der kan opstå på banen ved at følge en linje. Den første og sidste af disse kombinationer viser henholdsvis, hvad massemidtspunktet vil være, når der er en sort tape linje til venstre og en til højre. Det ses, at robotten kan blive forvirret af dette. Det er derfor nødvendigt, at programmet sikrer, at tilfælde som disse ignoreres. Ved krydsende linjer vil robotten ikke blive påvirket. Dette fremgår af den anden sidste kombination. Tabel 9-2: Sandhedstabel for massemidtpunktsalgoritmen for 4 sensorer, hvor 1 repræsenterer sort og 0 repræsenterer hvid.

Sensor 1 Sensor 2 Sensor 3 Sensor 4 Massemidtpunkt

1 0 0 0 1 1 1 0 0 1,5 0 1 1 0 2,5 0 0 1 1 3,5 0 0 0 1 4

1 1 1 0 2

1 1 1 1 2,5 0 1 1 1 3

Massemidtpunkt af lavest intensitet og naboer algoritmen er en kombination af massemidtpunkts- og lavest intensitets algoritmen. Til at starte med findes den lyssensor med laveste intensitet. Derefter anvendes massemidtpunktsalgoritmen på lyssensoren og dens 2 nærliggende sensorer. Således anvendes 3 sensorer til at beregne massemidtpunktet bortset fra de tilfælde, hvor kun af den ene af de yderste sensorer af på linjen, og der kun anvendes 2. Når vi kun har 4 sensorer, vil det være spild af regnekraft først at finde laveste intensitet inden beregning af massemidtpunktet. Massemidtpunkt af lavest intensitet og naboer algoritmen er derfor ikke velegnet. Vi endte med at vælge massemidtpunktsalgoritmen, da den med 4 sensorer kunne bestemme robottens position mest nøjagtigt.

9.2.2 Golfkugler Med henblik på at finde de røde golfkugler kræves det, at robotten har en komponent, der kan genkende den røde farve. Til dette formål har Lego et produkt ”NXT Color Sensor”, som kan skelne mellem forskellige farver. ”NXT Color Sensor” virker ved, at 3 forskellige farvede LED’er oplyser et område og måler den reflekterede intensitet af

Rob

hverer, aobjegolf Et Mini reaobjenedelinje Da progNXTDer Da Ntil ”NXTrødenembruget irdet p

Udotil aklo.

boCup

r farve. Derat den kun kektet, hvis ffkuglernes p

andet produndsensors. Naltid såledesekter. Når eterste højre kens forløb. K

NXTCam igram NXTCTCamView

r er 8 adresse

NXTCam, u”NXT ColoTCam. Da ve i billedern

mlig ikke et ige NXTCamr cut-filter. Vpåmonteret p

Fig

over at kunnat gribe golfk Kloen kan u

rved bestemkan se i en farve ønskeosition på R

ukt til NXTNXTCam er e

, at der kan t farvet objekoordinat seKommunikat

ikke sender CamView at

indkodes her til rådighe

udover at skeor Sensor” kvi afprøvedene skyldtes iir cut-filter t

m var at se enVed at skillepå NXTCam

gur 9-2: Med

ne se golfkugkuglerne. Tiludformes ho

mmes et områlille vinkel.s bestemt.

RoboCup ikk

T’en til at et visionssysdetekteres okt spores, er

endes til NXtionen melle

et billede t tilslutte N

hvilke farvered, hvilket m

elne farver, kan se i ene NXTCam, infrarød støjtil at bortfiltn rød golfkue et webcamm’en. Billede

d IR-CUT fi

glerne, skal l dette formåorisontalt som

ådes farve. P Det medførDet kan væe kendes præ

skelne farvstem med enog spores en r det som en

XT. Når en liem NXTCam

til NXT, eNXTCam til r, der ønske

muliggør, at d

også kan spon større vink

var billederj. Til vores trerer det infgle, vil dette

m ad lykkedee på NXTCa

ilter og uden

robotten ogsål kunne løsnm en skorpio

Problemet mrer, at senso

ære et problæcist.

ve er det un mikroprocelinje eller op

n kasse, hvorinje spores,

m og NXT’en

r det muligen PC og

es sporet i Nder kan gemm

orer objektekel og langrne meget røstore overr

frarøde lys. e være umulies det os at fam blev here

n IR-CUT fil

så have en fningen væreon klo, eller

med ”NXT Coren skal vælem, i og m

uofficielle Nessor, der bilp til 8 forsker den øverstsendes koor

n foregår ove

gt med det se billedet

NXTCam’enmes 8 forske

rs positionergt, valgte vøde. Det visraskelse havNår vores foigt, hvis ikkfinde et ir cu

efter meget ty

ter (til højre

form for gribe, at der lavevertikalt som

Color Sensorære rette momed at en a

NXTCam frlledbehandleellige farvedte venstre- ordinaterne foer I2C.

medfølgendt på Pc’en. ns mikrochipellige farver.

r og i forholi at anvendste sig, at de

vde NTXCamformål med ae vi fik fat put-filter og fydeligere.

)

bemekanismes en form fom en kran.

r” od af

ra er de og or

de I

p. .

ld de et m at på få

me or

RoboCup

62

9.2.3 Blinkende porte Den store udfordring med de blinkende porte er at kunne se, hvilken port der blinker. Til dette formål skal der enten anvendes en lyssensor, som kan måle lys intensiteter, eller noget, der kan skelne mellem en blinkende- og en ikke blikkende port. Hvis en port blinker, vil lys intensiteten skiftevis stige og falde, og med NXT’ens lyssensor vil dette kunne detekteres. Da lyssensoren skal måle intensiteten af det reflekterede lys, kræver det, at lyssensoren står lige overfor de blikkende lys. Hertil skal bruges en afstandssensor, som kan måle afstand mellem robotten og porten. Den anden løsningsmodel til at detekterer den blinkende port er at anvende NXTCam. I NXTCam kan farven, når den blinkende port lyser, gemmes i forvejen. Problemet med NXTcam er imidlertid, at det ikke har noget dybde syn, og da NXTCam kan se langt og i en stor vinkel, kan der opstå forvirring om, hvorvidt det er den første port eller den anden port, der blinker. Som nævnt tidligere ser NXTCam objekter som kasser, og jo tættere et objekt er, des større vil kassen være. Ved at se på størrelsen af disse ”kasser”, kan problemet måske løses.

9.2.4 Øvrige forhindringer For at få maksimum point for racerbanen, er en fart på over 1 m/s påkrævet. NXT motorens maksimale omdrejningshastighed er på 170 rpm, og med de hjul, der er til rådighed, kan en NXT robot uden gearing højst komme op på 77 m/s [A1]. Med gearing vil det således være muligt at opnå en hastighed på over 1 m/s, men da racerbanen drejer skarpt, kræver det også, at vores linjesensor skal kunne følge med. Med så store hastigheder vil det næppe være muligt at regulere robotten i tide med kun 4 sensorer, som vores linjesensor har. I kurset ”31385 Autonome robotsystemer” har vi tidligere prøvet tunnelforhindringen. Dengang brugte vi en SMR robot, som havde afstandssensorer både i front og på hver side. For at klare forhindring var det nødvendigt at bruge alle disse sensorer. Med NXT’en er der kun én afstandssensor til rådighed. Selvom der var flere til rådighed, ville det ikke være muligt at tilslutte NXT’en på grund af mangel på porte. Det vil derfor være umuligt at gennemfører denne forhindring med NXT’en kun ved brug af sensorer. I stedet skal forhindringen klares på basis af god odometri. En løsning på basis af odometri vil ikke være optimal, da små usikkerheder kan udarte sig til store usikkerheder. Hvis robotten gentagende gange drejer et par grader ved siden af det ønskede og kører lidt for langt eller for kort, kan robotten ende langt fra den planlagte rute. Anvendes en sensor, kan disse små usikkerheder rettes op, såfremt der er nogle faste holdepunkter. Ligesom ved tunnelforhindringen kræver keglebanen anvendelse af afstandssensorer både i front og på siden for at opnå en optimal løsning. Da koordinater for keglernes

RoboCup

63

placering er angivet, kan forhindringen også løses ved odometri. Men som tidligere nævnt vil dette ikke være optimalt.

9.3 Regulator For at holde en bestemt position på en linje, kræver det, at der implementeres en regulator. Da robotten skal kunne håndtere at følge en linje i høj fart, stiller det store krav til hastigheden af regulatoren. På grund af de høje hastighedskrav har vi valgt at anvende PD-regulator til linjesensoren i stedet for en PID. Grunden til at vi har udeladt integralleddet, selvom dette vil fjerne stationære fejl, er, at det ville forårsage, at regulatoren blev langsommere. Som reference til regulatoren anvendte vi værdierne ud fra sandhedstabellen for massemidtpunkt på Tabel 9-2. Hvis robotten skal følge midten af linjen, er referencen 2,5, og hvis robotten skal følge en linje til højre eller venstre, er reference henholdsvis 1,7 og 3,3. Programmet beregner hele tiden massemidtpunktet af sensorerne, og regulatoren sørger for, at massemidtpunktet bliver som referencen. Parametrene til PD-regulatoren blev forsøgt bestemt på basis af Ziegler-Nichols metode – en metode til dimensionering af regulatorer. Til at starte med sættes integral- og differentielleddet til 0. Forstærkningen forøges indtil systemet oscillerer og er marginalt stabilt. Den kritiske forstærkning samt svingningsperioden noteres. Ved at anvende disse værdier, bestemmes parametrene for regulatoren (se tabel 8-9).

Tabel 9-3: Regulatorparametre efter Ziegler-Nichols lukket-sløjferegler. [B2]

Kp τi τd

P‐reg 0,5 Kp,krit PI‐reg 0,45 Kp,krit 0,85 T0 PD‐reg 0,65 Kp,krit 0,08 T0 PID‐reg 0,6 Kp,krit 0,5 T0 0,13 T0

Vi lod robotten følge en sort linje og justerede proportionalleddet, indtil robotten begyndte at følge linjen oscillerende. Vi anvendte den kritiske forstærkning og svingningsperioden til at bestemme parametrene for PD-regulatoren. Det viste sig, at selvom Ziegler-Nichols metode blev anvendt, skulle der en del ”håndtuning” til, for at få regulatoren til virke helt optimalt. Da golfkuglerne ligger forholdsvis tæt på den sorte tape-linje, viste det sig, at en P-regulator var tilstrækkelig til at finde golfkuglerne. Da NXTCam sporer objekter som kasser, beregner programmet midtpunktet af objektet, og regulatoren sørger for, at objektets midtpunkt også svarer til midtpunktet af robotten. Når robotten nærmer sig

RoboCup

64

golfkuglerne, vil disse kasser blive større, og ved at stoppe robotten ved en bestemt kasse størrelse, er det muligt at stoppe lige foran golfkuglerne.

9.4 Robotdesign Som nævnt tidligere, har NXT’en et begrænset antal porte. Der er kun 3 motorporte og 4 sensorporte til rådighed. Der har derfor været nogle begrænsninger på robottens design. Efter nøje overvejelser kom vi frem til, at robotten som minimum havde brug for følgende komponenter til at kunne klare RoboCup-banen:

• 3 motorer • NXTCam • 1 linjesensor • 1 lyssensor • 1 afstandssensor

Eftersom den ene af de 3 motorer skal anvendes til en klo til at gribe golfkuglerne, er der 2 motorer til at styre robotten. Med 2 motorer er styringen af robotten begrænset til 2 løsningsmodeller: enten differentielstyring eller styrbart hjul. I differentielstyring er der enten 2 motorstyrede hjul med 1 eller 2 castor hjul eller 4 hjul, som parvis er motorstyret. Differentielstyring fungerer ved, at de 2 motoriserede hjul kan have forskellige hastigheder, og på den måde kan robotten drejer, køre lige ud og tilbage. Når hjulene har forskellige hastigheder, drejer robotten, og når hjulene har samme hastighed, kører robotten lige ud. Den anden form for styringsmulighed er med styrbart hjul, f.eks. Ackermann styring. Ackermann styring er det system, der bliver brugt i biler, hvor baghjulene af forbundet til en motor mens forhjulene er drejbare. Da en af RoboCup-banens forhindring er, at robotten skal køre ned af nogle trapper, ville dette bedst kunne lade sig gøre med 4 hjul. Da er der et begrænset antal komponenter til rådighed til at bygge Lego robotten, valgte vi at lave en differentielstyret robot med 2 motorstyrede hjul og 2 castor hjul. For bedst at kunne følge en linje, skal linjesensoren placeres så langt fremme som muligt. Linjesensoren blev placeret lige foran forhjulene. NTXCam’en placerede vi mellem forhjulene, således at kameraet ville være i øjenhøjde med golfkuglerne. Dermed opnås det bedste udsyn for kameraet. Som nævnt tidligere, kan kloen til at gribe golfkuglerne laves horisontalt eller vertikalt. På grund af NXTCam’ens placering valgte vi at lave kloen vertikalt. Lyssensoren og afstandssensoren blev placeret over kloen i en højde på lidt over 20 cm.

RoboCup

65

9.5 Odometri Da vi har valgt at lave en differentielstyret robot, vil der i dette afsnit kun gennemgås odometrien for en differentielstyret robot. Til at bestemme Lego robottens position anvendes odemetri. Lego motorerne har en enkoder, som måler rotationen af motoren med en opløsning på 1 grad. Som nævnt tidligere, anvendes to motoriseret hjul. Afstanden, som hjulene har bevæget sig, kan beregnes ud fra rotationen og hjulenes diameter. cm er omregningsfaktoren, som omregner rotation målt med enkoderne til, hvor meget hjulene har bevæget sig. Omregningsfaktoren er givet ved:

( 9.2)

Dn er hjuldiameteren, n er gearing og Ce er enkoderens opløsning i grader. Da Lego motorerne har en opløsning på 1 grad, er Ce 360. NL og NR er rotationen af hjulene for henholdsvis venstre og højre hjul. Når odometri benyttes, beregnes den nuværende position hele tiden relativt til en tidligere målt position. Ved at multiplicere omregningsfaktoren med rotation NL eller NR fås afstanden, som hjulene har bevæget sig siden sidste måling:

∆ / , / ,

( 9.3)

Afstanden, som robotten har bevæget sig siden sidste måling fra dens midtpunkt, er givet ved:

∆∆ ∆

2 ( 9.4)

Vinkelændringen af robotten siden sidste måling er givet:

∆∆ ∆

( 9.5)

b er akselafstanden. Den relative vinkel og position for robotten bliver således:

∆

( 9.6)

∆ cos ( 9.7)

RoboCup

66

∆ sin ( 9.8)

Da programmeringssproget NXC, som vi anvender, ikke kan regne med floating points, kan vinkelændringer på under 1 grad ikke registreres. Det er derfor vigtigt, at der ikke samples for hurtigt, for at kunne registrere vinkelændringer. I vores program tages der derfor højde for, at sampletiden ikke er for høj. For at mindske fejlen ved odemetri, benyttes nogle landmærker. På RoboCup-banen er der f. eks krydsende linjer, som kan anvendes som landmærker. [P2]

9.6 RoboCup deltagelse RoboCup-banens lysforhold viste sig at være anderledes end de lysforhold, hvorunder vi havde testet robotten. Det var derfor forventet, at linjesensoren ville blive påvirket af det. Under testkørsel på RoboCup-banen kunne vi også konstatere, at linjesensoren til en vis grad blev påvirket af det mere kraftige lys. Men da vores linjesenor var konstrueret til at frafiltrer dagslys, var påvirkning af det kraftige lys ubetydeligt. Til vores store skuffelse blev robottens linjesensor beskadiget under testkørsel, så det ikke var muligt at stille op til kvalifikationsrunden til RoboCup. Under den sidste testkørsel havde robotten for meget fart på ned ad rampen.

67

10 KONKLUSION

10.1 Resultater Det er lykkedes at konstruere en linjesensor til NXT’en, som kunne følge en sort tape-linje uden problemer. Legos Mindstorms NXT er blevet væsentligt forbedret i forhold til forgængeren RCX. Set fra et reguleringsmæssigt perspektiv ligger den store forbedring i motoren. I og med at NXT’en har fået en servomotor i erstatning for RCX’ens 9V gearet motor, er måling af rotationen blevet mere end 20 gange så nøjagtig. Fra at kunne have 16 målepunkter på en rotationsomgang, som RCX’en har, har NXT’en en rotations-nøjagtighed på 1 grad. Servomotoren har med dens indbygget enkoder også gjort det muligt for Lego at implementere en PID-regulator i firmwaren. Da NXT’en har fået større regnekraft, er det også muligt selv at implementerer bedre regulatorer. Konklusionen er derfor, at NXT har stærkt forbedrede reguleringsegen-skaber. Til at programmere NXT’en, blev NXC valgt. NXC er et C-lignende program, der kan anvendes som erstatning for det medfølgende software, NXT-G. Det viste sig, at NXT-G ikke var velegnet til større programmeringsopgaver, da programmerne hurtigt blev uoverskuelige, når de nåede en vis størrelse. Desuden fylder et program lavet i NXT-G mere end 10 gange så meget som et program lavet i NXC. Udover NXT-G blev det også overvejet at anvende ROBOTC som software, men da ROBOTC både er kommercielt og bruger anden firmware, faldt det endelige valg på NXC. For at skabe en forbindelse mellem NXT’en og eksterne sensorer, blev der valgt en I2C-bus til kommunikationen. Valget af et digitalt interface skyldes, at de digitale enheder har flere fordele sammenlignet med analoge enheder. Ved hjælp af et digitalt interface kan sensorerne, som skal kommunikere med NXT’en, individuelt udføre deres egen funktionalitet, og derefter kun sende data videre til NXT’en. I2C-bussen viste sig at være et effektivt element i NXT’ens sammensætning, der giver næsten ubegrænsede muligheder for at udvide indgangene samt udgangene på NXT’en.

Konklusion

68

Det skulle vise sig, at der er mange aspekter, som man skal tage hensyn til for at konstruere en linjesensor. Blandt andet spiller antallet af sensorer en afgørende rolle for detekteringen af en linje. Med blot en sensor, er robotten nødsaget til at følge kanten af linjen. Ved at følge kanten af en linje, er det vanskeligt at detektere forgreninger. Derfor er Legos medfølgende lysesensor ubrugelig til at følge en linje til RoboCup. Jo flere sensorer, der anvendes, des bedre bliver detekteringen af en linje. Vi besluttet derfor at konstruere en linjesensor med 4 sensorer. Linjesensoren kommunikerer med NXT’en gennem en I2C-bus. RoboCup-banens lysforhold var anderledes end det lys, hvorunder vi havde testet robotten. Det var derfor forventet, at linjesensoren vil blive påvirket af det. Under testkørsel på RoboCup-banen kunne vi også konstatere, at linjesensoren til en vis grad blev påvirket af det mere kraftige lys. Da vores linjessensor imidlertid var konstrueret til at frafiltrer det omgivende lys, var påvirkning fra det kraftige lys af mindre betydning. Til vores store skuffelse blev robottens linjesensor beskadiget under testkørselen, så det var ikke muligt at stille op til kvalifikationsrunden til RoboCup.

10.2 Perspektiver Et af formålene med konstruktionen af en linjesensor var at kunne deltage i DTU’s robot konkurrence RoboCup. Konstruktionen af linjesensoren til NXT’en gør det muligt for folk at deltage i RoboCup eller andre robotkonkurrencer, hvor man skal følge en linje. Desuden giver linjesensoren folk mulighed for at konstruere deres egne sensorer og skabe en forbindelse med NXT’en ved hjælp af det skabte I2C kommunikations-interface. Det skal dog nævnes, at hovedårsagen til det gik galt ved RoboCup var den tidsmæssige begrænsning, som gjorde, at vi indenfor 2 måneder skulle konstruere en linjesensor, skabe kommunikation mellem linjesensoren og NXT’en og lave en robot, som kunne deltage i RoboCup. Da vores opgave var at konstruere en linjesensor, som kunne kommunikere med NXT’en, blev hovedvægten derfor lagt på at lave en funktionel linjesensor, hvilket også lykkedes. Til dem, der har interesse for at deltage i RoboCup med Lego Mindstorms NXT, er det vor anbefaling at konstruere en linjesensor. Med en specialbygget linjesensor er det således lettere at følge en linje end det ville være, hvis Lego’s medfølgende sensor anvendes. Desuden kræver RoboCup mange forskellige opgaver som skal løses, hvilket kræver mange sensorer. Da antallet af indgange på Lego NXT’en er begrænset til kun 4 porte, giver det konstruerede I2C-bus interface mulighed for at koble næsten uendeligt mange sensorer til NXT’en.

Konklusion

69

Sammenfattet giver resultaterne fra dette projekt folk med interesse for deltagelse i RoboCup med Lego Mindstorms NXT en større chance for at vinde.

10.3 Videre arbejde Prototypen af linjesensoren er konstrueret således, at I2C-bus komunikationsinterfacet og selve linjesensoren er lavet som en samlet enhed. Dermed er det ikke muligt at koble eksterne sensorer til I2C-bus interface modulet. Det vil derfor være oplagt at skille I2C-interfacet og linjesensoren ad i to enheder, således at linjesensoren forbindes med et NXT RJ12 kabel til I2C-bus interfacet, hvor I2C-bus kommunikations interfacet er forbundet til NXT’en med et NXT RJ12 kabel.

Figur 10-1: Figuren illustrer, hvordan det ønskes at I2C-interfacet og linjesensoren adskilles fra at være en samlet hardwareenhed, til 2 forskellige enheder. Forbindelsen mellem NXT’en og I2C-bus interfacet sker med et RJ12 kabel, det samme gælder for forbindelsen mellem sensoren og I2C-bus interfacet.

Da linjesensoren og I2C-bus interfacet er designet, så de er uafhængige af hinanden, er det lige til at opdele kredsløbet, således at der er en linjesensor og et I2C-bus interface. Desuden skal der foretages nogle udbedringer af I2C-bus interfacet, for at det bliver bedst egnet til at blive anvendt med så mange sensorer som muligt. Der kunne f.eks. tilføjes en ekstern klok til ATmega8 mikrocontroller med henblik på opgaver, som kræver stor præcision af tiden.

Endvidere ønskes konstruktionen af en block i Lego NXT-G, til den konstruerede linjesensoor, således at det er muligt for interesserede, som ikke har en stor program-meringskunnen til at anvende linjesensorern. Desuden skal det være muligt med blocken at kalibere linejsensoren.

I

REFERENCER

De angivende PDF-kilder er vedlagt på den medfølgende cd.

Bøger [Bx]

[B1] Mikkel Holm Olsen, Atmel AVR programmering, 29. august 2007, s. 79-82.

[B2] Ole Jannerup og Paul Hasse Sørensen, Reguleringsteknik 4. udgave, 2006., s. 120

[B3] Micheal Gasperi and Philippe “Philo”Hurbin with Isabelle Hurban, Extreme NXT, Extending Leog Mindstorms NXT to the next level

PDF-dokumenter [Px]

[P1] John Hansen, NXC_Guide.pdf

[P2] J. Borenstein, H. R. Everett, and L. Feng, Where Am I.pdf, 1996

[P3] Atmel Corporation, ATmega8 databblad.pdf, s. 163-205

[P4] Priyank Patil, Line Follwing Robot.pdf,

[P5] Lego Group, Lego Mindstorms NXT Hardware Developer Kit.pdf, version 1,00, 2006

[P6] Lego Group, Lego Mindstorms NXT User guide.pdf, 2006

[P7] Lego Group, Lego Open Souce License Agreement.pdf, version 1,0, 2006

[P8] Atmel Corporation, SVR STK500 User Guide.pdf,

[P9] OSRAM Opto Semiconductors GMbH & CO. OHG, BPY63 fototransistor

datablad.pdf, 2001

[P10] Lukas Silberbauer, Practical Line Follwing Robot Documentation.pdf, 2005

[P11] Daniele Benedettelli with revisions by John Hansen, Lego NXT Robots using NXC.pdf, version 2,2, 2007

[P13] Guido Socher, A digital thermometer or talk I2C to your Atmel microcontrol ler, 2005

Referencer

II

Hjemmesider [Hx]

[H1] Bricxcc software til programmering af NXT:

http://bricxcc.sourceforge.net

[H2] I2C- bus protokol:

http://www.robot-electronics.co.uk/htm/using_the_i2c_bus.htm

[H3] Antallet af sensorer til at følge en linje: http://www.wrighthobbies.net/guides/linefollower.htm

[H4] Sensorernes betydning for detektering af en linje: http://www.ikalogic.com/tut_line_sens_algo.php

[H5] NXT-G: Officiel Lego Mindsorms NXT hjemmeside: http://mindstorms.lego.com/Overview/The_NXT.aspx

[H6] Officiel Lego Mindsorms hjemmeside: http://www.lego.com/eng/education/mindstorms/home.asp?pagename=rcx

[H7] ROBOTC: Officel hjemmeside:

http://www.robotc.net/

[H8] Anbefalet side af Lego:

http://www.philohome.com/motors/motorcomp.htm

[H9] Robocup banen: Officiel DTU Robocup hjemmeside:

http://www.dtu.dk/subsites/robocup/konkurrencen/banen.aspx

[H10] Test af software til NXT:

http://www.teamhassenplug.org/NXT/NXTSoftware.html

[H11] RoboCup junior:

http://www.dtu.dk/upload/subsites/robocup/junior/robocupjunior.pdf

NXT’ens system arkitektur

[H12] http://lejos-osek.sourceforge.net/NXT_system_architecture.JPG

Sensorer

[H13] http://irbasic.blogspot.com/

Dioder

[H14] www.pchonline.dk

IV

A BEREGNING AF MAX HASTIGHED

Den maksimale hastighed af en NXT motor er 170 rpm. De største hjul der følger med NXT’en har en diameter på 8,6 cm. Den maximale hastighed af en NXT robot uden gearing fås således til følgende:

170 · 8,6 ·60 77 ( A.1)

V

B KREDSLØBSDESIGN AF PROTOTYPEN AF LINJESENSOREN

Documents

Lego Mindstorms NXT til robotter - DTU Electronic …etd.dtu.dk/thesis/221228/Bachelorprojekt_1_juli_2008_Nimalendiran.pdf · ii Lego Mindstorms NXT til robotter, Interface til kommunikation