Probleme mit PID-Regelung (Drehzahl)

[MechMac]

So, die tests werde ich in Kürze an dem "echten" Motor durchführen.
An dem Testmotor, den ich hier auch beschrieben hatte, bin ich zu folgendem Ergebnis gekommen:

Wenn ich I etwas erhöhe wird es besser. Aber D darf ich nicht größer als 0 machen. Dann dreht das Teil völlig am Rad und fängt wie wild an zu schwingen.
Ich hatte folgende Werte
P=0.03 I=0.04 D=0.00

Kann D eigentlich auch negativ sein?


Naja, der "echte" Motor ist viel größer und dreht deutlich langsamer. Da kann ich dann auch mal den Test unter Last machen.

Also irgendwie kommen mir die Werte so "klein" vor.

Aber nochwas:
Output, also das was von der PID-Regelung kommt, ist ein double. Ich übergebe dem Steller aber nur integer. Im Grunde fehlen mir die beiden nachkommastellen, die ja auch "feine" Korrekturen beinhalten.
Als nicht-Mathematik-Mensch fällt mir da nur ein: Den Wert nicht begrenzen von 1500.00-1800.00, sondern von 15.00-18.00 und dann das Ergebnis*100.
Macht das Sinn?
Muss ich mal drüber nächtigen....

[Peter(TOO)]

Naja, der "echte" Motor ist viel größer und dreht deutlich langsamer. Da kann ich dann auch mal den Test unter Last machen.

Also irgendwie kommen mir die Werte so "klein" vor.

Meine Frage ist immer noch die Abtastrate des Istwertes und die Aufrufrate des Reglers?

Wenn du den Regler öfters aufrufst, als gemessen wird, bekommt er zwischen den Messungen immer den selben Wert gefüttert.

Der berechnete P-Anteil bleibt also konstant, weil (Ist-Soll) auch konstant bleibt.

Der D-Anteil rechnet mit (Ist_ALT - Ist_NEU) und kämpft gegen das Schwingen und zu schnelle Änderungen des Stellwerts. Wird er mit einem neuen Its-Wert aufgerufen rechnet er eine Gegenmassnahme. Bei den weiteren Aufrufen, wird sein Anteil dann 0.

Der I-Anteil integriert den Wert (Soll - Ist) Da diese Differenz zwischen den Abtastungen konstant bleibt, erhöht der P-teil bei jedem Aufruf die Stellgrösse, ohne zu bemerken, was die letzte Änderung des Stellwerts ausgerichtet hat.

Wenn du den Ist-Wert alle 2s abtastetest und den Regler alle 100ms aufrufst, hats du für 100ms einen vernünftigen Stellwert. Die nächsten 19 sind dann Schüsse in Blaue.
Das Doofe ist aber, dass der Motor sofort auf eine Änderung des Stellwertes reagiert .....

Die Abtastrate des Ist-Wertes muss also mindestens gleich gross, oder grösser, als die Aufrufzeit des Reglers sein.

Ein Problem ist noch die Konstanz der Abtastrate des Istwerts.
Etwas vereinfacht berechnet der Regler welche Drehzahlveränderung eine Stellwert-Veränderung um z.B. 10% in der Zeit t_A bewirkt.
ist nun aber die Abtastzeit einmal 2s und einmal 1s ändert sich dieser Wert um den Faktor 2!
Alleine dies führt schon zum Schwingen.

Man muss also die Abtastzeit möglichst Konstanz halten oder die reale Zeit zwischen den Abtastungen mit erfassen und im Regler mit verarbeiten. Dadurch wird allerdings die Rechnerei im Regler um einiges aufwändiger.

Aber nochwas:
Output, also das was von der PID-Regelung kommt, ist ein double. Ich übergebe dem Steller aber nur integer. Im Grunde fehlen mir die beiden nachkommastellen, die ja auch "feine" Korrekturen beinhalten.
Als nicht-Mathematik-Mensch fällt mir da nur ein: Den Wert nicht begrenzen von 1500.00-1800.00, sondern von 15.00-18.00 und dann das Ergebnis*100.

Du solltest natürlich schon die maximale Auflösung aus den Stellglied heraus holen!

Wenn dein Stellglied eine Auflösung von 1'000 hat und du skalierst das Ganze auf den Bereich von 0..10 (Integer), kann sich die Stellgrösse nur in 100er-Schritten ändern.
Skalierst du auf 0...1'000 kann sich der Ausgang in 1er-Schritten verstellen.

MfG Peter(TOO)

[HaWe]

