pid controller voor schoolproject

[maurits Profiel Privébericht]

Hallo,

Ik heb nog geen ervaring in stuurtechniek. Voor school moet ik nu een opwarmcyclus genereren met Arduino + breadboard. De code is gegeven, die hoef ik niet zelf te schrijven. Door de K-factoren te manipuleren wordt verschillende uitvoer gegenereerd in serial monitor. De gegevens van de opwarmsessies transporteer ik naar ecxel en van elke invoer maak ik een grafiek.

De opdracht is om mbv manipulatie van de 3 K-factoren in de excel-grafiek het optimum te simuleren voor de respectievelijke opwarmcyclus. Er is een voorbeeld-excel erbij verstrekt van een simulatie (incl de K-factoren) van een technische veer.

Ik heb nog 2 andere pid-excelsimulaties bekeken. Maar de manier waarop de K-factoren daar werken op de gegevens verschilt in mijn begripsniveau per excelvoorbeeld dermate veel dat ik er niet uit kan opmaken hoe de K-factoren toe te passen in mijn eigen opdracht. Waar ik op vast loop is

a) De opwarmcycli blijken in de grafiek niet zichbaar te verschillen. Zijn mijn waarden in de code te laag?
b) Hoe moet de invoer in excel worden bewerkt zodat de K-factoren de grafieklijn beinvloeden?

Ik heb een kolom in mijn excels toegevoegt met de afwijking tussen de gemeten temperatuur en setpoint. Ik heb een kolom toegevoegd met het verschil tussen opvolgende afwijkingen. En ik heb K-factoren ingevoerd. Het gaat dan zeker nog niet werken besef ik, maar op dat punt begin ik reeds het spoor bijster te raken. Ik zoek geen oplossing maar wel een beetje hulp in het leerproces?

In de code verander ik de achtereenvolgens de waarden voor Ki en Kd. Uploaden van extensie xlsr en pdf gaat niet. De grafiek uploaden gaat ook niet. Is dit correct?

cpp code

const float Kp = 70;             // Waarde voor de proportionele versterking.
const float Ki = 0;
const float Kd = 0;
int integraal = 0;
int afgeleide = 0;
const int dt = 500;
const int heaterPin          = 3;              // Uitgang voor het stuursignaal naar de verwarming.
const int analogSensor       = A0;             // Analoge ingang voor het sensorsignaal.
const int potentiometer      = A1;             // Analoge ingang voor het gewenste waarde signaal.

float setPoint               = 0;              // Variabele voor degewenste waarde, bereik 0 - 50.
float error                  = 0;              // Error signaal, verschil tussen gewenste en gemeten waarde.
float oude_error = 0;
int sensorValue              = 0;              // Waarde gelezen uit de analoge ingang A0
float sensorValue_mV         = 0;              // Signaal van de sensor in mV
float sensorValue_V          = 0;              // Signaal van de sensor in V
float temp                   = 0;              // Berekende temperatuur in graden Celcius 0 - 50 graden.
float power                  = 0;              // Berekende waarde voor het uitgangssignaal, bereik 0 - 50.
byte pwm                     = 0;              // PWM output value.
unsigned long startTime      = 0;              // Systeemtijd bij de start van het programma.
unsigned long time           = 0;              // De actuele tijd vanaf de start van het programma.

void setup() {
  // Start de seriële communicatie:
  analogReference(DEFAULT);
  Serial.begin(9600);
  Serial.println();                                    // Schrijf een lege regel omdat de eerste regel soms willekeurige tekens bevat.
  Serial.println("Time\tSetPoint\tPWM\tTemp");         // Koppen boven de kolommen van waarden in de monitor.
  pinMode(heaterPin, OUTPUT);                          // Stel de heater Pin in als uitgang.
  startTime = millis();                                // Leg de starttijd vast.
}

