Afsluttende projekt, 6. dag

Date: 5. Januar 2010

Duration of activity: 3½ hours
Group members participating: Heine Stokholm, Michael Vilhelmsen og Mads Møller Jensen

Dagens mål

• Få optimeret de forskellige dele af programmet, som robotten skal køre
• Forsøge at sætte de forskellige dele sammen, så robotten kan køre gennem banen, hvis vi bliver færdige med at optimere.

Plan

• Dele programmet op i de forskellige sekvenser igen
• Sætte farten ned i PID-systemerne
• Forsøge at anvende tachocounteren i stedet for kompasset

Optimering

Efter en dag i går, hvor robotten ikke rigtigt lystrede, har vi valgt at forsøge at optimere vores robot. Vi har derfor delt programmet op i mindre dele:

1. TurningRobot - kode
2. LineFollower - kode

Den del af programmet som vælger hvor robotten skal køre hen næste gang, er blot en algoritme og er derfor ikke relevant at tjekke i praksis med robotten.

TurningRobot programmet får robotten til at dreje rundt om sig selv, og for hver 90 grader måler den med lyssensoren, om den har set en åben eller en lukket vej. Vi har haft dette program til at virke før, men robotten kommer uregelmæssigt ud af programmet hver gang. Derfor bliver vi nødt til at optimere enten ved at optimere med kompasset eller bruge tachocounteren. Vi har forsøgt mange gange tidligere at bruge kompasset, men hver gang vi troede, at det virkede, har den skiftet opførsel til næste gennemløb. Derfor har vi prøvet at bruge tachocounteren. Vi ved i forvejen, at denne er upræcis, men i forhold til kompasset, er der ved tachocounteren større sandsynlighed for, at den er cirka lige upræcis hver gang. På den måde håber vi at få lidt mere kontrol med robotten, end vi har når vi bruger kompasset. 

I LineFollower programmet har vi tweaket lidt på de forskellige parametre. F.eks. har vi sat farten væsentligt ned og skruet lidt ned for Kc og Kp konstanten, for at få robotten til at oscillere mindre omkring linjen. Linjen skal jo bare bruges til at rette op efter, når robotten har drejet 360 grader om sig selv. Derfor dur det ikke hvis den oscillerer for meget, så den holder skævt, når LineFolloweren stopper. 

Repræsentation

Vi har også arbejdet videre med robottens repræsentation af kortet. Robotten husker på et 2-dimensionalt array bestående af Tiles. Disse Tiles kan man så spørge, om det er muligt at køre nord, syd, øst eller vest. Robotten finder ud af dette, når den kører rundt og scanner banen. I RoadmapRepresentation klassen har vi så lavet en metode, som tager et 2-dimensionalt array af Tiles og laver om til et streng.array, som vi så kan bearbejde på samme måde som de streng-arrays vi brugte i eksemplet fra sidste gang. Det eneste vi mangler nu er, at robotten kan konstruere det 2-dimensionale array ud fra det den læser på banen og efter færdigt gennemløb sender arrayet til computeren via BlueTooth. 

Status

Det hjalp os rigtig meget at skifte til tachocounteren. Vi får meget tæt på 90 graders rotation efter at have justeret lidt på hjulbredden osv. og sat farten meget ned. TurningRobot-delen er som det skal være nu, og det fungerer godt med at se om der er en væg i de forskellige retninger eller ej. 

LineFolloweren driller os rigtig meget, for vi har en LineFollower som fungerer rigtig godt, men når vi sætter den sammen med de andre komponenter, er der noget vi har overset, som gør at den kører alt for hurtigt, når den følger linjen. Vi troede, at det var TachoPilot-klassens regulateSpeed, der skulle sættes til false, men dette var ikke tilfældet. Vi har endnu ikke fundet fejlen.  

Vi har også modificeret robotten lidt. Vi har forlænget armen med den ene lyssensor, fordi robotten befandt sig lidt for langt væk fra markeringerne efter den retter ind efter den grå midterlinje. 

Næste gang

Næste gang skal vi have robotten til at køre endnu bedre end den gør. Og vi skal have den til at bruge de oplysninger den indsamler, så den ved hvilket modul, den skal køre hen til "næste gang". Hvis der bliver tid, skal vi se om den kan udfylde et array af Tiles og måske sende dette til computeren, som kan lave en grafisk repræsentation af dette.  

Afsluttende projekt, 5. dag

Date: 4. Januar 2010
Duration of activity: 4 hours
Group members participating: Heine Stokholm, Michael Vilhelmsen og Mads Møller Jensen


Dagens mål

• Få Thor til at køre efter vores sekvensstrategi.
• (Rette fejl i koden)
• Implentere brugen af en grå stribe på kortet til at navigere mere præcist efter.
• Optimere kompasset
• (Få Thor til at sende data og få vores PC til at modtage disse)