Der P-Anteil integriert den Wert (Soll - Ist) Da diese Differenz zwischen den Abtastungen konstant bleibt, erhöht der P-teil bei jedem Aufruf die Stellgrösse, ohne zu bemerken, was die letzte Änderung des Stellwerts ausgerichtet hat.

hier meinst du sicher den I-Anteil (I=Integral=Summe aller bisherigen Fehler),

I vergisst zum Einen nichts (alte Werte werden als Teil der Fehler-Summe ewig mitgeschleppt, wenn sie nicht intern im Algorithmus gedämpft werden), und daher ist I auch sehr träge und reagiert folglich (als Teil aller PID-Parameter im Gesamtzusammenhang) vor allem bei relativem Stillstand der Regelung ("Verrecken kurz vor dem Ziel").
Da die Abtastfrequenz des OP sehr gering ist, wird daher I dermaßen langsam reagieren, dass sich erst nach -zig Sekunden oder gar Minuten der Stellwert ändert, und daher kann man eigentlich hier I von vornherein auf Null lassen: damit wird das Ganze zum PD-Regler, der auch sicher für diese Zwecke ausreicht.

[Peter(TOO)]

hier meinst du sicher den I-Anteil (I=Integral=Summe aller bisherigen Fehler),

Sorry, war ein Typo. Habe es korrigiert, also nicht wundern, weil das Zitat nicht mehr stimmt.

- - - Aktualisiert - - -

ich habe jetzt die Bibliothek nochmals genauer unter die Lupe genommen.

Der Regler rechnet stur alle, Default 200ms, alles durch. Im obigen Fall merkt er aber nicht, dass sich der Ist-Wert nur alle 2s ändert.
Der Regler rechnet also nach 200ms nochmals mit dem alten Ist-Wert und kommt zum Schluss, dass die letzte Änderung des Stellwertes nichts gebracht hat .....

MfG Peter(TOO)

[Urinstein]

Welche Einheiten haben denn deine Kp/Ki/Kd-Faktoren?
Deine Reglereingangsgröße kommt als Drehzahl, also in 1/min, 1/s etc. pp.
Was ist deine Stellgröße? Eine Spannung? Strom? PWM-Tastverhältnis?

Mach dir darüber erstmal Gedanken, dann kann man die Größenordnung der Reglerparameter für gewöhnlich schonmal durch reines Nachdenken abschätzen.
Aus deinem Startpost entnehme ich mal dass du willkürliche Werte für Kp gewählt und dann vervielfacht hast. Bist du bei den anderen Parametern genauso vorgegangen?

Also irgendwie kommen mir die Werte so "klein" vor.

Aber D darf ich nicht größer als 0 machen. Dann dreht das Teil völlig am Rad und fängt wie wild an zu schwingen.

Siehe oben. Ohne Information über die Größenordnung und Einheit der Ein- und Ausgangsgrößen wertlose Informationen.
Vielleicht liegen die idealen Reglerparameter für deinen Anwendungsfall ja bei Kp=0.00001, Ki=0.004, Kd=0.000000003?

[MechMac]

Sorry, war ein Typo. Habe es korrigiert, also nicht wundern, weil das Zitat nicht mehr stimmt.

- - - Aktualisiert - - -

ich habe jetzt die Bibliothek nochmals genauer unter die Lupe genommen.

Der Regler rechnet stur alle, Default 200ms, alles durch. Im obigen Fall merkt er aber nicht, dass sich der Ist-Wert nur alle 2s ändert.
Der Regler rechnet also nach 200ms nochmals mit dem alten Ist-Wert und kommt zum Schluss, dass die letzte Änderung des Stellwertes nichts gebracht hat .....

MfG Peter(TOO)

Das verstehe ich nicht. Eigentlich rechnet er mit myPID.Compute();

Zu den Stellgrößen:
Da ich den Motor mittlerweile direkt an den Arduino-Regler angeschlossen habe und für die PWM die Lib "Servo" verwende, muss ich nun leider Wete von 0-180 angeben.
Wobei 90 die Mitte, also 1500µs darstellt.

ich lasse den PID-Regler für mich verständliche Werte in µs ausgeben:
myPID.SetOutputLimits(1538, 1800);
Die 1538µs sind kurz vor der langsamsten Drehzahl.

Dann mappe ich den ermittelten Wert auf das, was die Servo LIB benötigt:
myservo.write(map(servoval, 1000, 2000, 0, 180));

Welche Einheit oder Größe P, I, und D haben weiß ich nicht. Es sind für mich einheitslose Faktoren.