void loop() {
  time           = millis() - startTime;                                          // Bereken de actuele tijd vanaf begin programma.
  sensorValue    = analogRead(analogSensor);                                      // Lees de analogSensor waarde van de analoge ingang
  sensorValue_mV = map(sensorValue, 0, 1023, 0, 5000.0);                          // Schaal dit naar een bereik in 0 tot 5000 mV
  sensorValue_V  = sensorValue_mV / 1000.0;                                       // Reken om in Volts
  temp           = (sensorValue_mV - 400.0) / 19.53;                              // Bereken de temperatuur: sensor gevoeligheid 19.5 mV / deg.C, offset 400 mV
  setPoint       = map(analogRead(potentiometer), 0 , 1023, 0, 5000.0) / 100.0;   // Lees het setpoitsignaal, schaal het naar 50 degrees vol bereik
  error          = setPoint - temp;                                               // De regelformule: berekening van regelafwijking,
  integraal = integraal + error * (dt / 1000);
  afgeleide = (error - oude_error) / (dt / 1000);
  power          = Kp * error + Ki * integraal + Kd * afgeleide;                  // berekening van de uitgangswaarde
  pwm            = byte(constrain((power * 5), 0 , 255));                         // Bereken de PWM waarde en begrens tussen 0 en 255 en zet om naar type byte.
  analogWrite(heaterPin, pwm);                                                    // Zet de PWM waarde op de uitgang, heater pin
  Serial.print(time); Serial.print("\t");
  Serial.print(setPoint);    Serial.print("\t");
  Serial.print(pwm / 5)   ;    Serial.print("\t");
  Serial.println(temp);
  delay(dt);
}

[Koepel Profiel Privébericht]

Het is maar een eenvoudig forum. Je kunt een klein plaatje toevoegen en misschien nog een paar bestanden.
De FAQ is daar niet duidelijk over: http://arduinoforum.nl/faq.php#f9r0
Ik gebruik soms http://nl.tinypic.com om een groter plaatje toe te voegen. Dat plaats ik dan tussen [ img ] en [ /img ].

Mijn complimenten voor degene die de code schreef. Het is heel kort, doet wat het doen moet, en met voldoende commentaar er bij.

Kun je een simulatie van de verwarming maken ? Dan kun je sneller een paar dingen proberen.

In de Arduino omgeving wordt vaak deze PID gebruikt: http://playground.arduino.cc/Code/PIDLibrary met deze Autotune: http://playground.arduino.cc/Code/PIDAutotuneLibrary. Ik kan helaas niet zo snel zien of de berekeningen overeen komen.

[maurits Profiel Privébericht]

Oke, ik heb vijf excels op mijn online gezet met lees- en schrijfrechten voor gebruiker "arduino".
Het adres is https://vdrive.dds.nl/amdewolff/

Gebruiker "arduino" kan naar binnen met het wachtwoord "1234" (zonder "leestekens" invoeren).
Als de toegang toch mocht haperen ga ik daar wat aan doen natuurlijk.

[Koepel Profiel Privébericht]

Ik weet niet precies waar ik naar zit te kijken. De "pid.xls" ziet er goed uit, met een klein beetje overshoot. De "opdracht-4c-Kp" is heel traag. De andere twee bestanden zijn alleen maar heel veel getallen en de simulatie doet het niet in mijn LibreOffice.

Deze website vond ik om PID te proberen: http://www.rentanadviser.com/en/pid-fuzzy-logic/pid-fuzzy-logic.aspx
Rechtsboven staat "Plot Realtime (P,I,PI,PID)" en "Plot Rapid (P,I,PI,PID)". Dat lijken me de twee handigste mogelijkheden.
Begin met dt=0.1, R(t)=10.0, Kp=0.5, Ki=0.5, Kd=0.0
Voeg dan langzaam de Kd een beetje bij, dan zie je dat de uitgang veel sneller naar de waarde gaat, en als Kd te groot is, dan gaat het oscilleren.


