PID regelaar in C

hallo allen.

Ik ben opzoek naar een duidelijk programma voorbeeld in de taal C van een eenvoudige PID regelaar. Al eerder heb ik gezocht naar wiskundige voorbeelden, maar dit is lastig om te zetten naar C code.
Deze moet in de toekomst gaan lopen in een PIC.

Robbert

Op zich is het helemaal niet zo moeilijk; de fout optellen bij een integraal, de vorige fout opslaan, en dan de som bepalen van de p-gain keer de huidige fout, de i-gain keer de integraal, en de d-gain keer het verschil tussen de laatste opgeslagen fout en de huidige fout.

[Bericht gewijzigd door SparkyGSX op (99%)]

hoe de basis van een PID regelaar werkt is mij duidelijk. maar de berekening zijn mij niet duidelijk.

Robbert

leuk, leerzaam en lekker:
http://www.vandelogt.nl/htm/regelen_pid.htm

Geen C maar in IEC61131-3 ST.
Dat lijkt me wel om te zetten. Deze bijvoorbeeld iedere seconde, of iedere 10 seconden uitvoeren, afhankelijk van je proces.

		
ProcesVal_D := ProcesVal + ( ProcesVal - ProcesValLast ) * Derivative;
ProcesValLast := ProcesVal;
Err := SetVal - ProcesVal_D;
IF direct THEN Err := 0 - Err; END_IF
 
ControllerOut_temp := Err * Gain + Feedback;
IF ControllerOut_temp > 100 THEN ControllerOut_temp := 100; END_IF
IF ControllerOut_temp < 0 THEN ControllerOut_temp := 0; END_IF
 
ControllerOut := ControllerOut_temp;
 
Feedback := Feedback + ( Controllerout - Feedback ) * ResetRate;

Deze is zo simpel dat ik hem ook rechtstreeks in step7 heb omgezet. Werkt perfekt op de sealbalken van een inpakmachine.

is dit alles? bij mijn weten liggen er vrij complexe berekeningen achter een PID regelaqaar. deze zie ik hier nergens terug?

Ook zie ik geen functie waar die in zou kunnen zitten?
als ik kijk naar dit pdf:
http://www.vandelogt.nl/datasheets/pid_controller_calculus_v303.pdf

is er aardig wat programmeer werk nodig voor zo iets?

Robbert

de afleiding is vrij moeilijk (hfstk 2), maar als je dat gedaan hebt, kun je het geheel met 3 vermenigvuldigingen maken. de formule is Eq(uation)01, waarna je naar eq08 toewerkt.

de truc is het integrerende deel om te zetten in het snelheidsalgoritme, waardoor je alleen nog maar je vorige waarde nodig hebt. met een type c (hfstk 3) is het ook nog eens mogelijk om de PID onafhankelijk van setpointwijzigingen te maken.

Dhr van de Logt is docent aan de HTS en weet waar hij het over heeft.

(dit is geloof ik ook de basis van mn dicataat geweest als ik het zo zie:P)

Artikel "PID without a PHD", met grafieken en uitleg van P, PI, PD en PID controllers + C code

http://www.embedded.com/2000/0010/0010feat3.htm

Zo spannend is het niet. Kijk ook even naar de post van SparkyGSX.
Vroeger hadden we PID's die helemaal zonder "complexe berekeningen" functioneerden, pneumatisch. (nog steeds trouwens)

nog een, in de simpelste vorm:


previous_error = 0
integral = 0 
start:
  error = setpoint - actual_position
  integral = integral + (error*dt)
  derivative = (error - previous_error)/dt
  output = (Kp*error) + (Ki*integral) + (Kd*derivative)
  previous_error = error
  wait(dt)
  goto start

Het word pas spannend als je hem wil auto tunen.
Zoek op Ziegler-Nichols en op Cohen-Coon

[Bericht gewijzigd door GJ_ op (36%)]

@GJ_
laat daar nou net mn vak over gaan, auto-tunen:P

http://www.sauter-controls.com/fileadmin/ebooks/catalogue/en/

hoofdstuk 6, p65.07, heb zo nooit in handen gehad, maar wel met veel verwondering in zitten bladeren.

Atmel heeft een application note voor een PID op een AVR(AVR221).

Dit is de documentatie er over:
http://www.atmel.com/dyn/resources/prod_documents/doc2558.pdf

Hier moet je even zoeken naar de Application note 221 daar kan je zelfs de ZIP file met code in c downloaden.
http://www.atmel.com/dyn/Products/app_notes.asp?family_id=607

Op 4 juni 2010 12:49:24 schreef Robbertbd:
is dit alles? bij mijn weten liggen er vrij complexe berekeningen achter een PID regelaqaar. deze zie ik hier nergens terug?

Ook zie ik geen functie waar die in zou kunnen zitten?
als ik kijk naar dit pdf:
http://www.vandelogt.nl/datasheets/pid_controller_calculus_v303.pdf

is er aardig wat programmeer werk nodig voor zo iets?

Robbert

Het algorithme voor een PI(D) regelaar stelt opzich niet veel voor. Het probleem zit em in het bepalen van de variabelen, daar zijn die berekeningen voor bedoeld.

Ik ben zelf bezig geweest met een motorfader, daar kwam ik allerlei andere problemen tegen zoals:

