Projekt - 3

Dato:

15-01-2010

Antal timer brugt:
5 timer

Deltagende personer:
Kim Munk Petersen, Andreas Koefoed-Hansen og Tim Rasmussen

Målet:

1. Forstå hvordan robotten kan balancere.
   
2. Forstå principperne i en PID-controller.
   
3. Justere PID-controlleren så den passer til vores robot.

Planen:
Som vi beskrev i sidste blogindlæg, havde vi fundet noget kode som virkede rigtigt godt. Vi prøvede at bruge principperne i koden og lave vores egen gyroskopklasse og selv om den gav mere korrekte data, så fungerede den ikke sammen med PID controlleren. Koden indeholder en række parameter, hvoraf værdierne K_psi, K_phi, K_psidot og K_phidot er fundet ud fra en avanceret simulation i MathWorks Matlab og vi vil prøve at finde ud af hvordan disse har indflydelse på balanceevnen. Vi vil derfor forsøge at optimere værdierne Kp, Ki og Kd, således at robotten ikke overshooter så meget som nu.

Processen:

- Hvordan balancerer robotten?
Stevens kode benytter fire input, to fra gyroskopet og to fra motorerne. De to fra gyroskopet er robottens vinkel ift. lodret og dens vinkelhastighed. De to fra motorerne er TachoCount og RotationSpeed, altså også vinkel og vinkelahstighed. Brugen af flere sensorerne til at give en ønsket reaktion er beskrevet af Fred Martin som Sensor Fusion[1] der bruges for at give et mere komplet billede af situationen. Outputtet der læses fra gyroskopet er en vinkelhastighed. I gyroskopsensorklassen sættes vinklen fra starten til at være nul og opdateres løbende over tid ved at beregne ændringerne til vinklen ud fra vinkelhastighederne og addere disse til vinklen som beskrevet i første projekt-blogindlæg. Både vinkel og vinkelhastighed fra gyroskopet og input fra motorerne bliver benyttet til at beregne en error-værdi som senere bliver brugt i PID controlleren. De forskellige input er vægtet forskelligt ved at bruge de førnævte værdier: K_psi, K_phi, K_psidot og K_phidot. Vinklen fra gyroskopet har klart den højeste vægtning (ca. 50x større end fra motoren).

PID controlleren bruges til at beregne hvor meget power der skal gives til motorerne, dette er beskrevet i Fred Martin som Reactive Control[2] da motorerne reagerer direkte efter det input der kommer fra sensorerne. Det er dog ikke en ”ren” form for Reactive Control da der bliver set på fortiden i det både offsettet på gyroskopet bliver beregnet løbende og integral ledet i PID controlleren også ser på tidligere observationer, men disse led ikke spiller den store rolle i forhold til den endelige værdi.

- Generelt om PID controllers [3][4]:
En PID controller benytter tre forskellige parametre, Proportional (Kp), Integral (Ki) og Differential (Kd). Fælles for disse er at de tager udgangspunkt i en error værdi, der angiver hvor langt man er fra den ønskede tilstand.



- Proportional-regulering
Dette led i reguleringen består af en faktor der bare multipliceres på error. Reguleringen bliver foretaget på baggrund af størrelsen af den error der er, altså hvor langt man er fra den ønskede tilstand. Ulempen ved brug af kun denne simple form for regulering består i, at hvis man ønsker et meget hurtigt reagerende system, så er en stor konstant nødvendig. Dette kan det resultere i overshooting og efterfølgende oscillation.

- Integral-regulering
For at kunne kompensere for og lære af ændringer der sker over længere tid kan dette led benyttes. Den grundlæggende ide er, at tidligere error-værdier summeres. For at disse værdier ikke frit udvikler sig, er det ofte nødvendigt at indføre en form for dæmpning af værdien, eller indsætte en reel grænse for hvad den kan antage. Effekten af integral-leddet kan være at mindre fejl bliver udlignet, men også at systemet reagerer forholdsvis langsomt før netop en sum får en betydning.

- Differentiale-regulering
Ideen med dette led er at prøve at forudsige hvad eksempelvis den hastighed, hvormed systemet ændre sig, får af betydning. Dette kan bruges til at afdæmpe systemet ved meget pludselige ændringer og dermed bedre undgå overshooting. Dette led udregnes typisk ved at kigge på ændringen mellem de seneste to samples.