Mag ich gar nicht, da ich durch diese bekloppte 0-180 Grenze Genauigkeit verliere.
Ich könnte das auch selber machen ohne die Servo LIB, aber dann muss ich mit millis(); arbeiten.
Aber in der Vergangenheit hatte ich immer den Eindruck, das Millis(); und Micros(); abweichungen von mehreren 1/10 sek hat.
Wobei man bei den fertigen libs ja nie so genau weiß, ob da nicht irgend wo nen delay drin ist....Was das dann verursacht.
Ich weiß auch nicht wie das bei UART und I2C in Verbindung mit Millis(); und Micros(); aussieht...Aber ich schweife ab.

Ich hatte zunächst die Drehzahl entweder alle 200000 durchläufe oder alkle 2 Impulse berechnet.
Das hatte den Vorteil, das ich sowohl langsame, als auch schnelle Drehzahlen gut berechnen konnte.
Den PID-Regler habe ich unmittelbar nach der Messung gefüttert.
Das hatte zur folge, das, je schneller der Motor drehte, der PID auch öffter rechnete.

Da ihr aber meintet, zeitliche abtastung wäre besser, habe ich jetzt alle 1000 Zyklen festgelegt.
Damit kann ich drehzahlen unter circa 600 u/min nicht mehr erfassen. Aber ist nicht so schlimm.
Das hat jetzt auch den Nachteil, das ich mir die aktuelle Drehzahl nicht mehr via UART ausgeben kann, da UART nicht mehr funktioniert.
Später wird das mögl. weise noch ein Problem. Ob I2C noch funktioniert...keine Ahnung.

Wenn ich das aber alles ignoriere und so tue als ob die Kommunikation nur in eine Richtung laufen müsste hat es jetzt folgendes ergeben:
D darf ich immer noch nicht >0 setzen. Nach wie vor dreht das Teil komplett am Rad, wenn ich es nur wage.
Ohne I schwingt er etwas, mit I kaum.
In nur 1-2 Sekunden hat er die neue Drehzahl erreicht (welche das ist, k.a. da UART ja nicht mehr funktioniert)
Also im prinzip ist es jetzt wie vorher, nur das ich statt P=0.03, I=0.04 jetzt P=0.02, I=0.03 habe.

Was mir letztendlich komisch vorkommt, wieso darf ich bloß D nicht verwenden....
Ich habe gelesen das ein double auf dem Arduino auch nicht mehr wie 2 Nachkommastellen hat, oder?
Sonst hätte man es ja mit 0.001 versuchen können... Vielleicht ist 0.01 schon der Vorschlaghammer.



------Ergänzung-------
Der Motorsteller ist ein gewöhnlicher Steller aus dem Modellbaubereich.
Er erwartet ein PWM-Signal von etwa 1000-2000 µs
Wobei 1500µs +- ~30 den Totbereich um den Stillstand des Motors darstellen.
>1500 gilt als Vorwärtslauf, <1500 gilt als Rückwärtslauf

[HaWe]

double ist bei Arduino AVRs das selbe wie float, und float hat ca. 6-7 Dezimalstellen Genauigkeit, gemessen ab der 1. signifikanten Stelle ab der letzten führenden Null.
Sie werden bei Arduino Serial nur bei der Ausgabe nie alle angegeben, sondern immer nur 2 Nachkommastellen, es sei denn, du forderst diese Genauigkeit ausdrücklich.
Intern wird aber immer mit allen Stellen gerechnet.


ps,
du kannst die Sample Time definieren mit (wer hätte's gedacht) SetSampleTime(int milliseconds)
https://playground.arduino.cc/Code/P...ySetSampleTime

sie muss also nicht so wie per default bleiben.

[Urinstein]

Das verstehe ich nicht. Eigentlich rechnet er mit myPID.Compute();

Nein!
Deine PID Library rechnet, sofern möglich, mit der eingestellten Taktung. Default sind glaube ich alle 100ms, also 10Hz.
Bei jedem Ausführen der PID.Compute() fragt die Library ab, ob die Berechnung erfolgen soll oder nicht, also ob seit der letzten Berechnung eine Sampletime abgelaufen ist. Daher solltest du PID.Compute unabhängig von der eingestellten Sampletime so oft wie möglich ausführen.

Da ich den Motor mittlerweile direkt an den Arduino-Regler angeschlossen habe und für die PWM die Lib "Servo" verwende, muss ich nun leider Wete von 0-180 angeben.

Die Library hat auch einen Befehl um die Einschaltzeit des PWM-Signals auszugeben statt eines Winkels. Nutze ich immer so.
Der Befehl lautet servo.writeMicroseconds(1500).