Plan

Sekvensstrategi:

Vores program består stadig af de 3 sekvenser:

1. Identificer modulet
2. Find ud af hvor vi skal hen næste gang
3. Kør derhen

Thor er i stand til at følge disse strategier, men stadig uden brug af en "LineFollower"-del. Dette vil vi implementere i dag, da det simpelthen er nødvendigt for os for at kunne ordentligt.

Selve PID-systemet til at følge en linje har vi lavet, og vi vil i dag indsætte det i vores kode, så Thor benytter dette som et led i sin sekvensstrategi, under punkt 3.

Grå Stribe:

Vi fik sat en grå stribe på vores bane sidste gang, og stødte på et nyt problem, nemlig at vi aldrig kører midt på striben, men altid til en side af denne. Derfor vil vi i dag flytte alle de små sorte firkanter som vores sekundære lyssensor læser. Disse kan flyttes uden problemer, da de netop er sat på en måde der tager højde for fra hvilken side man kommer. Desuden bliver vi nødt til enten at forlænge armen med vores primære lyssensor på, eller udvide alle de brede sorte striber.

Sende og modtage data:

Vi vil i sidste ende have Thor til at opbygge et map af vores bane, og sende dette til vores PC, som så kan lave en grafisk repræsentation. For at tage hul på dette vil vi i dag forsøge at få Thor til at sende data som vi vil modtage.

Ideelt set vil Thor køre hele vores bane igennem, og så til sidst sende et komplet map af banen. Dette vil i sidste ende betyde at vi indfører et ekstra punkt i vores sekvensstrategi. I dag vil vi dog sende inden vi har et komplet map, da vi stadig er langt fra at kunne foretage et fuldstændigt gennemløb af vores bane. 

Optimere kompas:

Da vi allerede nu forudser problemer med den grå stribe som vi vil implementere, vil vi gøre et sidste forsøg på at gøre kompasset brugbart. Det primære problem skønner vi er elektronisk forstyrrelse fra de mange elektriske kilder der er tilstede i lokalet og tæt ved vores bane. Derfor vil vi undersøge om det vil hjælpe noget at hæve kompasset yderligere, eller måske endda om vores kompas er defekt.

Resultater:

Fejl:

Vi har introduceret adskillige fejl i vores kode, så nu kaster Thor exceptions i vildskab. Derfor arbejder vi på at få disse fejl elimineret, da vi så burde have en (vel)fungerende sekvensstrategi.

Kompas:

Det viste sig at vores kompas stort set er ubrugeligt. Når den blot drejer på stedet fungerede det nogenlunde. 

Her var fejlmarginenen på +/- 10 grader, hvilket ikke er optimalt, men dog brugbart til eks. at dreje 360 grader.

De største udsving viste sig når vi tog vores robot, og pressede den op mod kanten af vores bane, og aflæste kompasværdien, for derefter at rykke vores robot x antal cm. frem.

Her viste det sig, at hvis vi starter i den ene ende af vores bane, hvor vi eks. har værdien 100, og rykker op i den anden ende af vores bane, ender vi på 130. Og talene ændrer sig lineært undervejs, dvs at halvvejs har vi værdien 115. Lignende målinger foretaget andre stedet i lokalet, og med kompasset rykket længere væk fra Thor gav samme resultat - kompasset er ubrugeligt. 

Vi vil derfor undersøge om vi får andre resultater med et andet kompas. Hvis ikke vil vi måske foretage vores sving vha. tachocounter i stedet for kompasset. Navigering må vi i givet fald foretage vha. den grå stribe som vi også har planlagt.

Status:
Vi fik identificeret fejl ved kompasset og overvejer nu andre metoder til at foretage præcise sving på. 
Vi fik ikke arbejdet med at sende data over bluetooth endnu. Dette må vente til senere.
Vi fik dog rettet fejlene i Thor, så han nu igen kan følge en linje.
Den grå stribe og de sorte firkanter "virker" tilfredstillende indtil videre. De skal dog rettes til en gang.


Næste gang:
Vi skal finde en brugbar metode til at foretage præcise sving på.
Vi skal finde ud af at sende og modtage data fra robotten via bluetooth.
Vi skal højst sandsynligt have rettet striberne på banen til, så de er mere præcise.

Afsluttende projekt, 4. dag

Date: 3. Januar 2010
Duration of activity: 4½ hours
Group members participating: Heine Stokholm og Mads Møller Jensen

Dagens mål

• Lave stregen på banen som robotten skal følge
• Få robotten til at køre på banen vha de forskellige sekvenser
• Kigge på repræsentationen af robottens input på computeren
• Evt. Bluetooth-kommunikation