- PID controlleren i vores projekt:
Værdierne for PID controlleren var allerede sat i koden, så vores mål var at optimere disse og se hvad der skete når vi ændrede på dem. Vi valgte at gå systematisk frem og først ændre på Kp, derefter Ki og til sidst Kd. Herefter prøvede vi at ændre på flere på én gang, idet den optimale konfiguration ikke kan findes ved at skrue på en parameter af gangen. For at kunne se virkningen af ændringerne bedre valgte vi at logge de vinkler der blev udregnet af gyroskopklassen. Både værdierne fra getAngle() og getAngleVelocity() og blev gemt ved hjælp af vores egen datalogger-klasse, som bygger på den datalogger der var tilgængelig tidligere i kurset i forbindelse med Lydsensoren [5]. Den udleverede datalogger er kun i stand til at gemme heltal. Vi har udviddet den således at den også kan gemme alle de andre gængse datatyper, dvs. byte, short, long, float, double, char og String. Derudover kan vores datalogger også automatisk skrive timestamps på målingerne, tilføje forklarende overskrifter i toppen og inkrementelt forøge filnavnet med et tal således at tidligere log-filer ikke overskrives, men nye oprettes.

Ændringerne på PID controlleren kunne ses ved at plotte værdierne i et diagram, og i nogle tests kunne det også direkte ses på opførslen af robotten. Vi har taget nogle af resultaterne ud og vist dem herunder. Alle nedenstående grafer viser robottens udsving fra den blev startet og 10 sekunder frem.

Originale værdier:

P = 1.2, I = 0.25, D = 0.1

Dette er værdierne som Steven fandt frem til, grafen ser meget jævn ud og oscillation er hverken sigende eller faldende. Opførelsen af robotten afspejlede også dette da den stod stille og balancerede uden at bevæge sig meget.


P Increase:

P = 1.4, I = 0.25, D = 0.1

Vi prøvede i denne test at skrue lidt op for P for at se om det ville give en mere stabil balance, men som det ses ud fra grafen at der var en mere ujævn balancering og mere oscillation.


P Decrease:

P = 1.0, I = 0.25, D = 0.1

Denne graf blev dannet da vi prøvede at skrue ned for P hvilket resulterede i at der kom en del overshoot i starten og meget udsving, efterhånden blev balanceringen mere stabil.

I Decrease:

P = 1.2, I = 0.15, D = 0.1
Udsvingene på i vinkelen er ikke ret stor i begyndelsen, men fordi der ikke bliver taget meget hensyn til de tidligere målinger bygger der sig en fejl op og det resulterer i at udsvingene vokser med tiden.

I Increase:

P = 1.2, I = 0.35, D = 0.1
Overshooted i dette eksperiment var meget stort og på grafen kan det også ses hvordan vinkelen svinger meget frem og tilbage. Robottens balanceevne var ikke særlig god og den væltede kort efter at vi havde foretaget målingerne.

D Increase:

P = 1.2, I = 0.25, D = 0.2

Ved at ændre på D kom der ikke de store ændringer i starten men der blev gradvist overshootet lidt ad gangen indtil der var en meget ustabil balancering.


Koden med PID controlleren ligger i BalanceControl klassen og er som følgende:

double Psi = gyro.getAngle();
double PsiDot = gyro.getAngleVelocity();
           
// ctrl.tiltAngle() is used to drive the robot forwards and backwards
double Phi = motors.getAngle() - ctrl.tiltAngle();
double PhiDot = motors.getAngleVelocity();
// Proportional Error
double error = Psi * K_psi + Phi * K_phi + PsiDot * K_psidot + PhiDot * K_phidot;
// Integral Error
int_error += error;
// Derivative Error
double deriv_error = error - prev_error;
prev_error = error;
// Power sent to the motors
double pw = error * Kp + deriv_error * Kd + int_error * Ki;

Konklusion:
Efter at have eksperimenteret med de forskellige parametre i PID controlleren fandt vi ud af at de originale værdier var dem der virkede bedst. Det har dog ikke været spildt arbejde da vi ved at teste andre værdier har kunnet se at den teori der er bag PID controlleren stemmer nogenlunde overens med hvordan det virker i praksis. Vi har fået en bedre forståelse af hvordan en PID controller kan benyttes til at abstrahere fra fejlmålinger og derved give et bedre resultat.Vi vil de næste gange arbejde på at få oprettet en Bluetoothforbindelse mellem computeren og NXT'en og dermed få sendt input til robotten.

Referencer:

1. Sensor Fusion.Chapter 5, pp. 207 of Fred G. Martin, Robotic Explorations: A Hands-on Introduction to Engineering, Prentice Hall, 2001.  
   
2. Reactive Control.Chapter 5, pp. 192-193 of Fred G. Martin, Robotic Explorations: A Hands-on Introduction to Engineering, Prentice Hall, 2001. 
3. PID Controller, http://en.wikipedia.org/wiki/PID_controller
4. PID Control.Chapter 5, pp. 179-190 of Fred G. Martin, Robotic Explorations: A Hands-on Introduction to Engineering, Prentice Hall, 2001. 
   
5. NXT Programming, Lesson 3, http://legolab.daimi.au.dk/DigitalControl.dir/NXT/Lesson3.dir/Lesson.html