suche fertiger PID-regler

Das wird dir höchstwahrscheinlich nicht viel bringen, kommt darauf an 
was für Eingangs- und Ausgangssignale du hast. PWM? Analog? Wieviel bit? 
AD/DA-Wandler per I²c, SPI, Parallel?

Mit der Berechnung der Stellgröße könnte ich aushelfen, den Rest musst 
du schon selbstanpassen.

In diesem Fall mit Resourcen 'geaast' (double-Variablen), Abtastung alle 
20ms

1

double PID_Berechnung (double x, double w)

2

{

3

e = w - x;  // Regelabweichung ermitteln

4

y = yalt + (Kp*e) + (I*ealt) + (D*ealt2);  // Reglergleichung

5

if (y > 1023)    // Stellgröße auf 0..1023 begrenzen (10 bit PWM)

6

 {

7

  y = 1023;

8

 }

9

if (y < 1)

10

 {

11

  y = 0;

12

 }

13

ealt2 = ealt;    // Regelabweichungs-Historie zuweisen

14

ealt = e;

15

yalt = y;    // Stellgrößen-Historie zuweisen

16

17

return y;    // Stellgröße zurückgeben

18

}

e => Regelabweichung
w => Sollwert
x => Istwert
y => Stellgröße
Kp => Proportionalverstärkung
I => Integralverstärkung
D => Differentialverstärkung

Der Schnipsel ist für die Ausgabe über 10-bit-PWM geschrieben und 
funktioniert prima.

ealt und ealt2 werden mit den jeweiligen Differential- und 
Integralverstärkungen multipliziert, das Ganze bezieht sich jeweils nur 
auf die letzten zwei Messwerte.
Der D-Anteil ist auch niemals 0, nur wenn die Regelabweichung über 
längere Zeit genau null ist.

D*ealt2 wird niemals null, nur wenn der Sollwert null ist. Wie soll denn 
ein Motor/Lüfter/Pumpe o.Ä. laufen, wenn keine Ansteuerung erfolgt? Eine 
gewisse Stellgröße braucht jedes Stellglied, um einen Sollwert zu 
halten.

Die Stellgröße y setzt sich ja aus den drei Anteilen zusammen.

Ach ja: die Quelle von dat janze:
http://www.roboternetz.de/wissen/index.php/Regelungstechnik#Digitaler_Regler

Ich denke, wenn man das Thema PID Regler nicht gerafft hat, sollte man's 
eh seinlassen. Und wenn man's gerafft hat, sind die paar Zeilen in ein 
paar Minuten geschrieben.

Und ich denke, dass jeder einen PID-Regler einsetzen kann, ganz gleich 
ob er ihn verstanden hat oder nicht. Ist wie beim Autofahren, das kann 
auch jeder...

@ Starter:
Ich habe mir elaubt, den Code vom obigen Antwortposting anzupassen:

1

double PID_Berechnung (double x, double w)

2

{

3

e = w - x;         // aktuelle Regelabweichung bestimmen

4

esum = esum + e;   // Summe der Regelabweichung aktualisieren

5

y = (Kp*e)+(I*Ta*esum)+(D*((e-ealt))/Ta);  // Reglergleichung

6

ealt = e;          // Regelabweichung für nächste Abtastung merken

7

if (y > 1023)      // Stellgröße auf 0..1023 begrenzen (10 bit PWM)

8

  {

9

    y = 1023;

10

  }

11

if (y < 1)

12

  {

13

    y = 0;

14

  }

15

return y;          // Stellgröße zurückgeben

16

}

mit
Ta = 0.02 (20ms)
Kp = 18
I  = 16
D  = 0.05

regelt mein Lüfter sauber, schnell und ruhig, ohne großes Zappeln der 
Stellgröße.
Ich bitte um Korrektur, falls ich auf die Schnelle was vergessen habe!

Für die Regelung einer Lüfterdrehzahl kann man auf den D-Anteil locker 
verzichten, das brauchts nur bei dynamischen Vorgängen wie Positions- 
oder Lageregelung mit Motoren.

