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