Zwei Algorithmen für digitalen PID

[Dummbernd (Gast)]

Abend,

ich beschäftige mich gerade mit digitalen PID-Reglern. Ich bin mit 
einiger Mühe in der Lage, den Stellalgorithmus aus der 
Differenzengleichung für den zeitdiskreten PID herzuleiten.

Nun findet man jedoch als Codeumsetzung meist zwei Möglichkeiten für den 
digitalen PID.

Zum einen die Möglichkeit, die sich an die PID-Differenzengleichung 
anlehnt: (http://www.rn-wissen.de/index.php/Regelungstechnik#PID-Regler)

e = w - x;        
esum = esum + e;        
y = Kp*e + Ki*Ta*esum + Kd/Ta*(e – ealt);
ealt = e;

(schön einfach und übersichtlich)

Oder durch andere Herleitung (siehe 
Beitrag "Re: PID- Regler")

e = w - x;        
y = yalt + q0*e + q1*ealt + q2*ealt2;  
ealt2 = ealt;
ealt = e;
yalt = y;

wobei
q0=Kp+Ki*Ta+Kd/Ta
q1=-Kp-2*Kd/Ta
q2=Kd/Ta
(irgendwie komplexer)


Ich verstehe nicht den Unterschied zwischen beiden Algorithmen. Gibt es 
da Vor/Nachteile?
Kann ich jetzt einfach sagen, ich nehmen Lösung 1 da diese einfacher und 
kürzer ist? Welche Nachteile nehme ich dafür in Kauf?

[Achim M. (minifloat)]

Der Integrator im Regler ist an 2 verschiedenen Stellen "verbaut":

Bei Variante 1 steckt er in
esum = esum + e;
ealt = e;

Bei Variante 2 steckt er in
y = yalt + (...);
yalt = y;

Die beiden "ealt"s bei Variante 2 bringen nur eine zusätzliche 
Verzögerung.
Ich zeichne mir das mal als Blockschaltbild auf.
mfg mf

[Dummbernd (Gast)]

hai

ich bin's noch mal


Ich glaube, ich bin ein wenig weiter :/

Bei dem ersten Algorithmus handelt es sich offenbar um einen sog. 
"PID-Stellungsalgorithmus". Die Stellgröße y ist dabei dann immer 
absolut.
An Rechenaufwand braucht man 4 MULs, 2 ADDs, 1 SUB und eine DIV.
Relativ hoher Aufwand pro Zyklus also.

Der zweite Algo wird bei den Amis als PID-Geschwindigkeits-Algo 
bezeichnet.
Das Ding arbeitet rekursiv über die letzten beiden Regelabweichungen. 
Die Stellgröße wird außerdem immer relativ zur vorigen (yalt) gebildet.
Wind-Up-Effekt kann wegen fehlender Variable zur Summenbildung nicht 
auftreten. Der Algo ist recht flott, da nur 3 ADDs und 3MULs mit festen 
Konstanten nötig sind.


Konstruktive Kritik meiner Behauptung sind erwünscht.

[Achim M. (minifloat)]

Ist das nicht eigentlich so gemeint:
y = Kp*e + Ki*Ta*esum + (Kd/Ta)*(e - ealt);

(Kd/Ta) ist eine Konstante, das wird ein guter Compiler erkennen und 
entsprechend umsetzen.

Ich komme auf folgendes:
   Erster Algo:
   5ADD, 3MUL (Ob + oder - immer noch eine Addition)

   Zweiter Algo:
   4ADD, 3MUL
   Allerdings wird hier ein Wert mehr zwischengespeichert.

mfg mf

[Dominik W. (Gast)]

Guten Morgen

Ich arbeite ebenfalls diesen Software-PID in meinen AVR zu packen.

Wie schauts aus, hattet ihr schon den gewünschten Erfolg? Könnt ihr 
Tipps bei der Umsetzung geben?

Benutzt ihr 8- oder 16-bit Register?

Gruss