- Motor begint pas bij 60% / 70% PWM te lopen. Wat gebeurd er met de berekende PWM-waarde? Die gaan schalen over de overgebleve 30% / 40%?

- Wat gebeurd er met de berekening bij overshoot? Opnieuw starten of door laten rekenen?
- Berekening van de I-waarde heb ik nooit begrepen. Het enige wat die doet is groter worden en had steeds meer invloed op de uitgestuurde PWM-waarde. Mij lijkt dat die I-waarde op den duur ook kleiner moet worden, zodra de eindwaarde dichter in de buurt is.

- Hoe bereken ik de variabelen nu goed uit. Sampletijd van het uitvoeren van de meting en opnieuw aansturen is volgens mij van belang, de aanlooptijd en benodigde tijd om af te remmen is volgens mij van belang. Dit zie ik gedeeltelijk in wat voorbeelden op internet terug, maar nergens is het naar mijn idee duidelijk uitgelegd.

Op de site http://www.vandelogt.nl/htm/regelen_pid.htm staat veel nuttige info, maar ook veel wat alleen maar voor verwarring zorgt. Bijvoorbeeld, wat moet je nu met zo'n berekening:
tau - tau/3 = 16573 - 6599 <=> (2/3) * tau = 9974 <=> tau = 14961 seconden.
En zo zijn er nog wel meer onduidelijke dingen.

Daarnaast ben ik geen enkel voorbeeld tegen gekomen wat gaat over een snelle positieregeling. De motorfader die ik gebruik is in staat om in minder dan een halve seconde van de ene naar de nadere kant te gaan. Alle voorbeelden die ik tot nu toe heb gevonden zijn regelprocessen die 1x in de 5min. ofzo worden berekend om een tank water oid. te verwarmen.

Het project ligt al een jaar in de kast, wil het graag nog een keer afronden maar met de kennis wat betreft PID-regelaars waar ik nu over beschik gaat dat niet lukken. Mocht iemand nog goede ideeen hebben, dan ben ik, naast de TS, zeer geinteresseerd :).

Op 4 juni 2010 12:49:24 schreef Robbertbd:
is dit alles? bij mijn weten liggen er vrij complexe berekeningen achter een PID regelaqaar. deze zie ik hier nergens terug?

De basis van een PID regelaar is simpel en kan met de eenvoudige formules die hierboven geschreven zijn worden geprogrammeerd.

In de praktijk* zie je dat je met de eenvoudige implementatie nogal eens tegen (wiskundige) problemen aanloopt: direct differentieren levert ruis op (afrondingsfoute, discrete tijd), integratoren kunnen overflowen, beperkt aantal significante cijfers in floatingpoint getallen, etc.
Als je dit soort problemen wilt voorkomen, ga je de PID regelaar op een andere manier programmeren die een stuk moeilijker wordt. In plaats van te differentieren en integreren wordt er bijvoorbeeld vaak gefilterd. Indien er hele hoge nauwkeurigheid is vereis of wanneer je sampletijd beperkt is kom je zelfs correcties tegen om meetvertragingen te compenseren en wordt er met intersamples gewerkt.

Ofwel: de basis is inderdaad super simpel.... maar de implementatie in code kun je zo ingewikkeld maken als je wilt. Zelfs wanneer je uitgaat van zoiets als een basis PID regelaar zonder auto-tuning.

* mijn praktijkervaring komt uit de hoek van zeer nauwkeurige pick&place machines, waferhandling en haptische simulatoren.

Als een integrator overflowt, heeft de programmeur zijn werk niet goed gedaan (onvoldoende dynamisch bereik van de variabele), of de schaalfactoren voor de in- en uitgang zijn slecht gekozen.

Een ander probleem is een integrator wind-up; dit wordt veroorzaakt door een uitgang (actuator) die verzadigd. In veel gevallen mag dit gewoon nooit gebeuren; in situaties waar het wel kan gebeuren, moet je daar speciale maatregelen voor treffen.

Bij het differentiëren heb je inderdaad snel last van sampleruis; dit kan onderdrukt worden door de ingang van de D-regelaar door een low-pass filter te halen.

In veel gevallen, zoals bij het regelen van aandrijvingen, kan het zinvol zijn om ook de tweede afgeleide te gebruiken in de regelaar.

Het inregelen van een PID regelaar is echt een vak apart; wiskunde is leuk, maar wordt in de praktijk alleen gebruikt als je een relatief eenvoudig proces hebt, en echt het onderste uit de kan wil hebben. De meeste regelaars worden op gevoel (en ervaring!) ingeregeld.

[Bericht gewijzigd door SparkyGSX op (15%)]

Heren, bedankt voor al deze informatie.

ik ga met deze info aan het experimenteren en wanneer er resultaat is laat ik dit uiteraard weten.

MvG Robbert

p.s. excuus voor de late reactie.

Nog even een reactie hierop.

Ik heb de pid regelaar op een machine geintegreerd zoals sparkygsx het omschreef in z'n eerste post (hetzelfde als in de application note van atmel)

Dit werkte bij mij nog niet goed. Ik kon de gewenste regelsnelheid niet halen en wanneer ik dit probeerde dan begon de machine te oscilleren.

Nu wil ik de type c snelheids pid integreren.

Mijn vraag is of een snelheids pid beter kan werken dan een positie pid ? en /of wat jullie ervaring hiermee is?