Plan

• Lave en grå streg på banen som robotten kan navigere efter. Vi ønsker denne streg pga. af præcision vanskeligheder ved kompasset.
• Implementere et program som robotten skal køre vha. de forskellige systemer, vi allerede har udviklet
• Implementere et program som skal lave en grafisk repræsentation af de data vi får fra robotten

Stregen
Vi forsøgte at lave en grå streg af gaffatape på vores bane, men vi mødte et stort problem. For at stregen skal få robotten til at blive på midten af banen, skal stregen placeres ved siden af midten, da robotten jo vil korrigere i forhold til den grå farve på stregen og den hvide farve på pladen. Dette giver os et stort problem, da vi ikke kan vide med sikkerhed, hvilken vej robotten kommer fra, og dermed ikke kan vide på hvilken side af midten, stregen skal placeres. Vi vil derfor i første omgang forsøge at teste, om det er muligt for robotten at gennemføre uden at have en streg at korrigere efter. Dette er meget risikabelt, da vi tidligere har haft problemer med kompassets præcision og derved har en potentiel stor fejlmargin. Vi lægger derfor hovederne i blød for at finde et alternativ.

Sekvensstrategi
Vores program består af tre sekvenser:

1. Identificer modulet
2. Find ud af hvor vi skal hen næste gang
3. Kør derhen

Disse tre sekvenser består af en masse små operationer. Ingen af de tre sekvenser var helt færdige, men vi kunne få robotten til at kører rundt 4x90 grader og bippe, når den så hvid, altså en mulig vej. Herefter valgte robotten en tilfældig vej, og kørte indtil den så en sort markering. Her fandt vi ud af, at vi er nødt til at have en rettesnor til robotten i form af en streg. Det var tydeligt for os at se, at det ikke ville fungere i længden ved kun at bruge kompasset, der simpelthen er for upræcist.  

Fred Martin skriver om fordele og ulemper ved en sekventiel strategi i kapitel 5.3 i bogen "Robotic Explorations". En sekventiel tilgang er en række handlinger man udfører for at opnå et ønsket mål. I vores tilfælde at mappe en bane, der er opbygget af moduler. Men disse handlinger er ikke nok i sig selv, hverken i Fred Martins Groucho tilfælde eller i vores. Da robotten er upræcis, er vi nødt til at have nogle feedbackloops for at korrigere. Dette har vi bl.a. i vores kompas PID-system og i den LineFollower vi er nødt til at lave. Sekventielle strategier egner sig godt i et statisk miljø. Groucho er en robot, som kæmper mod andre robotter i Robo-Pong, og den befinder sig dermed i et dynamisk miljø. Vi har derimod et rimeligt statisk miljø med en fast bane og kun en robot. Alligevel er der nogle ændringer i miljøet, som gør at robotten ikke fungerer perfekt. F.eks. Er det et stort problem at der løber strøm i gulvet og i sidepanelerne og det giver vores kompas store problemer. Vi mener dog, at den sekventielle tilgang er vejen at gå, da den opgave vi har opstillet minder meget om en matematisk algoritme, som også består af en række operationer som anvendes på noget data.


Grafisk repræsentation
Vi har lavet et meget simpelt program, som tager et array af strenge, og laver en grafisk repræsentation af disse strenge. I alt sin enkelthed ud på følgende:

1. Vi gemmer de 11 forskellige banemoduler i et map. Hvert modul er repræsenteret af et 300x300 pixel jpeg-billede, som vi har lavet meget primitivt i paint.
2. Vi læser array'et igennem, hvor hver streng repræsenterer et specifikt modul. Strengens placering i arrayet, afgør hvor i griddet det placeres. 
3. Til sidst vises billederne i et grid som svarer til banens opbygning.

Programmet er lavet til at mappe vores specifikke bane, eller i hvert fald en bane af samme størrelse, dvs. 3x3 moduler. Placeringerne i arrayet giver følgende placering i griddet:

Koden for programmet kan ses her: RoadmapRepresentation.java

For at programmet virker skal man lave de 11 moduler og give dem de rigtige navne som er angivet i koden.

Stregen, del 2
Vi har besluttet os for alligevel at lave en grå streg på midten af banemodulerne. Vi kan kompensere for at robotten ikke kører præcis midt på modulet ved at flytte de små sorte markeringer. Markeringerne er i forvejen placeret i forhold til hvilken vej man kommer ind på et modul. Da vi altid vil køre på samme side af den grå streg, er det derfor muligt at flytte markeringerne. Dette betyder, at vi vil have problemer med at få lyssensoren helt ud og læse kanterne, fordi robotten ikke længere holder midt på modulet. Dette kan løses ved enten at forlænge armen som lyssensoren sidder på eller ved at gøre kanterne bredere.
Vi har lavet den tynde grå streg på banen.

