|
|
# Group 5
|
|
|
|
|
|
## Lab Notebook Lesson 5
|
|
|
|
|
|
**Date:** 19/03 2015
|
|
|
|
|
|
**Group members participating:** Daniel Vestergaard, Christoffer Skovgaard, Mikkel Brun Jakobsen og Josephine Raun Thomsen.
|
|
|
|
|
|
**Activity duration:** 6 + 3 + 4 + 10 hours
|
|
|
|
|
|
## Goal
|
|
|
I denne lesson er målet at lave en *selvbalancerende* LEGO robot gennem eksperimentering med NXT lyssensor, NXT farvesensor og HiTechnic gyrosensor. Med inspiration fra Hassenplug’s berømte Legway [1], der både er i stand til at bevæge sig og balancere på to hjul samtidig, ønsker vi at udforske dette felt. Yderligere eksempler på selvbalancerende robotter er også at finde i Hurbain’s NXTway [2] og Bagnall’s balancerende robot, der benytter programmet Sejway.java [3]. I de følgende øvelser vil vi tage udgangspunkt i de to sidstnævnte eksempler på selvbalancerende LEGO-robotter kontrolleret af en NXT.
|
|
|
|
|
|
## Plan
|
|
|
Vores plan er at følge den overordnede guide for Lesson 5 [3] samt søge inspiration i den tilhørende litteratur for guiden.
|
|
|
|
|
|
## Results
|
|
|
|
|
|
### 1. Self-balancing robot with light sensor
|
|
|
|
|
|
I denne øvelse eksperimenterede vi med NXT lyssensor som input til at gøre NXT robotten selvbalancerende. Vores fysiske konstruktion af LEGO-robotten er bygget efter Hurbain’s billeder af hans NXTway selvbalancerende robot [2]. I billedet nedenfor ses den robot, vi har bygget og gjort brug af i eksperimentet.
|
|
|
|
|
|
*Billede 1: NXTway-lignende robot anvendt i eksperimenterne med lyssensoren*
|
|
|
|
|
|
![lyssensor](http://gitlab.au.dk/uploads/jrt92/lesson-5/3fdf3081ca/lyssensor.JPG)
|
|
|
|
|
|
Programmet som vi har afviklet på NXT’en er Bagnall’s Sejway.java program [3]. For at kalibrere PID controllerens setpoint variabel (offset), altså balancepunktet, forsøgte vi at holde robotten lodret mens vi aflæste værdien på displayet. Hernæst definerede vi den aflæste offset-variablen i selve kildekoden, fremfor at lade robotten afhænge af den kalibrerede værdi. Vi gjorde dette for at undgå at et tryk på ENTER-knappen, i forbindelse med kalibreringen, skulle give anledning til en betydningsfuld fejlkilde i robottens evne til selv at balancere. Nedenfor ses et uddrag fra vores kode, som viser hvordan vi satte offset-værdien manuelt.
|
|
|
|
|
|
*Kode 1: Eksempel på manuel indsættelse af offset-variabel i kildekoden*
|
|
|
|
|
|
```Java
|
|
|
public void getBalancePos() {
|
|
|
// Wait for user to balance and press orange button
|
|
|
while (!Button.ENTER.isDown()) {
|
|
|
// NXTway must be balanced.
|
|
|
offset = ls.readNormalizedValue();
|
|
|
LCD.clear();
|
|
|
LCD.drawInt(offset, 2, 4);
|
|
|
LCD.refresh();
|
|
|
}
|
|
|
offset = 295;
|
|
|
}
|
|
|
```
|
|
|
|
|
|
Vores følgende seks eksperimenter havde til formål at undersøge, under hvilke miljømæssige betingelser lyssensoren virker optimalt. Som Hurbain konkluderer i sine egne eksperimenter med NXTway er lyssensoren ret kræsen i forhold til sine omgivelser.
|
|
|
|
|
|
Vi har valgt at afprøve lyssensoren i tre forskellige miljøer med to forskellige konfigurationer. Miljøerne er hhv. et blå let teksturerede gulv i Zuse bygningen, en hvid halvmat karton overflade og et stærkt teksturerede og farvet stykke karton. Konfigurationsmæssigt har vi afprøvet lyssensoren i ca. 1 og 4 cm højde over jorden. Billedet nedenfor viser overfladen i de tre forskellige miljøer afprøvet.
|
|
|
|
|
|
*Billede 2: Overflade miljøer afprøvet i eksperiment*
|
|
|
|
|
|
![Skærmbillede 2015-03-25 kl. 13.33.18](http://gitlab.au.dk/uploads/jrt92/lesson-5/4862381ac1/Sk%C3%A6rmbillede_2015-03-25_kl._13.33.18.png)
|
|
|
|
|
|
#### Eksperiment 1a: Selvbalancerende LEGO-robot på blå let tekstureret gulvoverflade med lyssensor placeret i ca. 1 cm højde
|
|
|
|
|
|
I dette eksperiment læste vi offset-værdien til 330 i balanceret position. Demonstrationsvideoen nedenfor viser at LEGO-bilen formåede at balancere kortvarigt på gulvet, men ikke over længere tid. Gulvets lette teksturerede overflade lader til at gøre det svært for lyssensorens at registrere overfladen, og dermed besværliggør robottens evne til at registrere om den var på vej ud af balance eller befinder sig i rette position.
|
|
|
|
|
|
*Video 1: Demonstration af LEGO-robot med lavt-placeret lyssensor over gulv*
|
|
|
|
|
|
[![image alt text](https://img.youtube.com/vi/-5ez4bxLDb0/0.jpg)](https://www.youtube.com/watch?v=-5ez4bxLDb0)
|
|
|
|
|
|
#### Eksperiment 1b: Selvbalancerende LEGO-robot på hvid karton overflade med lyssensor placeret i ca. 1 cm højde
|
|
|
|
|
|
I dette eksperiment læste vi offset-værdien til 505. Som det fremgår i video-demonstrationen nedenfor er det umiddelbart lettere for lyssensoren at aflæse den ensfarvede hvide overflade, og dermed hjælpe robotten i at opretholde balanceakten. Sensoren er dog stadig meget følsom, så blot det at personen, som set i videoen, bevæger armen ind foran loftslyset og dermed skygger, kan kaste robotten ud af balance fordi det ændre på offset værdien.
|
|
|
|
|
|
|
|
|
*Video 2: Demonstration af LEGO-robot med lavt-placeret lyssensor over hvid overflade*
|
|
|
|
|
|
[![image alt text](https://img.youtube.com/vi/mabLEgwjdIM/0.jpg)](https://www.youtube.com/watch?v=mabLEgwjdIM)
|
|
|
|
|
|
|
|
|
#### Eksperiment 1c: Selvbalancerende LEGO-robot på meget teksturet og flerfarvet karton overflade med lyssensor placeret i ca. 1 cm højde
|
|
|
|
|
|
|
|
|
Med udgangspunkt i de to forrige eksperimenter, var det forventeligt, at LEGO-bilen ville opleve store udfordringer med at finde et balancepunkt pga. de store afvigelser i tekstur og farve på overfladen af kartonen, brugt i dette eksperiment. Lyssensoren blev kalibreret over det lys-orange område, med en værdi af 520, hvilket fremgår omkring 0:14 i video-demonstrationen. Dette var stedet hvor robotten kunne holde balancen i længst tid, men denne overflade var alt i alt stadig den sværeste for robotten at balancere på.
|
|
|
|
|
|
|
|
|
*Video 3: Demonstration af LEGO-robot med lavt-placeret lyssensor over flerfarvet overflade*
|
|
|
|
|
|
[![image alt text](https://img.youtube.com/vi/yUM0RjlRGRU/0.jpg)](https://www.youtube.com/watch?v=yUM0RjlRGRU)
|
|
|
|
|
|
|
|
|
Erfaring fra de tre forrige eksperimenter viste at LEGO-bilen havde en tendens til at hvile på lyssensoren, hvis den kom ud af balance og væltede forover. Derfor gentog vi de 3 første forsøg, denne gang med sensoren placeret højere (ca. 4 cm), for at give mulighed for at korrigere lige meget til begge sider, og samtidig erfare om det er en fordel at aflæse overfladerne fra en længere afstand.
|
|
|
|
|
|
|
|
|
*Billede 3: Sammenligning af setup med lavtsiddende lyssensor (ca. 1 cm højde), vist til højre, og højtsiddende lyssensor (ca. 4 cm højde), vist til venstre.*
|
|
|
|
|
|
![Skærmbillede 2015-03-25 kl. 18.07.44](http://gitlab.au.dk/uploads/jrt92/lesson-5/254fdeb199/Sk%C3%A6rmbillede_2015-03-25_kl._18.07.44.png)
|
|
|
|
|
|
Lyssensoren på robotten til venstre, med sin højere siddende lyssensor, viser at det udsendte lys oplyser et større område end den lavere siddende lyssensor, i setup’et til højre. Det giver formodentlig sensoren et større område at måle fra, hvilket kan påvirke særligt hvorledes overflader med stor variation i farve og tekstur registreres. I de følgende eksperimenter vil vi undersøge dette.
|
|
|
|
|
|
|
|
|
#### Eksperiment 2a: Selvbalancerende LEGO-robot på blå let tekstureret gulvoverflade med lyssensor placeret i ca. 4 cm højde
|
|
|
|
|
|
Sammenlignet med det tidligere eksperiment er robotten i dette forsøg mere besværet i at holde balancen. Dette kan skyldes, som tidligere nævnt, at lyssensoren skal registrere data over et større område. Da det blå gulv er let tekstureret, kan det give flere afvigelser i målingerne fordi lyssensoren nu skal måle over et større område, med flere variationer i farver end før.
|
|
|
|
|
|
*Video 4: Demonstration af LEGO-robot med højt-placeret lyssensor over gulv*
|
|
|
|
|
|
[![image alt text](https://img.youtube.com/vi/MFUMWxpeyHk/0.jpg)](https://www.youtube.com/watch?v=MFUMWxpeyHk)
|
|
|
|
|
|
|
|
|
#### Eksperiment 2b: Selvbalancerende LEGO-robot på hvid karton overflade med lyssensor placeret i ca. 4 cm højde
|
|
|
|
|
|
|
|
|
Besynderligt nok udviste robotten på den konsistente hvide overflade samme problemer som robotten i eksperiment 2a oplevede på det blå gulv (se video 5 nedenfor). For at minimere antallet af interfererende faktorer i lyssensorens målinger, forsøgte vi at gentage dette forsøg over samme hvide overflade, i et mørkelagt rum. Af gode grunde kunne vi ikke optage video af dette setup, da det blot ville være et sorte billeder, men disse omstændigheder udviste markant bedre resultater, hvor robotten formåede at holde sig stabil i over 10 sekunder.
|
|
|
|
|
|
|
|
|
*Video 5: Demonstration af LEGO-robot med højt-placeret lyssensor over hvid overflade*
|
|
|
|
|
|
[![image alt text](https://img.youtube.com/vi/PicUORAyXCw/0.jpg)](https://www.youtube.com/watch?v=PicUORAyXCw)
|
|
|
|
|
|
|
|
|
#### Eksperiment 2c: Selvbalancerende LEGO-robot på meget teksturet og flerfarvet karton overflade med lyssensor placeret i ca. 4 cm højde
|
|
|
|
|
|
I dette eksperiment udviste robotten stort besvær med at holde balance, antageligvis pga. de store afvigelser i overfladen. I realiten af at den højtplacerede lyssensor registrere et større område, var det forventeligt at robottens evne til at balancere ville være endnu dårligere end det tidligere eksperiment, fordi overfladen ville være endnu mere inkonsistent end tidligere. Som det fremgår af video-demonstrationen er dette også realiteten, da robotten kun kan balancere i ganske få sekunder, før den ryger ud af balance.
|
|
|
|
|
|
|
|
|
*Video 6: Demonstration af LEGO-robot med højt-placeret lyssensor over flerfarvet overflade*
|
|
|
|
|
|
[![image alt text](https://img.youtube.com/vi/A34MzB2hpbQ/0.jpg)](https://www.youtube.com/watch?v=A34MzB2hpbQ)
|
|
|
|
|
|
|
|
|
#### Opsummering af eksperimenter med lyssensor
|
|
|
Opsummeret har vi altså afprøvet tre forskellige miljøer og to konfigurationer i forbindelse med at undersøge lyssensoren som input til at gøre en LEGO robot selvbalancerende. I vores forsøg fandt vi ud af at den overflade robotten nemmest kunne balancere på var en hvid konsistent overflade. Endvidere fandt vi ud af at, robotten balancerer bedre hvis lyssensoren er placeret i afstand af overfladen der måles på, frem for at være helt tæt på den.
|
|
|
|
|
|
|
|
|
### 2. Self-balancing robots with color sensor
|
|
|
|
|
|
I dette forsøg er målet at undersøge NXT farvesensoren som alternativ til at gøre en LEGO-robot selvbalancerende. I de kommende eksperimenter har vi desuden taget udgangspunkt i en anden fysisk robot konstruktion, navngiveligt “NXT Segway with Rider” fra [6]. Vi vil fremover referere til denne fysiske konstruktion af robotten som Ez-Rider.
|
|
|
|
|
|
*Billede 4: Setup af Ez-Rider med farvesensor*
|
|
|
|
|
|
![Segwayrider -Farvesensor](http://gitlab.au.dk/uploads/jrt92/lesson-5/600a66b6de/Segwayrider_-Farvesensor.png)
|
|
|
|
|
|
Under eksperimenterne med lyssensoren blev det tydeligt at vi havde brug for løbende at kunne ændre konstanterne for PID-controlleren. Da vi alligevel skulle ændre på Sejway.java for at få farvesensoren til at virke, sørgede vi i samme omgang for at PID konstanterne og offset variablen kunne ændres i en Bluetooth-forbundet GUI på computeren. I implementeringen heraf gjorde vi brug af PCcarController.java og BTcontrolledCar.java [5]. Billedet nedenfor vises GUI’en der kan ændre konstanterne løbende over Bluetooth.
|
|
|
|
|
|
*Billede 5: Screenshot af GUI til computeren*
|
|
|
|
|
|
![GUI](http://gitlab.au.dk/uploads/jrt92/lesson-5/fc00f2d275/GUI.png)
|
|
|
|
|
|
PID konstanterne fra det originale program (Sejway.java fra Bagnall) passede nogenlunde til den fysiske udformning af Hurbain’s NXTway LEGO-robot, men viste sig at være problematisk for Ez-Rider.
|
|
|
|
|
|
I forbindelse med vores undersøgelser af farvesensoren anså vi at det ville være relevant at undersøge hvilke værdier farvesensoren målte som en funktion af dens afstand til overfladen. Følgende målinger er foretaget i et mørklagt rum, hvor farvesensoren befinder sig i gradvist større afstand fra blank hvid overflade (se billede 6). Hvert punkt på grafen (graf 1) er baseret på gennemsnittet af 5 målinger i samme afstand.
|
|
|
|
|
|
*Billede 6: Farvesensormålinger fra forskellige afstande.*
|
|
|
|
|
|
![colorsensor-afstande](http://gitlab.au.dk/uploads/jrt92/lesson-5/693c8f53cc/colorsensor-afstande.JPG)
|
|
|
|
|
|
*Graf 1: Graf over farvesensormålinger. x-akse er i cm og y-akse er den målte værdi.*
|
|
|
|
|
|
![FarveSensorBegrënsninger](http://gitlab.au.dk/uploads/jrt92/lesson-5/26a246c360/FarveSensorBegr%C3%ABnsninger.png)
|
|
|
|
|
|
Vi observerer at sensoren ikke umiddelbart giver fornuftige værdier under 1 cm afstand til overfladen. Dette er formentlig fordi at det lys farvesensoren udsender bliver afskåret i at reflektere tilbage, som et resultat af sensorens fysiske konstruktion.
|
|
|
|
|
|
Magen til eksperimenterne med lyssensoren, har vi undersøgt farvesensoren i 3 forskellige miljøer (3 forskellige overflader). I disse forbliver farvesensoren i ca. 4 cm højde over den målte overflade.
|
|
|
|
|
|
#### Eksperiment 1a: Selvbalancerende LEGO-robot på blåt let tekstureret gulvoverflade med farvesensor
|
|
|
|
|
|
Dette eksperiment udviste højere grad af stabilitet end med lyssensoren, på det teksturprægede gulv, hvilket medførte de udsving der ses hos LEGO-robotten i video-demonstrationen. Farvesensoren holder LEGO-robotten oprejst i ca. 8 sekunder i demonstrationen, men med de konstante udsving, hvilket skyldes ujævnheder i farveskalaen i gulvets overflade.
|
|
|
|
|
|
*Video 7: Demonstration af color sensor på gulv overflade*
|
|
|
|
|
|
[![image alt text](https://img.youtube.com/vi/fNLMIVwoGi4/0.jpg)](https://www.youtube.com/watch?v=fNLMIVwoGi4)
|
|
|
|
|
|
|
|
|
#### Eksperiment 1b: Selvbalancerende LEGO-robot på hvid karton overflade med farvesensor
|
|
|
|
|
|
Robottens udsving på den hvide overflade, som vist i demonstrationsvideoen (video 8), er åbenlyst reduceret markant fra gulvoverfladen i forrige forsøg (video 7). Resultatet af dette er en stabil balancering, der ved gode forhold (minimal udefrakommende interferens, god kalibrering), kunne stå stabilt i en længere periode. Demonstrationsvideoen viser en stabil balancering i over 10 sekunder. Det er altså derfor umiddelbart favorabelt at bruge en konsistent ensfarvet overflade til farvesensoren.
|
|
|
|
|
|
|
|
|
*Video 8: Demonstration af color sensor på hvid overflade*
|
|
|
|
|
|
[![image alt text](https://img.youtube.com/vi/1YEjK-qraVU/0.jpg)](https://www.youtube.com/watch?v=1YEjK-qraVU)
|
|
|
|
|
|
|
|
|
#### Eksperiment 1c: Selvbalancerende LEGO-robot på multifarvet karton overflade med farvesensor
|
|
|
|
|
|
Som i tilfældet med lyssensoren, fandt vi ikke nogen fornuftig måde at få LEGO-bilen til at balancere oven på det flerfarvede karton, da alle ujævnhederne i overfladens farveskala, gør det meget svært for sensoren at registrere hvornår den er ved at komme ud af balance, kontra hvornår den bevæger sig over en anden farve. Netop dette fænomen ses også tydeligt i video 9.
|
|
|
|
|
|
*Video 9: Demonstration af color sensor på multi-farvet karton*
|
|
|
|
|
|
[![image alt text](https://img.youtube.com/vi/SvUReF4lEUo/0.jpg)](https://www.youtube.com/watch?v=SvUReF4lEUo)
|
|
|
#### Opsummering af eksperimenter med farvesensor
|
|
|
|
|
|
Vores overordnede erfaringer med farvesensoren er at den er bedre til at holde LEGO-robotten stabil over en længere periode, end lyssensoren var i stand til. Derudover lader det til at farvesensoren i modsætning til lyssensoren havde nemmere ved at se bort fra fejlkilder såsom skygger eller andet lys. Farvesensoren er, i vores optik, bedre til at tilpasse sig ujævne overflader, dette ses tydeligst ved eksperiment 1a og 1b, hvor den holder balancen relativt stabilt over den hvide ensartede overflade, og stadig er i stand til at holde balance, dog med oscillationer, over det teksturerede gulv. Det er svært at sige om disse erfaringer udelukkende skyldes en bedre sensor eller om den nye robot konstruktion har et mere favorabelt tyngdepunkt til at holde balance, eller om det faktum at vi eksplicit har ændret på PID konstanterne har noget at sige.
|
|
|
|
|
|
### 3. Self-balancing robots with gyro sensor
|
|
|
|
|
|
I dette eksperiment, forsøger vi at implementere en selvbalancerende LEGO-robot ved brug af en HiTechnics gyrosensor. Den fysiske konstruktion af LEGO-robotten, som vi gør brug af, er magen til Ez-Rider fra part 2 af denne opgave (plus/minus sensor placeringer). Undervejs har vi udført en række eksperimenter med gyrosensoren, for at lære dens virkemåde. Dette var f.eks. nødvendigt for at identificere dens akse, og senere finde ud af dens optimale placering på LEGO-robotten.
|
|
|
|
|
|
|
|
|
#### Gyroeksperimenter
|
|
|
|
|
|
Den gyrosensor vi er blevet stillet til rådighed kan kun detektere rotation omkring én akse, og returnere derfor enkelte værdier i grader pr. sekund. Med målet om at lave en selvbalancerende robot, styret af gyrosensoren, er det relevant for os at lave nogle initiale undersøgelser af gyrosensoren. Vi lavede fire eksperimenter for at finde frem til hvordan sensoren skal vende, samt hvorvidt sensoren måler bedre når den sidder højt i forhold til når den sidder lavt.
|
|
|
|
|
|
|
|
|
##### Eksperiment 1 og 2
|
|
|
|
|
|
I de første to eksperimenter har vi sat sensoren relativt *højt* oppe på robottens arm, i to forskellige retninger (se billede 7). Dernæst har vi logget sensorens rå værdier, mens vi har bevæget den fra en startposition til en slutposition, som fremgår af billede 8. Her angiver den gule pil den udførte bevægelse med robotten, mens a) angiver slutpositionen, b) angiver midterpositionen og c) angiver startpositionen.
|
|
|
|
|
|
|
|
|
*Billede 7: Gyrosensoren placeret i to forskellige retninger - placeret højt.*
|
|
|
|
|
|
![Gyrosensor-høj](http://gitlab.au.dk/uploads/jrt92/lesson-5/1736483f5a/Gyrosensor-h%C3%B8j.png)
|
|
|
|
|
|
*Billede 8: Måling med gyrosensoren - placeret højt.*
|
|
|
|
|
|
![Gyrodata-høj](http://gitlab.au.dk/uploads/jrt92/lesson-5/2b4f74be1d/Gyrodata-h%C3%B8j.png)
|
|
|
|
|
|
*Graf 2: Logning af rå gyrosensorværdier fra høj placering af sensor som Billede 7 a). x-aksen er i tid, og y-aksen er gyrosensorværdier.*
|
|
|
|
|
|
![GyroSensorLuftGod](http://gitlab.au.dk/uploads/jrt92/lesson-5/1173513ba8/GyroSensorLuftGod.png)
|
|
|
|
|
|
*Graf 3: Logning af rå gyrosensorværdier fra høj placering af sensor som Billede 7 b). x-aksen er i tid, og y-aksen er gyrosensorværdier.*
|
|
|
|
|
|
![GyroSensorLuftDÜrlig](http://gitlab.au.dk/uploads/jrt92/lesson-5/9f23fb0371/GyroSensorLuftD%C3%9Crlig.png)
|
|
|
|
|
|
Vi ser at målingerne (vist i graf 2) korresponderer med en fin og kontinuert bølge i a) konfigurationen, mens målingerne fra b) konfigurationen (vist i graf 3) er stort set konstante. Dette indikerer at sensoren skal placeres i a)-konfigurationen for at gyrosensorens akse stemmer overens med LEGO-robottens faldretning. De kraftige udsving der ses på graferne ved hhv. tid ca. 1250 på graf 2 og tid ca. 1000 graf 3 svarer til når robotten rammer bordet og efterfølgende bliver stoppet.
|
|
|
|
|
|
|
|
|
##### Eksperiment 3 og 4
|
|
|
|
|
|
I de følgende eksperimenter har vi sat sensoren *lavt* på robotten, modsat den høje placering i eksperiment 1 og 2. Her eksperimenteres også med to forskellige retninger (se billede 9). Herudover har vi ligesom i eksperiment 1 og 2, logget data og bevæget robotten fra en startposition til en slutposition, som det fremgår af billede 10.
|
|
|
|
|
|
*Billede 9: Gyrosensoren placeret i to forskellige retninger - lav placering.*
|
|
|
|
|
|
![gyro-lav](http://gitlab.au.dk/uploads/jrt92/lesson-5/a253910e31/gyro-lav.png)
|
|
|
|
|
|
*Billede 10: Måling med gyrosensoren - lav placering.*
|
|
|
|
|
|
![Gyrodata-lav](http://gitlab.au.dk/uploads/jrt92/lesson-5/605e00c3f0/Gyrodata-lav.png)
|
|
|
|
|
|
*Graf 4: Logning af gyrosensorværdier fra lav placering af sensor som Billede 9 a). x-aksen er tid og y-aksen er gyrosensorværdier.*
|
|
|
|
|
|
![GyroSensorDÜrlig](http://gitlab.au.dk/uploads/jrt92/lesson-5/a81c78b6ed/GyroSensorD%C3%9Crlig.png)
|
|
|
|
|
|
*Graf 5: Logning af gyrosensorværdier fra lav placering af sensor som Billede 9 b). x-aksen er tid og y-aksen er gyrosensorværdier.*
|
|
|
|
|
|
![GyroSensorGod](http://gitlab.au.dk/uploads/jrt92/lesson-5/c32850070e/GyroSensorGod.png)
|
|
|
|
|
|
I graferne ovenfor ser vi fuldstændigt samme tendens som i eksperiment 1 og 2, i b) konfigurationen (graf 5) ses en blød kontinuerlig bølge, mens a) konfigurationen (graf 4) udviser mange uforklarlige udsving.
|
|
|
|
|
|
Eftersom vi formentlig ikke har bevæget robotten lige hurtigt i alle 4 eksperimenter, er det svært at drage en konklusion om, i hvilken højde sensoren virker optimalt, men det lader umiddelbart til at være uden større betydning om sensoren placeres højt eller lavt på robotten fordi begge grafer viser kontinuerte bølger.
|
|
|
|
|
|
Med viden om hvilken retning gyrosensorens akse befinder sig, er det muligt at gå videre med at få Ez-Rider til at balancere. Efter et par fejlede forsøg på at modificere Sejway.java programmet, kastede vi os over HiTechnic’s egen NXC kode for deres HTWay robot og konverterede den til Java under navnet RoboBalance.java. Vi har undladt at oversætte kode der har med retningsstyring af den balancerende robot at gøre. Den direkte oversættelse af programmet får vores Ez-Rider til at balancere ganske godt - se vores repository for hele koden og video 12, 13 for demonstration.
|
|
|
|
|
|
Den mest essentielle del af koden er hvordan vi tolker hvad vi læser fra gyrosensoren. Når robotten startes op, læser vi den rå værdi fra gyroen et vist antal gange (100) og tager gennemsnittet. Denne værdi gemmes i gOffset og bliver trukket fra fremtidige sensor læsninger for at få svingninger pr sekund.
|
|
|
|
|
|
```Java
|
|
|
private static void updateGyroVars() {
|
|
|
float gyroRaw = gyroSensorPort.readRawValue();
|
|
|
gOffset = EMAOFFSET * gyroRaw + (1.0f - EMAOFFSET) * gOffset;
|
|
|
gyroSpeed = gyroRaw - gOffset; // Angular velocity (degrees/sec)
|
|
|
gyroAngle += gyroSpeed * dt; // Absolute angle (degrees)
|
|
|
}
|
|
|
```
|
|
|
|
|
|
For at undgå at gyrosensoren “drifter” (pga. temperatur, strøm niveau eller andet) bruger NXC koden et løbende gennemsnit af alle de rå værdier vi har set, hvilket som regel betegnes som et Kalman filter. Dette giver mening fordi udsving over tid går ud med hinanden (et sving fremad vil medføre et sving bagud).
|
|
|
|
|
|
Gyro-vinklen (som kontrol løkken forsøger at bringe mod 0) beregnes ved numerisk at integrere (Euler integration) gyro hastigheden. I tidligere implementationer legede vi, uden success, med idéen om at bruge farve eller lyssensoren til at nulstille gyro vinklen hvis farve eller lyssensoren rapporterede en værdi tæt på deres setpoints. Men dette opgav vi fordi det gjorde robottens balanceevne mere ustabil.
|
|
|
|
|
|
|
|
|
##### Eksperiment 5
|
|
|
|
|
|
På trods af at sensoren giver fornuftige målinger når den sidder højt og vi manuelt bevæger den (jf. graf 2) observerede vi at “rygraden” på robotten vibrerede, når den forsøgte at balancere ved afvikling af “RoboBalance.java”. Dermed har den fysiske konstruktion af robotten betydning for robottens performance, idet sensorens målinger også vil afspejle disse vibrationer. Vi forsøgte at overkomme dette ved at stabilisere rygraden ved brug af tape (se billede 11).
|
|
|
|
|
|
|
|
|
*Billede 11: Illustration af vibrerende spots på LEGO-robot under balancering med højt placeret gyrosensor.*
|
|
|
|
|
|
![ustabil](http://gitlab.au.dk/uploads/jrt92/lesson-5/ac7ef6336e/ustabil.png)
|
|
|
|
|
|
Vi forsøgte at måle på dette fænomen ved at skrive gyrosensorens rå værdier til en fil mens robotten forsøger at balancere. Logning gjorde at vores program blev markant langsommere, hvorved robotten blev ude af stand til at balancere. Dette skyldes at den oprindelige DataLogger klasse (fra Lesson 1) bruger FileOutputStream som blokerer på IO operationer. Så for at løse problemet, wrappede vi DataLoggerens FileOutputStream med en BufferedOutputStream, der ikke blocker på IO operationer, hvorved robotten balancerede uden problemer. Den nye DataLogger kan ses i vores repository (DataLogger.java).
|
|
|
|
|
|
|
|
|
*Graf 6: Logning af gyrosensoren placeret højt. x-aksen viser tid, og y-aksen viser rå gyrosensor værdier.*
|
|
|
|
|
|
![BalanceLuftSensor](http://gitlab.au.dk/uploads/jrt92/lesson-5/eefe1f360f/BalanceLuftSensor.png)
|
|
|
|
|
|
*Video 10: Demonstration af LEGO-robottens kørsel, med højt placeret gyrosensor.*
|
|
|
|
|
|
[![image alt text](https://img.youtube.com/vi/UAGx_o6dkoI/0.jpg)](https://www.youtube.com/watch?v=UAGx_o6dkoI)
|
|
|
|
|
|
Som det kan ses af videoen ovenfor, kører Ez-Rider ikke specielt stabilt. Målingerne (der kan ses i graf 6) svinger utroligt meget mere end de burde. Vi kunne muligvis have overkommet denne forhindring ved at bruge en mere solid rygrads-konstruktion. Vi valgte dog i stedet at forsøge med at placere sensoren længere ned.
|
|
|
|
|
|
|
|
|
*Graf 7: Logning af gyrosensoren placeret lavt. x-aksen er i tid, og y-aksen i er rå gyrosensor værdier.*
|
|
|
|
|
|
![BalanceCenterSensor](http://gitlab.au.dk/uploads/jrt92/lesson-5/22ba94bc80/BalanceCenterSensor.png)
|
|
|
|
|
|
*Video 11: Demonstration af LEGO-robottens kørsel, med lavt placeret gyrosensor.*
|
|
|
|
|
|
[![image alt text](https://img.youtube.com/vi/Ep4hXlnpvvI/0.jpg)](https://www.youtube.com/watch?v=Ep4hXlnpvvI)
|
|
|
|
|
|
Som det fremgår af viden ovenfor, bidrager den lavt placerede sensor på Ez-Rider konstruktionen til en stabil og afbalanceret kørsel. Af graf 7 fremgår det at der forekommer udsving i starten og slutningen af målingen, hvilket stemmer overens med videoen der viser at robotten initialt stabiliserer sig, og til slut får et mindre skub, som den efterfølgende korrigerer for. Foruden disse udsving læner alle værdierne sig tæt op ad gyrosensorens offset, hvilket i video-demonstrationen kommer til udtryk ved en stabil balancering. Altså er denne placering af gyrosensensoren optimal i at lade robotten selvbalancere.
|
|
|
|
|
|
|
|
|
### Demonstration af endelig version af Ez-Rider
|
|
|
|
|
|
Efter vi determinerede den optimale placering af gyrosensoren, har vi opsummerende demonstreret Ez-Rider’s egenskaber til at køre stabilt og yderligere korrigere for udefrakommende skub, igennem de nedenstående 2 videoer, hvor video 12 har fokus på stabil balancering, mens video 13 fokuserer på korrigering.
|
|
|
|
|
|
|
|
|
*Video 12: Demonstration af selvbalancerende robot med gyrosensor - part 1*
|
|
|
|
|
|
[![image alt text](https://img.youtube.com/vi/sI3gVpquYT0/0.jpg)](https://www.youtube.com/watch?v=sI3gVpquYT0)
|
|
|
|
|
|
*Video 13: Demonstration af selvbalancerende robot med gyrosensor - part 2*
|
|
|
|
|
|
[![image alt text](https://img.youtube.com/vi/pnnmXQCKBUc/0.jpg)](https://www.youtube.com/watch?v=pnnmXQCKBUc)
|
|
|
|
|
|
Remember kids - safety first:
|
|
|
|
|
|
![Safety-first](http://gitlab.au.dk/uploads/jrt92/lesson-5/3112f05058/Safety-first.JPG)
|
|
|
|
|
|
## Conclusion
|
|
|
|
|
|
Alle øvelser for denne uge blev udført ved hjælp af NXT guiden for Lesson 5 [4]. Det overordnede mål for øvelserne var at lave en selvbalancerende LEGO-robot gennem eksperimentering med forskellige sensorer, herunder NXT lyssensor, NXT farvesensor og HiTechnic gyrosensor. Gennem disse eksperimenter opnåede vi desuden en større forståelse for de enkelte sensorer med henblik på deres respektive anvendelsesramme, herunder fordele og begrænsninger.
|
|
|
|
|
|
Gennem eksperimentering med lyssensoren var det ikke muligt for os at få robotten til at balancere i længere tid. Vi benyttede to forskellige konfigurationer af lyssensoren samt Hurbain’s opsætning af robotten som “NXTway”[2], og demonstrerede at robotten havde nemmere ved at balancere, hvis lyssensoren er placeret i ca. 4 cm højde frem for helt tæt på overfladen. Derudover testede vi lyssensoren i tre forskellige “miljøer”, hvor vi erfarede at lyssensoren bliver kraftigt påvirket af sine miljømæssige omgivelser. Ydre faktorer såsom selve overfladen robotten placeres på, har især stor betydning for robottens samlede performance. Her fandt vi ud af at en hvid overflade er at foretrække frem for en gulvoverflade og en flerfarvet overflade.
|
|
|
|
|
|
Ved eksperimentering med farvesensoren konstruerede vi robotten som “NXT Segway with Rider” [6]. Denne fysiske konstruktion er væsentligt anderledes end NXTway (både højere og med lavere tyngdepunkt), og resultaterne med farvesensoren kan derfor være svære at sammenligne med lyssensoren. Ikke desto mindre var robotten væsentligt bedre til at holde sig selvbalancerende i længere tid med farvesensoren. Dette kan dels skyldes den nye konstruktion, men også det faktum at vi kalibrerede den anvendte PID-controller.
|
|
|
|
|
|
I vores sidste eksperimenter med brug af gyrosensoren viste det sig at det var muligt at udvikle en selvbalancerende robot uden at ændre på “NXT Segway with Rider” konstruktionen. Adskillige eksperimenter med gyrosensoren blev gennemført bl.a. for at undersøge, hvordan sensoren skulle placeres og hvordan den skulle vende for at optimere dens læseevne. Ved brug af datalogging var det f.eks. muligt at identificere hvilken akse gyrosensoren målte på. Vi udviklede herefter adskillige programmer baseret på vores resultater, hvor vi bl.a. modificere Bagnall’s Sejway.java [3] program, men ud fra disse var det ikke muligt at gøre robotten tilfredsstillende selvbalancerende. Så vi forsatte med mere held i at omskrive den tilhørende kode for HTWay robotten [7] til Java. Demonstration af kørslen af denne kode viste at robotten var i stand til at balancere af sig selv, og endda modstå lette skub fra ydre påvirkninger. Altså med den rette kombination af undersøger i fht. optimal hardware og software var det muligt for os at udvikle en selvbalancerende robot.
|
|
|
|
|
|
## References
|
|
|
|
|
|
[1] Hassenplug, Steve. Legway - http://www.teamhassenplug.org/robots/legway/
|
|
|
|
|
|
[2] Hurbain, Phillipe. NXTway - http://www.philohome.com/nxtway/nxtway.htm
|
|
|
|
|
|
[3] Bagnall, Brian. Maximum Lego NXTBuilding Robots with Java Brains, Chapter 11, 243 - 284.
|
|
|
The chapter contains a java program Sejway.java that can be used as a starting point for experiments with a self-balancing LEGO robot.
|
|
|
|
|
|
[4] NXT guide for Lesson 5 - http://legolab.cs.au.dk/DigitalControl.dir/NXT/Lesson5.dir/Lesson.html
|
|
|
|
|
|
[5] Lesson5Programs - PCcarController.java and BTcontrolledCar.java
|
|
|
|
|
|
[6] NXT Segway with Rider
|
|
|
|
|
|
[7] HITechnic, HTWay - A Segway type robot.
|
|
|
|
|
|
|