... | @@ -6,50 +6,67 @@ |
... | @@ -6,50 +6,67 @@ |
|
|
|
|
|
**Group members participating:** Josephine Raun Thomsen, Daniel Vestergaard, Christoffer Skovgaard, Mikkel Brun Jakobsen.
|
|
**Group members participating:** Josephine Raun Thomsen, Daniel Vestergaard, Christoffer Skovgaard, Mikkel Brun Jakobsen.
|
|
|
|
|
|
**Activity duration:** 3 hours
|
|
**Activity duration:** 6 hours
|
|
|
|
|
|
|
|
|
|
## Goal
|
|
## Goal
|
|
What is the goal?
|
|
|
|
I denne LEGO-session eksperimenteres med NXT lyssensor med henblik på at få LEGO-bilen til at følge en sort linje og stoppe i et grønt målfelt for enden af linjen. Vi bruger derfor lyssensoren til at registrere tre farver: sort, hvid og grøn.
|
|
I denne LEGO-session eksperimenteres med NXT lyssensor med henblik på at få LEGO-bilen til at følge en sort linje og stoppe i et grønt målfelt for enden af linjen. Vi bruger derfor lyssensoren til at registrere tre farver: sort, hvid og grøn.
|
|
|
|
|
|
|
|
|
|
## Plan
|
|
## Plan
|
|
What is your plan to reach the goal?
|
|
Vores plan er at følge instruktionerne for de 6 exercises for Lesson 4 [1].
|
|
At følge instruktionerne for Lesson 4 [1].
|
|
|
|
|
|
|
|
## Results
|
|
## Results
|
|
|
|
|
|
### Exercise 1 - Black White Detection
|
|
### Exercise 1 - Black White Detection
|
|
|
|
|
|
I denne exercise benyttes programmet BlackWhiteSensor.java. Vi kalibrerede hernæst bilen til bilens miljø ved at holde sensoren over hhv. en sort overflade (se billede 1) og en hvid overflade (se billede 2). Ved hjælp af værdierne for disse to målinger udregnes et blackWhiteThreshold. Dette beregnes som medianen mellem de to målinger. Efter kalibrering afprøvede vi programmet ved at holde sensoren over en grålig overflade (se billede 3), der derfor hverken kan bestegnes som hvid eller sort, for at se om hvordan programmet reagerede på denne farve.
|
|
I denne exercise benyttes programmet BlackWhiteSensor.java til at undersøge lyssensorens evne til at skelne mellem overfladefarver. Ved kørsel af programmet startes der først med at kalibrer lyssensoren til miljøet, dvs. lyssensoren først holdes over en sort overflade (se billede 1), og dernæst en hvid overflade (se billede 2). Disse to værdier bruges dernæst til at beregne thresholdet (blackWhiteThreshold variablen i BlackWhiteSensor.java) mellem sorte og hvid, ved at tage gennemsnittet for de to. Efter udført kalibrering afprøvede vi programmets evne til at skelne mellem sort og hvid, ved at holde sensoren over en grålig overflade (se billede 3), der hverken kan betegnes som hvid eller sort, for at se hvilken reaktion programmet havde på denne farve.
|
|
|
|
|
|
|
|
|
|
|
|
#### Eksperiment 1: Sort overflade
|
|
|
|
|
|
*Billede 1: Sort overflade*
|
|
*Billede 1: Sort overflade*
|
|
|
|
|
|
![sort](http://gitlab.au.dk/uploads/group-5/group-5-lesson-4/c39b7c2226/sort.JPG)
|
|
![sort](http://gitlab.au.dk/uploads/group-5/group-5-lesson-4/c39b7c2226/sort.JPG)
|
|
|
|
|
|
|
|
Da vi afprøvede programmet på en sort overflade, var programmet, som forventet, i stand til at genkende den sorte overflade.
|
|
|
|
|
|
|
|
|
|
|
|
#### Eksperiment 2: Hvid overflade
|
|
|
|
|
|
*Billede 2: Hvid overflade*
|
|
*Billede 2: Hvid overflade*
|
|
|
|
|
|
![hvid](http://gitlab.au.dk/uploads/group-5/group-5-lesson-4/c6a5dcec42/hvid.JPG)
|
|
![hvid](http://gitlab.au.dk/uploads/group-5/group-5-lesson-4/c6a5dcec42/hvid.JPG)
|
|
|
|
|
|
|
|
Magen til resultatet på den sorte overflade, var programmet også i dette tilfælde i stand til at genkende den hvide overflade.
|
|
|
|
|
|
|
|
|
|
|
|
#### Eksperiment 3: Grålig overflade
|
|
|
|
|
|
*Billede 3: Grålig overflade*
|
|
*Billede 3: Grålig overflade*
|
|
|
|
|
|
![grå](http://gitlab.au.dk/uploads/group-5/group-5-lesson-4/2d71b0e890/gr%C3%A5.JPG)
|
|
![grå](http://gitlab.au.dk/uploads/group-5/group-5-lesson-4/2d71b0e890/gr%C3%A5.JPG)
|
|
|
|
|
|
Sensoren tolkede farven som vist på billede x som hvid. Dvs. programmet yieldede White True, Black False. Dette betyder at værdien for denne farve lægger over det beregnede threshold for sort og hvid. Dette stemmer meget godt overens med vores egen opfattelse af farven, som snarere er lysegrå end mørkegrå.
|
|
Lyssensoren fortolkede den grålige overflade (vist på billede 3) som hvid. Med andre ord fandt programmet at den læste værdi fra lyssensoren lå inden for det hvide interval (over halvdelen af blackWhiteThreshold variable værdien). Herudaf må vi erkende at der formentlig kan opstå komplikationer når der ikke aflæses helt rene farver af sort og hvid.
|
|
|
|
|
|
|
|
|
|
### Exercise 2 - Line Follower with Calibration
|
|
### Exercise 2 - Line Follower with Calibration
|
|
|
|
|
|
I denne exercise benyttede vi os af programmet LineFollowerCal.java. Dette program benytter klassen Car.java til at bevæge bilen.
|
|
I denne exercise benyttede vi os af programmet LineFollowerCal.java. Dette program benytter klassen Car.java til at bevæge bilen.
|
|
|
|
|
|
For demonstration af dette program se videoen nedenfor
|
|
For demonstration af dette program, se videoen nedenfor.
|
|
|
|
|
|
*Video 1: Demonstration af bilen med programmet LineFollowerCal.java*
|
|
*Video 1: Demonstration af bilen med programmet LineFollowerCal.java*
|
|
|
|
|
|
[![image alt text](http://img.youtube.com/vi/UgDLlGIJyGU/0.jpg)](http://www.youtube.com/watch?v=UgDLlGIJyGU)
|
|
[![image alt text](http://img.youtube.com/vi/UgDLlGIJyGU/0.jpg)](http://www.youtube.com/watch?v=UgDLlGIJyGU)
|
|
|
|
|
|
|
|
Det ses tydeligt at bilen med den påsatte lyssensor er i stand til at følge den sorte linje - men vi bemærker også at LEGO bilen oscillere en hel del for at følge linjen. Desuden lader det til at bilens største udsving forekommer når der køres over krydsende linjer.
|
|
|
|
|
|
|
|
|
|
### Exercise 3 - ThreeColorSensor with Calibration
|
|
### Exercise 3 - ThreeColorSensor with Calibration
|
|
|
|
|
|
Programmet BlackWhiteSensor.java kan potentielt set også bruges til at læse og reagere på andre farver end sort og hvid. I programmet ThreeColorSensor.java har vi implementeret en klasse der også kan detektere grøn.
|
|
De allerede definerede intervaller i programmet BlackWhiteSensor.java kan potentielt set komplementeres yderligere af flere intervaller, med det formål at læse og reagere på andre farver end blot sort og hvid. I denne exercise har vi valgt at gøre netop dette, ved at definere et interval i programmet ThreeColorSensor.java, der har til formål at detektere farven grøn.
|
|
|
|
|
|
*Java-kode 1: Calibrate-metoden fra ThreeColorSensor.java*
|
|
*Java-kode 1: Calibrate-metoden fra ThreeColorSensor.java*
|
|
|
|
|
... | @@ -59,12 +76,18 @@ Programmet BlackWhiteSensor.java kan potentielt set også bruges til at læse og |
... | @@ -59,12 +76,18 @@ Programmet BlackWhiteSensor.java kan potentielt set også bruges til at læse og |
|
blackLightValue = read("black");
|
|
blackLightValue = read("black");
|
|
whiteLightValue = read("white");
|
|
whiteLightValue = read("white");
|
|
greenLightValue = read("green");
|
|
greenLightValue = read("green");
|
|
|
|
|
|
// The threshold is calculated as the median between
|
|
// The threshold is calculated as the median between
|
|
// the two readings over the two types of surfaces
|
|
// the two readings over the two types of surfaces
|
|
blackWhiteThreshold = (blackLightValue+whiteLightValue)/2;
|
|
blackWhiteThreshold = (blackLightValue+whiteLightValue)/2;
|
|
|
|
|
|
greenDetectionRange = Math.abs(blackLightValue - whiteLightValue) / 2;
|
|
greenDetectionRange = Math.abs(blackLightValue - whiteLightValue) / 2;
|
|
}
|
|
}
|
|
```
|
|
```
|
|
|
|
|
|
|
|
greenDetectionRange værdien bruges til at definere det interval hvorved lyssensoren læser en grøn overflade. Beregningen af denne værdi foregår ved at tage halvdelen af den absolutte værdi af differencen mellem værdierne for en hvid og sort overflade (blackLightValue og whiteLightValue), således at vi får et relativt interval i fht. til de sorte og hvide intervaller. Eksempelvis, hvis whiteLightValue = 60 og blackLightValue = 30 beregnes greenDetectionRange til 15/2 = 7,5.
|
|
|
|
|
|
|
|
|
|
*Java-kode 2: Green-metoden fra ThreeColorSensor.java*
|
|
*Java-kode 2: Green-metoden fra ThreeColorSensor.java*
|
|
|
|
|
|
```Java
|
|
```Java
|
... | @@ -73,13 +96,14 @@ public boolean green() { |
... | @@ -73,13 +96,14 @@ public boolean green() { |
|
}
|
|
}
|
|
```
|
|
```
|
|
|
|
|
|
|
|
I ovenstående green()-metode bliver differencen mellem den kalibrerede værdi for en grøn overflade (greenLightValue) og lyssensorens måling sammenlignet med greenDetectionRange-værdien for at identificere om den målte værdi ligger indenfor det grønne interval. Hvis vi eksempelvis læser en overflade til readValue = 50 og greenLightValue = 45, får vi Math.abs(45-50) < greenDetectionRange, dvs. 5 < 7,5. Da 5 ligger indenfor vores greenDetectionRange registrerer vi derfor at lyssensoren befinder sig over en grøn overflade.
|
|
|
|
|
|
```Java
|
|
```Java
|
|
import lejos.nxt.Button;
|
|
import lejos.nxt.Button;
|
|
import lejos.nxt.LCD;
|
|
import lejos.nxt.LCD;
|
|
import lejos.nxt.SensorPort;
|
|
import lejos.nxt.SensorPort;
|
|
import lejos.util.Delay;
|
|
import lejos.util.Delay;
|
|
|
|
|
|
|
|
|
|
public class Test {
|
|
public class Test {
|
|
|
|
|
|
public static void main(String[] args) {
|
|
public static void main(String[] args) {
|
... | @@ -103,7 +127,10 @@ public class Test { |
... | @@ -103,7 +127,10 @@ public class Test { |
|
|
|
|
|
}
|
|
}
|
|
```
|
|
```
|
|
Ved at afprøve programmet gennem ovenstående program test.java blev det klart, at programmet kunne detektere grøn på mere end en måde. F.eks. eksperimenterede vi med at læse både sort og hvid for at opnå samme værdi som en grøn overflade ville give. På opsætning nedenfor (billede 4) oplevede vi at at programmet yieldede grøn (" Green: true") ved at læse en bestemt mængde sort og hvid.
|
|
|
|
|
|
Test.java programmet er et simpelt program, der gør brug af vores ThreeColorSensor.java program til at outputte, via displayet, om den læste farve, opfanges som sort, hvid eller grøn.
|
|
|
|
|
|
|
|
Da vi afprøve ovenstående program, Test.java, blev det klart, at programmet kunne detektere grøn på mere end én måde. F.eks. eksperimenterede vi med at læse skellet mellem en sort og hvid overflade for at se om det var muligt at snyde programmet til at opfange en grøn værdi. På opsætningen nedenfor (billede 4) ses forsøgsopstillingen for dette eksperiment, hvor vi oplevede vi at programmet anviste grøn (" Green: true") på skellet mellem en sort og hvid overflade. Lyssensoren kan dermed “blande” sort og hvid, således at den læste værdi bliver et sted midt mellem værdien for sort og hvid afhængigt af mængden af sort og hvid. Dette er naturligvis noget der skal tages højde for i forbindelse med detektering farver i bevægelse, da der herved vil være en kontinuerlig sammenblanding af lysindfaldet i lyssensoren.
|
|
|
|
|
|
*Billede 4: Sensor placeret over både hvid og sort overflade.*
|
|
*Billede 4: Sensor placeret over både hvid og sort overflade.*
|
|
|
|
|
... | @@ -112,6 +139,7 @@ Ved at afprøve programmet gennem ovenstående program test.java blev det klart, |
... | @@ -112,6 +139,7 @@ Ved at afprøve programmet gennem ovenstående program test.java blev det klart, |
|
|
|
|
|
### Exercise 4 - Line Follower that stops in a Goal Zone
|
|
### Exercise 4 - Line Follower that stops in a Goal Zone
|
|
|
|
|
|
|
|
I programmet LineFollowerCal.java benyttes ligeledes vores ThreeColorSensor.java program, men denne gang til at følge en sort linje, for tilsidst at stoppe i en grøn zone (areal med grøn overflade). Udfordringen i denne exercise ligger I at sensoren kan have svært ved at differentiere imellem de 3 farver i bevægelse. F.eks. som identificeret i forrige exercise aflæses en overflade der er delvist sort og delvist hvid, som værende det definerede interval for grøn. Måden hvorpå vi har løst denne udfordringer er ved at implementere en counter, der for hver gang der læses grønt, tæller op indtil tilstrækkeligt med grønne værdier er fundet, eller nulstiller counteren hvis den læser en hvid eller sort overflade i stedet. Dermed stopper bilen først, hvis en grøn overflade læses mindst 30 gange i træk, for at sikre mod fejlaflæsninger. De 30 gange er en værdi som vi eksperimentelt har udledt.
|
|
|
|
|
|
```Java
|
|
```Java
|
|
import lejos.nxt.*;
|
|
import lejos.nxt.*;
|
... | @@ -164,26 +192,34 @@ public class LineFollowerCal { |
... | @@ -164,26 +192,34 @@ public class LineFollowerCal { |
|
}
|
|
}
|
|
}
|
|
}
|
|
```
|
|
```
|
|
|
|
|
|
*Video 2: Demonstration af programmet*
|
|
*Video 2: Demonstration af programmet*
|
|
|
|
|
|
[![image alt text](http://img.youtube.com/vi/u0Iddyub2Z0/0.jpg)](http://www.youtube.com/watch?v=u0Iddyub2Z0)
|
|
[![image alt text](http://img.youtube.com/vi/u0Iddyub2Z0/0.jpg)](http://www.youtube.com/watch?v=u0Iddyub2Z0)
|
|
|
|
|
|
|
|
Som det ses af videoen ovenfor følger LEGO-bilen den sorte streg, indtil den bevæger sig ind i det grønne felt, hvor den stopper efter en mindre forsinkelse. Forsinkelsen skyldes at counteren skal tælle tilstrækkeligt med grønne værdier (30) inden den identificere en reel grøn værdi, og dermed stopper bilen. Dette er naturligvis noget som kan optimeres yderligere.
|
|
|
|
|
|
|
|
|
|
### Exercise 5 - PID Line Follower
|
|
### Exercise 5 - PID Line Follower
|
|
|
|
Som det fremgår af Video 1 viser LEGO-bilen en oscillerende opførsel, hvor lyssensoren regelmæssigt bevæges fra den sorte linje ud i det hvide område. Denne opførsel forsøgte vi at optimere ved at få LEGO-bilen til at bevæge sig mere “smooth”, og dermed undgå oscillering, ved at benytte en PID-controller.
|
|
|
|
|
|
Vi brugte Bluetooth og en GUI til løbende at ændre på PID konstanterne (og minPower).
|
|
For at kunne ændre på konstanterne uden overhead med at uploade programmet, benyttede vi os af Bluetooth samt en GUI, der tillod vi kunne tilgå konstanterne (og minPower). Dette gjorde vi for at fjerne overheadet i at uploade programmet med nye værdier hele tiden.
|
|
|
|
|
|
Vi fandt konstanterne i rækkefølgen Kp, Ki, Kd. Kp konstanten var valgt således at robotten nogenlunde fulgte en lige linje uden at oscillere så meget at det var synligt. Da robotten havde svært ved at dreje om hjørnet, satte vi stille og roligt Ki konstanten op indtil hjørnet ikke længere var et problem. Til sidste fandt vi en Ki konstant der gjorde at robotten kunne håndtere at vi skubbede til den.
|
|
Ved eksperimentel udledning fandt vi frem til konstanterne i PID controlleren som vi fandt fornuftige - selvom der uden tvivl er plads til forbedringer. Vi startede med at identificere Proportional konstanten (Kp), hernæst Integral konstanten (Ki) tilsidst Differential konstanten (Kd). Kp konstanten valgte vi således at robotten nogenlunde fulgte en lige linje, med mindst mulig oscillering. Da vi observerede at LEGO-bilen havde svært ved at dreje om hjørnet, finjusterede vi særligt Ki konstanten op, indtil dette sving ikke længere var problematisk. Slutteligt finjusterede vi atter Ki konstanten, i en sådan grad at bilen kunne håndtere at blive slået mildt ud af kurs selvom vi skubbede til den. Fremfor de foreslåede 2/3 faktor “dampning” i integral leddet [2], brugte vi en faktor 0.5.
|
|
|
|
|
|
TODO: Noget med at et af de to hjul blev "bremset" af kanten?
|
|
|
|
|
|
|
|
Vi "damper" vores integral led med en faktor på 0.5 (i modsætning til den foreslåede 2/3 i [2]).
|
|
*Video 3: Demonstration af vores bedste kalibrering af PID controlleren*
|
|
|
|
|
|
[![image alt text](http://img.youtube.com/vi/Qxq-QzVjhmg/0.jpg)](http://www.youtube.com/watch?v=Qxq-QzVjhmg)
|
|
[![image alt text](http://img.youtube.com/vi/Qxq-QzVjhmg/0.jpg)](http://www.youtube.com/watch?v=Qxq-QzVjhmg)
|
|
|
|
|
|
|
|
Videodemonstrationen viser hvorledes LEGO-bilen kører stabilt langs den sorte streg, og at den ved skub retter sig ind på kursen, inden for ca 1,5 sekunder. Ligeledes følger LEGO-bilen den sorte streg rundt i svinget, uden nogen tydelig oscillering.
|
|
|
|
|
|
### Exercise 6 - Color Sensor
|
|
### Exercise 6 - Color Sensor
|
|
|
|
|
|
|
|
Tilsvarende exercise 4, ønsker vi at LEGO-bilen skal følge en sort linje, indtil den rammer en grøn overflade, men denne gang ved at gøre brug af en farvesensor i stedet for en lyssensor. Ved at benytte ColorSensorTest.java programmet og placere sensoren hhv. over sort, hvid og grøn er det muligt for os at undersøge om farvesensoren kan skelne mellem de tre farver. Resultaterne kan ses nedenfor.
|
|
|
|
|
|
|
|
*Figur 1: Dataindsamling for farverne sort, hvid og grøn ved brug af programmet ColorSensorTest.java*
|
|
|
|
|
|
| Black | Raw | Cal |
|
|
| Black | Raw | Cal |
|
|
| ------------- |:-------------:| -----:|
|
|
| ------------- |:-------------:| -----:|
|
|
| Red | 64 | 1 |
|
|
| Red | 64 | 1 |
|
... | @@ -206,10 +242,18 @@ Vi "damper" vores integral led med en faktor på 0.5 (i modsætning til den fore |
... | @@ -206,10 +242,18 @@ Vi "damper" vores integral led med en faktor på 0.5 (i modsætning til den fore |
|
| Blue | 335 | 88 |
|
|
| Blue | 335 | 88 |
|
|
| Light | 444 | 134 |
|
|
| Light | 444 | 134 |
|
|
|
|
|
|
|
|
Som det ses af målingerne herunder, er der en distinkt afvigelse mellem de tre farver. Disse målinger kan vi benytte til at differentiere mellem farverne og få LEGO-bilen til følge en sort streg og stoppe i et grønt felt.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## Conclusion
|
|
## Conclusion
|
|
|
|
|
|
|
|
Alle øvelser i denne uge blev udført ved hjælp af instruktionerne fra NXT guiden for Lesson 4 [1]. Gennem øvelsernes forskellige eksperimenter med NXT lyssensoren opnået en klarere forståelse for lyssensoren anvendelsesramme og dens tilhørende egenskaber.
|
|
|
|
|
|
|
|
Vi har vist at vi kan kontrollere LEGO-bilens bevægelsesmønster udelukkende ved hjælp af lyssensoren, herunder få den til at følge en sort streg, stoppe når den registrerede et grønt felt. I denne forbindelse har vi gjort os erfaring med en væsentlig problematik ved lyssensoren, idet lyssensoren er istand til at læse en værdi for en bestemt farve uden nødvendigvis at være placeret over pågældende farve. Dette skyldes at lyssensoren er istand til at læse flere farver på én gang og dernæst beregne et slags gennemsnit baseret på mængden af hver farve. I en øvelse overkom vi dette ved at kræve af lyssensoren skulle registrere samme værdi for farven over et længere tidsinterval, således forekomsten disse tilfældigheder blev elimineret.
|
|
|
|
|
|
|
|
Derudover eksperimenterede vi med måden LEGO-bilen bevægede sig på ved at få den til at bevæge sig mere flydende, og dermed følge den sorte linje mere præcist. Dette lykkedes ved hjælp af en PID-controller, hvor vi gennem eksperimentation med konstanterne (proportional-, integral-, og differential konstanten) fandt frem til en kombination, således LEGO-bilen var i stand til at oscillere mindst muligt, men samtidig håndtere skarpe sving. Slutteligt, har vi påvist at det er muligt at få LEGO til at udvise samme opførsel som ved brug af en farvesensor, der ligeledes lyssensoren kan differentiere mellem forskellige farver.
|
|
|
|
|
|
## References
|
|
## References
|
|
|
|
|
|
[1] NXT programming guide - Lesson 4:
|
|
[1] NXT programming guide - Lesson 4:
|
... | @@ -217,3 +261,5 @@ http://legolab.cs.au.dk/DigitalControl.dir/NXT/Lesson4.dir/Lesson.html |
... | @@ -217,3 +261,5 @@ http://legolab.cs.au.dk/DigitalControl.dir/NXT/Lesson4.dir/Lesson.html |
|
|
|
|
|
[2] A PID Controller For Lego Mindstorms Robots
|
|
[2] A PID Controller For Lego Mindstorms Robots
|
|
http://www.inpharmix.com/jps/PID_Controller_For_Lego_Mindstorms_Robots.html
|
|
http://www.inpharmix.com/jps/PID_Controller_For_Lego_Mindstorms_Robots.html
|
|
|
|
|
|
|
|
|