Status
Vi har fået et program , der kan tage et streng-array og vise en grafisk repræsentation af de forskellige banemoduler. Vi har fået en streg som kan korrigere robotten, når kompasset er upræcist. Vi har set, hvor langt vi er med vores program.

Næste gang
Næste gang skal vi arbejde med at få sekvensstrategien til at virke og så skal vi flytte alle de sorte markeringer, så de passer til, at robotten kører ved siden af midten.

Referencer
Fred G. Martin, Robotic Exploration: "A Hands-On Introduction to Engineering", 2001 Prentice-Hall 

Afsluttende projekt, 3. dag

Date: 16. December 2010
Duration of activity: 4 hours
Group members participating: Heine Stokholm og Mads Møller Jensen


Dagens mål:

• Færdiggøre PID-systemet
• Finde ud af robottens endelige navigation i banen
• Kigge på Bluetooth kommunikation

Plan:

• Arbejde videre med gårsdagens PID-system
• Undersøge muligheder for at navigere i banen
• Få robotten til at sende de læste kompasværdier til computeren vha. Bluetooth, og eventuelt fortæller detaljer om hvordan den har kørt

PID-systemet

I dag har vi arbejdet videre med PID-systemet og fået et rigtig fornuftigt resultat. Robotten overstyrer stadig, når den skal dreje til en bestemt kompasværdi, men nu har vi fået den til at oscillere tilbage mod målet, så vi ender med en errorværdi på 0, og robotten altså peger præcis den vej, som kompasset fortæller den, den skal. Desværre har vi stadig lidt problemer med kalibreringen af kompasset, så robotten ikke drejer 90 grader, selvom den tror, den gør. Alligevel drejer den "omkring" 90 grader, og vi kan godt bruge dette resultat, selvom det ikke er perfekt.

Planen er, at robotten skal køre til midten af et banemodul, dreje 90 grader og læse om der er en sort streg, og gentage dette fire gange, og på den måde genkende banemodulet. Her er det ikke så vigtig om robotten drejer 90 eller 95 grader, da vi i begge tilfælde vil være muligt at se om der er en sort streg.

Koden for at dreje 90 grader med PID-systemet kan ses her


De største forskelle på PID-systemet til at følge en linie  og det til at følge kompasset er måden vi finder vores offset i starten og måden vi beregner error værdien løbende. Vores metode til at dreje med PID-systemet tager to værdier, start og t, som er i hvilken retning peger og hvor meget vi gerne vil dreje den. Ud fra det beregner vi så offsettet. Error værdien bliver beregnet ud fra offsettet minus den retning vi peger, men med nogle yderligere tjek da vi skal sikre os at vi altid drejer kortest vej. Derfor har vi sagt at hvis vi skal dreje over 180 grader skal vi istedet dreje error - 360 grader. 
Udover det har vi lavet en variabel der meget passende er døbt awesome som bliver talt op hver gang vores error er lig nul, og nulstillet hvis error er forskellige fra nul. Med den kan vi registrere om robotten har fundet hvile i den rigtige retning, eller om den bare står og oscillerer over offsettet. Hvis de sidste 100 errors har været 0 går vi ud af løkken og går ud fra at robotten peger i den rigtige retning. 

De relevante steder i koden står med fed i kodestykket nedenfor.

public static void pidTurn(int start, int t){
 long kp = 300;
 long ki = 10;
 long kd = 500;
 long offset = (start + t)%360;
 long tp = 10;
 long integral = 0;
 long lastError = 0;
 long error = 0, derivative, turn, power;
 int awesome = 0;
 while(awesome < 100){
     LCD.drawInt((int)us.getDegrees(),3,13,0);
     LCD.drawString("offset", 0, 1);
     LCD.drawInt((int)offset,3,13,1);
     LCD.drawString("error", 0, 2);
     LCD.drawInt((int)error,3,13,2);
     error = (start + t)%360 - (int)us.getDegrees();
     if(error > 180) error = error - 360;
     integral = integral + error;
     derivative = error - lastError;
     turn = kp * error + ki * integral + kd * derivative;
     turn = turn / 100;
     power = tp + turn;
     leftMotor.controlMotor((int)power,1);
     rightMotor.controlMotor((int)power,2);
     
     lastError = error;
     if(lastError == 0){
  awesome++;
     }else{
  awesome = 0;
     }
 }
    }
    

Navigation på banen