Op Wikipedia wordt (in de eerste twee alinea's) duidelijk en kort de PID regelaar uitgelegd: https://nl.wikipedia.org/wiki/PID-regelaar.

Klopt de sketch wel ? Is het zetten van de oude_error misschien er uit verdwenen ? Wat is er nog meer uit verdwenen ?

[shooter Profiel Privébericht]

maak eerst de Kp maar eens het dubbele, en als het nog stabiel is dan weer verdubbelen.
tot het instabiel wordt.
dan de Kd en vervolgens de Ki.
met de arduino maak je dus een stel grafieken en stel je de waardes in.
kijk eens naar ziegler nichols
het is de bedoeling om de regeling zo snel mogelijk op de instelwaarde te krijgen zonder instabiliteit en afhankelijk van de eisen ook met weinig of geen overshoot.
bedenk dat het proces niet netjes lineair is en 2 tijden kent voor verwarmen en koelen. Dat is ook gelijk het grootste probleem met een PID regeling die is niet slim zoals fuzzy wel is.
maar hou het simpel en maak je grafieken zorg dat je de tijd meeneemt in de grafiek.
hou de setpoints klein, dat is sneller.

[maurits Profiel Privébericht]

Bedankt voor de reacties. Ik zal de waarde verhogen. Wat gebeurt er eerst: instabiliteit of een smeltend breadbord? Geintje.

Wat wordt er precies instabiel en hoe kan ik dat zien? Ik heb de seriele monitor openstaan tijdens het verwarmingsproces en volg wat er gebeurt. Wat er gebeurt is dat de temperatuur opkruipt naar de setpoint en dan vlak eronder blijft hangen. Instellen van de Ki en Kd in Arduino verandert dat niet; de temperatuur blijft hangen vlak onder de setpoint. Maar misschien gaat ook dit veranderen als ik de waarde ga opschroeven.

De klassicale instructies stellen dat wanneer de temperatuur de waarde van de setpoint heeft benaderd, de output van de serialmonitor met een handmatige copy/past wordt ingevoerd in een excelbestand. Daar ga je dan simuleren met die gegevens. Dit houdt in dat de simulatie geheel plaatsvindt buitenom de opwarming via Arduino. Misschien kan het wel beter op een andere manier, maar zo zijn de oefeninstructies voor deze opdracht nu eenmaal.

Hoe ga ik simuleren? Ik heb de excel met de technische veer goed bestudeerd (staat in mijn Vdrive). Daar worden in de verschillende kolommen de effecten nagebootst van P I en D op de loskomende veerenergie. Nu heb ik geen nut voor versnelling en zwaartekracht, maar in die overige kolommen worden het proportionele, integrale en differentiele effect nagebootst. Dat heb ik vervolgens ook gedaan in de excel van mijn opdracht-4c in de kolommen rechts van de temperatuur. Door die kolommen met elkaar een berekeningshandeling uit laten voeren zou dit effect ook daar op moeten treden. Maar dan moet het wel doorgekoppeld worden naar mijn temperatuurkolom. En naar die kolom luistert mijn grafiek weer. Ervan uitgaande dat ik op de goede weg ben, weet ik nog niet hoe ik die koppeling maak. Hoe doe ik dat op een juiste manier?

Mvg maurits

[ruud-572 Profiel Privébericht]

Klopt de sketch wel ? Is het zetten van de oude_error misschien er uit verdwenen ? Wat is er nog meer uit verdwenen ?

Inderdaad, er ontbreekt code!

[shooter Profiel Privébericht]

je programma is eigenlijk een analoge regelaar, en moet je dus ook zo zien.
Het is de bedoeling dat de pwm een stabiel getal wordt na verloop van tijd.
de integraal zorgt ervoor dat het setpoint wordt bereikt.
als je de K hoog maakt, en de temperatuur springt een klein beetje dan gaat de PWM helemaal swingen van 0 naar 255, en dus instabiel.
de Differentiaal zorgt er ook nog eens voor dat de PWM snel hoger wordt om de verstoring er zo snel mogelijk opgelost wordt.

omdat je de I op 0 hebt staan zal er altijd een afwijking blijven bestaan tussen setpoint en gemeten waarde.

dat is allemaal regeltheorie.
In de excels zie je dus een simulatie, maar die is heel erg snel, en dus zul je met jouw verwarming veel geduld moeten hebben.

[maurits Profiel Privébericht]

Wanneer ik alleen de P-waarde hanteer (I+D=0) en deze stapsgewijs opvoer krijg ik geen overshoot bij het bereiken van setpoint temperatuur. De zelfuitvlakking (PWM=0) neemt wel toe bij het opvoeren van de P-waarde. Maw, signaal blijft langer liggen op de de setpoint en gaat dan blijvend oscilleren. Hoe is het verband tussen een hogere P-waarde en een langduriger PWM=0 te verklaren?

Wanneer ik PID inschakel en daar respectievelijke waarden aan toeken, lijkt het erop dat een I=3 en D=15 het meest uitgevlakte signaal geven. Dwe p-waarde heeft minder tot geen bepalende invloed lijkt het. Typisch is wel weer dat het met mijn extreme P-waarde van 2500 langer duurt om de setpoint te bereiken dan met een P-waarde van 1200 onder vergelijkbare omstandigheden

Ik heb 2 excel files met resultaten gezet op https://vdrive.dds.nl/amdewolff/

In opdracht-4c-Kp-Ki-Kd op de sheet Kp=1200; Ki=5; Kd=15, geven de instellingen in Arduino de meest egale temperatuurverloop langs de setpointlijn. Maar is de temperatuurlijn nog verder vlak te krijgen?

mvg maurits

[maurits Profiel Privébericht]

Ik heb 2 excel files met resultaten gezet op https://vdrive.dds.nl/amdewolff/

mvg maurits

login op Vdrive
username= arduino
passwd= 1234