@ JÜrgen G.:
Stimmt schon mit den doubles. Habe ich von oben übernommen, da es nicht 
auf die Rechenleistung ankommt (16MHz, mega32) kann ich die schon 
nehmen. Bei int muss man die Überläufe abfangen (vermeiden), da kommt 
dann auch noch Rechenleistung dazu.
Was meinst du mit Anti-Windup-Maßnahme? Kannst du das Beispiel damit 
ausstatten?

@ Dieter Werner:
Haste Recht. Ich habe grade einen Lüfter mit Reflexkoppler da gehabt, 
darum habe ich den benutzt. Den D-Anteil kann man problemlos weglassen.

OK, hab selber mal gegoogelt. Wird wohl auf AWR (Anti-Windup-Reset) 
'rauslaufen. Werde mich mal dransetzen.
Hier noch ein recht übersichtlicher Link zum Thema:
http://www.energietechnik.fh-dortmund.de/personen/walter/walter/mikrocontroller_infos/Regler_und_Optimierung.htm

Wie sollte man dann den Sourcecode ändern, um den I-Anteil einzufrieren?

Na, sobald das Ausgangssignal, aka Stellgroesse, an das Limit kommt, 
wird nicht mehr weiter integriert.

1

double PID_Berechnung (double x, double w)

2

{

3

e = w - x;         // aktuelle Regelabweichung bestimmen

4

esum = esum + e;   // Summe der Regelabweichung aktualisieren

5

y = (Kp*e)+(I*Ta*esum)+(D*((e-ealt))/Ta);  // Reglergleichung

6

ealt = e;          // Regelabweichung für nächste Abtastung merken

7

if (y > 1023)      // Stellgröße auf 0..1023 begrenzen (10 bit PWM)

8

  {

9

    y = 1023;

10

    Itemp = I;         // I merken

11

    I = 0;             // nicht weiter integrieren

12

    return y;          // Stellgröße zurückgeben

13

}

14

  }

15

else

16

  {

17

    I = Itemp;

18

  }

19

if (y < 1)

20

  {

21

    y = 0;

22

    Itemp = I;         // I merken

23

    I = 0;             // nicht weiter integrieren

24

    return y;          // Stellgröße zurückgeben

25

}

26

  }

27

else

28

  {

29

    I = Itemp;

30

  }

31

return y;          // Stellgröße zurückgeben

32

}

Itemp muss zu Anfang natürlich mit dem Wert von I initialisiert werden.
Sollte das Problem beheben, oder?

Upps.. so natürlich nicht!

1

double PID_Berechnung (double x, double w)

2

{

3

e = w - x;         // aktuelle Regelabweichung bestimmen

4

esum = esum + e;   // Summe der Regelabweichung aktualisieren

5

y = (Kp*e)+(I*Ta*esum)+(D*((e-ealt))/Ta);  // Reglergleichung

6

ealt = e;          // Regelabweichung für nächste Abtastung merken

7

if (y > 1023)      // Stellgröße auf 0..1023 begrenzen (10 bit PWM)

8

  {

9

    y = 1023;

10

    I = 0;             // nicht weiter integrieren

11

    return y;          // Stellgröße zurückgeben

12

}

13

  }

14

else

15

  {

16

    I = Itemp;

17

  }

18

if (y < 1)

19

  {

20

    y = 0;

21

    I = 0;             // nicht weiter integrieren

22

    return y;          // Stellgröße zurückgeben

23

}

24

  }

25

else

26

  {

27

    I = Itemp;

28

  }

29

return y;          // Stellgröße zurückgeben

30

}

So wir deher 'n Schuh draus. ;)

OK, hab's getestet. So geht's nicht. Werde weitertesten.

Ok, ich habe hier die Aufintegration der Regelabweichung bei 
übersteuerten Stellglied eingefroren. Fonktioniert auch soweit ...

1

double PID_Berechnung (double x, double w)

2

{    

3

e = w - x;                  // aktuelle Regelabweichung bestimmen

4

if ((y <= 1023)&&(y >= 0))

5

  {

6

    esum = esum + e;        // Summe der Regelabweichung aktualisieren  

7

  }

8

y = (Kp*e)+(I*Ta*esum)+(D*((e-ealt))/Ta);  // Reglergleichung

9

ealt = e;                   // Regelabweichung für nächste Abtastung merken

10

if (y > 1023)               // Stellgröße auf 0..1023 begrenzen (10 bit PWM)

11

  {

12

    y = 1023;

13

  }

14

    if (y < 1)

15

  {

16

    y = 0;

17

  }

18

return y;

19

}