Problemet i at vores robot ikke drejer præcist er, at vi så har svært ved at få det til at køre "rigtigt" rundt på banen. Vi har derfor valgt at bruge en sekventiel strategi. Først og fremmest vil vi modificere banen, så vi får en midterlinje på hele banen. Derved kunne vi bruge en LineFollower til at køre imellem de forskellige moduler og skifte til kompasfunktionen, når vi skal genkende de forskellige moduler. Et problem, vi dog stadig slås lidt med, er, at vi mangler en god idé, så robotten kan se når den er på midten af et modul, og altså kan bruge genkendelsesprocessen. Indtil videre har vi to forslag:

• Bruge en tacocounter for at måle, hvor langt vi er kørt. Da vi ved hvor store de forskellige moduler er burde dette være en mulig løsning, og også den vi ville have brugt, hvis kompasset fungerede optimalt. Men da vi nok bliver nødt til at bruge en LineFollower, bliver det svære at bedømme afstanden, da robotten skal navigere efter stregen, samtidig med at den skal køre en bestemt længde frem.
• En anden løsning kunne være at lave en markering på midten af hvert modul. På den måde ville robotten kunne genkende midten, når den vha. LineFolloweren nåede derhen. Problemet er her, at vores lyssensor er placeret et stykke foran robotten, så vi alligevel er tvunget til at bruge tacocounteren til at køre det sidste stykke frem, og derved igen er i fare for at miste præcision. En løsning her er dog at bruge en ekstra lyssensor, som vi placerer ud for hjulene. På den måde ved vi, at vi skal stoppe, når denne lyssensor læser markeringen midt på modulet. 

Endnu et PID-system

Vi begyndte at lave et PID-system, så robotten kunne følge en linje, så vi kan være sikre på, at robotten kører "rigtigt" på banen. Igen fulgte vi metoden fra PID_Controller_For_Lego_Mindstorms, da vi føler, at denne metode har en stor succesrate. Dette var overstået rimelig hurtigt og robotten kunne følge en linje uden at oscillere. Eftersom robotten ikke skal følge en linje gennem et sving, gjorde det opgave rimelig overskuelig, og vi fik hurtigt rigtig gode resultater med meget få justeringer. 

Status

De nye tiltag, vi har lavet i dag, har betydet, at vi har lavet to modifikationer i forhold til tidligere.
For det første har vi ombygget robotten:

Dvs. vi nu har en robot med tre sensorer: Et kompas (som er placeret ca. 20 cm væk fra selve NXT'en), en lyssensor (som er placeret foran robotten) og en ekstra lyssensor(som er placeret bag hjulene). Det er nu meningen at robotten skal mappe, som følger:
Følge en streg vha lyssensor1 indtil lyssensor2 ser en markering. Herefter drejer robotten 4x90 grader, og for hver 90 grader scanner den med lyssensor1 efter sort eller hvid. Næste skridt vælger robotten en af de mulige veje, som (den lige har opdaget), eksisterer og følger så vha. lyssensor1 en streg videre til næste gang lyssensor2 ser en markering, osv.


Dette har betydet, at vi også har ændret vores bane:

Selve banen er i for sig den samme, men nu har vi tilføjet alle de markeringer lyssensor2 skal aflæse (de mange små sorte prikker).  Vi mangler dog stadig at lave en streg som robotten skal følge, men dette gemmer vi til næste gang.


Til gengæld har vi nu en klar idé om, hvordan vi skal få robotten til at mappe banen. Vi har et godt PID-system til kompasset og et godt PID-system til at følge linjen med. Det sidste skal muligvis revideres, når vi får testet det på vores endelige bane, altså på den streg vi mangler at tegne op.


Næste gang
Næste gang vil vi:

• Lave stregen på banen, som robotten skal følge
• Få robottens sekvensstrategi til at fungere (altså få sat de forskellige dele sammen til et helt program)
• Kigge på Bluetooth-kommunikation (som vi ikke nåede i dag)
• Kigge på repræsentationen af robottens input på computeren  

Afsluttende projekt, 2. dag

Date: 15. December 2010
Duration of activity: 3 hours
Group members participating: Heine Stokholm, Michael Vilhelmsen og Mads Møller Jensen

Dagens mål:

• Konstruere en bane, der senere skal mappes af robotten
• Lave et PID-system så robotten kan dreje præcist.
• Afgøre næste mål

Plan

• Finde mål og redskaber til at lave banen med
• Komme op med et simpelt banedesign
• Bygge selve banen
• Implementere et PID-system, jvf. artiklen PID_Controller_For_Lego_Mindstorms_Robots

Banen

Vi har besluttet at konstruere vores egne bane moduler. Vi har valgt at beholde de fire forskellige slags moduler, som findes i LEGO. Dvs. En lige vej, et sving, et t-kryds og et kryds. Vi gik væk fra LEGO-elementerne, da disse både var for små og i grøn og grå som lyssensoren læser næsten ens. Vi har i stedet valgt at lave modulerne i 30x30 cm format, og bruge gaffatape til at markere vejene med.

Måden vi har lavet banen på er ved først at tegne banen på et stykke papir i et mindre format. Derefter tegnede vi samme bane op i rigtig størrelse på vores plade, og til sidst markerede vi de tegnede streger op med gaffatape. På den måde har vi fået en god størrelse bane, som passer til vores robot, hvor vi samtidig kan skelne stregerne, da disse er sorte på hvidt underlag.

Den første bane vi har lavet har vi holdt helt simpel, men vi overvejer at udvide den, når vi kommer længere frem i projektet. F.eks. har vores nuværende bane intet kryds. 

PID-systemet

Vi har forsøgt at lave et PID-system, jvf. det vi lavede til en LineFollower-opgave. Vi havde nogle problemer med at få det til at virke, generelt fordi det var svært at omskrive et program som følger en linje til at finde en kompasværdi. Grunden, til at vi lavede PID-systemet i første omgang, var at robotten overstyrede hen til den kompasværdi, vi ønskede, den skulle stå på. Den fik for meget motorkraft og nåede ikke at stoppe før vi var forbi den værdi vi ønskede. Med PID-systemet havde vi på et tidspunkt også det problem, motorene fik for lidt kraft til at kunne dreje robotten det sidste stykke hen til værdien. Samtidig havde vi igen lidt problemer med magnetisk interferens fra computere i lokalet.

PID-systemet virker stadig ikke helt optimalt, og vi er nødt til at bruge noget mere tid på at forbedre det yderligere, da hele projektet afhænger meget af, at robotten kan dreje meget præcist. Vi har allerede brugt meget tid på systemet, men vi er nødt at investere mere i det, da det er så vigtigt. 

Vi har overvejet to alternativer, hvis ikke vi får PID-systemet til at virke:

1. At dreje uden PID-system ved at sætte farten helt ned. Dette vil kunne forhåbentlig gøre at robotten ikke overstyrer, men samtidig vil det gøre den meget ineffektiv
2. At bruge tacocounteren til at tælle omdrejninger på hjulet i stedet for at bruge kompasset. Dette er dog ikke så præcist, som at benytte kompasset, så det er kun som sidste udvej, at vi overvejer dette. 

Næste gang:

Næste gang vil vi:

• Arbejde videre med PID-systemet
• Kigge mere på Bluetooth kommunikationen 
• Begynde at kigge på repræsentationen af det som robotten mapper

Det er opgaver, som minder meget om dem vi har kigget på i dag, men vi arbejder allerede videre i morgen, så vi forhåbentlig snart kan få robotten til at køre på banen.

Afsluttende projekt, 1. dag

Date: 2. December 2010
Duration of activity: 7 hours
Group members participating: Heine Stokholm, Michael Vilhelmsen og Mads Møller Jensen



Dagens mål:

• Få hul igennem mellem robot og computer via Bluetooth
• Få en idé om hvordan vi skal lave en bane, som vi kan arbejde med.
• Overveje robottens konstruktion: Hvordan skal den se ud? Hvor mange sensorer skal den have?
• Prøve at præcisere de forskellige delmål, vi gerne vil nå i løbet af projektet.

Plan:

• For at få hul igennem mellem robot og computer, vil vi forsøge at køre nogle af de eksempler, der følger med leJos-pakken. På den måde håber vi hurtigt at få en form for kommunikation
• Til banen vil vi prøve forskellige alternativer, og teste dem lyssensoren. På den måde kan vi lave en bane/brikker, som forhåbentlig er optimal(e) til projektet.
• Til robottens konstruktion vil vi diskutere forskellige varianter, der kunne være mulige. Dette punkt bliver meget afhængigt af banens konstruktion, og vi laver formentlig de to punkter i sammenspil.
• Til sidst vil vi forsøge at beskrive de tanker, vi har med projektet, bl.a. gennem eksempler.

Bluetooth og andre tests

I starten havde vi lidt problemer med at få computeren og robotten til at "tale" sammen over Bluetooth, fordi vi troede, at vi skulle oprette en forbindelse på samme måde, som man gør med andre Bluetooth-enheder. Vi kunne godt få kontakt fra computer til robot, men den anden vej skrev robotten, at "Connection was unsuccessful". Vi fortsatte alligevel, og uploaded en klasse fra leJos sample-mappen til robotten, og en til computeren. Så kørte vi programmerne og fik hul igennem. Programmet var meget simpelt og gik ud på at computeren sendte nogle talværdier til robotten, som skrev disse på LCD-displayet, og returnerede det negerede tal tilbage til computeren. Dette virkede uden problemer og uden yderligere modifikation. 

Programmet vi brugte på PC'en kan ses her

Programmet vi brugte på robotten kan ses her

Ydermere testede vi kompasset, som vi havde fået som ekstra sensor. Kompasset vil hjælpe os meget i forbindelse med mapping, men mere om det senere.

Programmet vi brugte til at teste kompasset kan ses her   

Vi lavede flere forskellige forsøg med kompasset, da vi opdagede, at det var en smule ustabilt. Vi lavede et program, hvor robotten skulle dreje 90 grader og så stoppe, og gennem denne proces kunne vi se, at det, robotten gennem kompasset troede var 90 grader, ikke var det hver gang. Vi kiggede efter råd i leJos API'en, og fandt en kalibreringsfunktion. Vi forsøgte at køre kalibreringen, men vi havde stadig præcisionsproblemer. Vores teori var, at kompasset blev forstyret af computernes magnetfelter. Når nu kompasset skulle placeres 20 cm væk fra motor og NXT, ville det også give mening at den kunne blive forstyret af computerne.

Vi testede herefter kompasset væk fra alle forstyrrende elementer og kalibrerede den igen. Herefter virkede kompasset perfekt! Vi havde dog stadig lidt problemer med at få robotten til at dreje de 90 grader, men vi ved allerede nu, at vi med et PID-system kan klare det problem. Problemet er at robotten drejer lidt for kraftigt, men med et PID-system vil den dreje mindre og mindre skarpt efterhånden som den nærmer sig den ønskede kompasværdi. 

Banen

Vi har snakket meget frem og tilbage om hvordan vi skal konstruere en bane. Opgaveforslaget lægger op til at banen konstrueres med LEGO's egne bane moduler. Disse har imidlertid flere ulemper. For det første sagde Ole, at vi kunne prøve dem indtil vi gav op. Problemet er at LEGO modulerne er grønne og grå i farverne, og disse farver er meget svære for lyssensoren at skelne i mellem. Derudover synes vi, at bane modulerne er en anelse for små. Selv med en "lille" robot ville det være svært at dreje 360 grader uden at noget af robotten kørte ud af banen. 

Derfor valgte vi at konstruere vores egne banemoduler ud fra LEGOs idé. Vi vil altså beholde de fire forskellige slags moduler, men forstørre dem (til 30x30 cm) og så lave dem i sort/hvid. Ved at beholde modulidéen håber vi, at vores mapping bliver nemmere og mere overskuelig, da robotten kun skal kende de fire forskellige moduler, og så være i stand til at sætte dem sammen til et fuldendt kort.

Vi har denne plade at gå ud fra:

Tanken er, at vi med Gaffatape konstruerer modulerne på den hvide plade. Vi har overvejet at lave to baner, så vi kan vise at vores robot kan genkende forskellige baner, men det er kun på idé-stadiet. Forhåbentlig kan vores program mappe så overbevisende, at det ikke er nødvendigt at vise det to gange. 

Robotten

Vi tog udgangspunkt i vores almindelige LineFollower robot

På denne tilføjede vi et kompas, som vi monterede ca. 20 cm. fra motorerne og NXT'en.

Robotten er ca. 20 cm. bred, og vores "vej-moduler" er 30x30cm. Derfor var vi nødt til at forlænge lyssensoren, så denne kan opfange de mørke områder på vores moduler, når hjulene står midt på modulet. Lyssensoren er herved blevet hævet lidt mere, da stangen vi forlængede var vinklet lidt opad. Heldigvis har det ikke forstyrret vores læsninger betydeligt (endnu).

Vi har (midst) 2 måder at konstruere vores robot på - enten lader vi den være som den er nu, og drejer 360 grader når den står midt på et modul. Under denne rotation skal robotten så notere sig hvor på modulet den kan køre ud og hvor den ikke kan.

Den anden måde er at montere yderligere 2 lyssensorer, så den kan måle alle 3 potentielle veje på én gang. Herved ville vi slippe for det tab af præcission vi har når vi drejer 360 grader.

Vi arbejder videre med robotten med én lyssensor - sammen med kompasset er det håbet at vi kan få foretaget præcise 90 graders drejninger uden at komme ud af kurs.

Plan fremover

I dag har været rigtig god, og vi har nået mange ting. Vi har et kompas, der virker, og en robotkonstruktion der burde kunne klare at mappe en bane. Derudover har vi en idé til hvordan banen skal konstrueres. 

Næste gang gang vil vi:

• Lave banen
• Lave et PID-system, så vi får fuld kontrol over robotten. 
• Arbejde videre med Bluetooth kommunikationen. Vi vil få robotten til at sende nogle af de værdier, den læser gennem kompasset videre til computeren, og se om vi muligvis kan arbejde med robotten, mens den er i gang.

Så håber vi at være på vej mod at få robotten til at mappe en bane, hvilket er vores første store delmål. Herefter er planen, at vi tilføjer nogle ekstra egenskaber, som vi vil præcisere nærmere, når første delmål er nået.

Week 11 in LEGOlab

Date: 25. November

Duration of activity: 3 hours

Groups members participating: Heine Stokholm, Michael Vilhelmsen and Mads Møller Jensen

Dagens opgaver:

• Finde 3 ideer til endcourse project og vælge hvilken vi har lyst til at arbejde med.

Robot pong

hardware:

3 nxt
4 tryksensorer
computer / mobil til styring af paddles

tanker om projektet:

lave et pong spil hvor bolden og de to paddles er robotter. Bolden skal køre automatisk og selv beregne sin rotation når den rammer en væg.
Paddles skal være styret af brugeren.
En af de store problemer ville være noget mapping til bolden så man kunne regne ud hvor meget bolden skulle dreje ved at ramme væggen.
Samtidig skulle vi også finde en måde at styre paddles.
Derudover vil der være visse mekaniske problemer, i forbindelse med at konstruere en bold der altid har de fire trykflader til at vende den rigtige vej.
Det sværeste vil altså være i bolden. De 2 paddles kan laves relativt nemt. Men bolden vil indeholde al "hjernen".
Og der vil som sagt være visse mekaniske udfordringer ved at lave bolden såvel.

Vi ville forvente at kunne præsentere et (vel)fungerende setup, hvor man kan spille pong vha. robotterne.

road mapping

hardware:
1 (2) nxt
lego veje
computer til grafen
kompas sensor

tanker om projektet:

Der skal laves noget præcist mapping så robotten kan navigere rundt på banen.
Der skal laves kommunikation til computeren så den kan fremvise grafen.
Når grafen er lavet skal vi kunne sige på computeren hvor robotten skal køre hen,
og så skal den kunne køre den korteste rute derhen.
Evt. få 2 nxt'er til at samarbejde om at kortlægge banen, og samtidig undgå at køre ind i hinanden.
Herved vil der sandsynligvis også indgå et element af behaviour based systems.
Det sværeste i dette projekt forventer vi vil være 2 dele:
1) At få lavet et ordentligt map
2) At få konstrueret mappet internt i robotten på en måde som giver mening, rent visuelt, når det overføres til en PC.

Vi ville forvente at kunne præsentere en robot der er i stand til at mappe en given bane, og danne et billede af banen
på en PC. Sandsynligvis ville vi også kunne gøre robotten i stand til at navigere hurtigst muligt mellem 2 punkter på banen.

sex bots

hardware:

5+ NXT
2x5+ motorer
Ikke nødvendigvis nogen sensorer, afhængig af hvordan robotterne skal køre rundt

Tanker om projektet:

I dette projekt vil vi kunne anvende behaviour based systemer.
Robotterne skal have flere forskellige lag af opførsler og disse skal kunne udvekles med andre robotter.
Der skal også indgå en måde at kommunikere på mellem robotterne, eks. enten via IR eller Bluetooth.
Det sværeste i dette projekt forventer vi er at få robotterne til at kommunikere.
Selve deres adfærd burde ikke volde de store problemer.

Vi ville forvente at kunne præsentere et setup hvor 5+ robotter kører rundt og udveksler adfærd.
Eksempelvis kunne 1 af robotterne starte med en adfærd der var at sige en lyd hvert 5. sekund.
Når alle 5+ robotter siger en lyd hvert 5. sekund vil vi betragte projektet som en succes.

Konklussion

Vi har valgt projektet "Road Mapping".
Grunden til dette er at vi synes det er meget interessant at arbejde med autonome robotter, der er i stand til at udføre tasks af sig selv.
Mapping er også et interessant emne, da det ikke er trivielt. Desuden synes vi det er rart at have noget visuelt at arbejde med/udfra,
og hertil virker det meget fornuftigt, at lave et billede af banen på PC'en vha. robotten.

Helt konkret vil vi forsøge at lave følgende:

En NXT robot med 2 motorer, der kører rundt på en tilfældig bane konstrueret at LEGO-road moduller (eller tilsvarende sort/hvide papir-udgaver).
Robotten skal holde styr på hvor den har kørt og hvor den ikke har kørt, og den skal stoppe når den har kortlagt hele banen.
Herefter skal banen sendes via Bluetooth til en PC, og ud fra dette input skal vi på PC'en kunne konstruere et kort over banen.
Dernæst vil vi vælge 2 stedet på banen, (evt. givet ved 2 moduler) og vores robot skal så kunne finde den korteste vej mellem disse 2,
og køre denne vej, hvis den startes i et af stederne.

Planen for arbejdet er i første omgang at mødes næste torsdag, og planlægge hvornår vi skal arbejde videre ;)