Die einzelnen Anteile getrennt zu berechnen ist sicher die bessere 
Lösung.

So jetzt mal ein positives Ergebnis:

1

double PID_Berechnung (double x, double w)

2

{    

3

e = w - x;                  // aktuelle Regelabweichung bestimmen

4

if ((y < 1023)&&(y > 0))

5

  {

6

    esum = esum + e;        // Summe der Regelabweichung aktualisieren  

7

  }

8

y = (Kp*e)+(I*Ta*esum)+(D*((e-ealt))/Ta);  // Reglergleichung

9

ealt = e;                   // Regelabweichung für nächste Abtastung merken

10

if (y > 1023)               // Stellgröße auf 0..1023 begrenzen (10 bit PWM)

11

  {

12

    y = 1023;

13

  }

14

    if (y < 1)

15

  {

16

    y = 0;

17

  }

18

return y;

19

}

Hab's getestet, funktioniert prima! :)

Ich habe bei übersteuertem Stellglied nur esum eingefroren. Dadurch kann 
nicht mehr integriert werden. Die anderen Parameter bleiben davon 
unberührt.
Ich hab's auf meiner Hardware laufen, der Unterschied zu vorher ist 
Welten besser! :)

>Die Datentypen gefallen mir nicht
Jo, mir auch nicht! ;) Das kommt als nächstes.

Zur Visualisierung mal den Unterschied des Regelverhaltens.
In diesem Bild OHNE anti-Windup.

Grün => Stellgröße
Rot => Sollwert (70 Hz)
Weiß => Istwert

Der Lüfter gibt eine Frequenz von 0 bis max 140 Hz zurück

Und hier MIT anti-Windup.

Achso, zur Erklärung:
Ich ahbe den Lüfter für ca. 2s angehalten und wieder losgelassen. Im 
Bild mit anti-Windup sieht man, dass der 1. Überschwinger deutlich 
kleiner ist. Ohne Anti-Windup wird er umso größer, je länger ich den 
Lüfter anhalte.

Sieht doch schon besser aus ;)
nur glaube ich dass

1

if ((integ <= 1023)&&(integ >= 0))

nicht funtioniert, da sonst die nachfolgende Begrenzung der Stellgöße 
diese Bedingung immer erfüllt.
Besser wäre

1

if ((integ < 1023)&&(integ > 0))

oder hast du's schon ausprobiert?

> (unsigned int) y = prop + integ + diff;    // Ausgangsstellgröße

Sorry, müsste das nicht

y = (unsigned int)(prop + integ + diff);

heissen ?

Ich lerne gerne dazu....

Gruß Sven

>Ich probiere nicht aus, weil ich keinen µC grad bei der Hand hab
Aber ich! :)

Mit größer-gleich geht's nicht. Mit größer schon.

Das Problem ist, wie erkenne ich ob der Ausgang übersteuert ist (z.B. 
1028) oder ob er bei genau 1023 ist. Das geht nur, wenn ich ein Bit 
abziehe. Darum der 'größer', bzw. 'kleiner'-Verleich anstatt >=, bzw <=.

>Wie iniitierst du denn das ganze?
Kp = 18;
I = 12;
D = 0;
w = 50;
Den ganzen Rest mit 0.

Also esum ist ja das Element, das integriert wird. Wenn ich dieses 
einfriere, also den Wert bei überschreiten der Übersteuergrenze (0 und 
1023) halte (nicht 0 setzen!), dann bleibt esum außerhalb der 
Übersteuergrenzen auf einem konstanten Wert und der Regler 'fängt' sich 
bei Rückkehr in den Regelbereich an dem Punkt wieder, an dem das 
Stellglied übersteuert wurde. Von dort arbeitet er wieder korrekt.
Wenn du integ auf 0 setzt fängt das ganze furchtbar an zu schwingen, 
sobald einmal die Übersteuergrenze überschritten war.

Jo, den D-Anteil brauche ich beim Lüfter nicht, das macht nur die 
Stellgröße 'hibbelig'.

>und dann ab in die Codesammlung ^^

Da isser schon :-)

Gute Idee, lass' dich nicht aufhalten ! ;)