verbesserung Drehzahlregelung I- zu PI-, PID-Regler ???

[Lieber_Gott]

Grüß Gott,

Ich hab nach längerem Suchen leider noch keinen Thread dazu im Forum gefunden, obwohl ich davon ausgehe das sich bestimmt schon Leute hier im Forum damit beschäftigt haben. Falls jemand einen Thread kennt wäre der link dazu schon sehr hilfreich.

Es geht um die verbesserung der Drehzahlregelung, von einem I-Regler zu einem PI oder PID Regler, so wie es auch schon in der RP6RobotBaseLib.c steht.
(Nochmal kurze zwischenfrage) Warum ist das eigendlich ein .c File und keine Header datei ???

Anhand der C-Implementierung aus RN-Wissen, könnte man meinen der I regler müsste nur um den Summanden (Kp * e) erweitert werden.

I-Regler:

esum = esum + e
y = Ki * Ta * esum


PI-Regler:

esum = esum + e
y = Kp * e + Ki * Ta * esum

nur allein schonmal die Stelle im Programmcode zu finden gestaltet sich für mich sehr schwer.

ist das diese Stelle
// Left motor speed control:
und
// Right motor speed control:

Wo im Programmcode ist genau der Sollwert und was ist der vom Drehgeber gemessene Ist-Wert ?

Die Regelabweichung ist error_left und error_right, oder lieg ich da falsch ?
Und welche Variable ist die Stellgröße ?


Ich bin leider noch ziemlich am anfang und blick bei der ganzen sache noch kaum durch.

Eine allgemeine Frage zur Regelung hab ich noch.
Es müssen ja 2 Regelungen gleichzeitig stattfinden, einmal die Regelung der gewünschten Geschwindigkeit mleft_des_speed ; mright_des_speed;
und beim Geradeausfahren müssen beide Ketten so geregelt werden das sie gleichschnell laufen.
Ist das im Programmcode auch so realisiert, oder funktioniert das anders ?

Es würde mich wirklich sehr freuen wenn mir jemand weiterhelfen könnte.

Herzlichen Dank schon mal

beste Grüße

Thomas

[SlyD]

Hallo Thomas,


Hab leider nicht viel Zeit, daher kurz:


> Falls jemand einen Thread kennt wäre der link dazu schon sehr hilfreich.

Fällt mir jetzt so direkt keiner ein. Kann aber sein das das Thema schonmal diskutiert wurde... wenn dann ists aber länger her.


> Wo im Programmcode ist genau der Sollwert

mright_des_speed und mleft_des_speed sind die Sollwerte. des=desired
Also zu deutsch: gewünschte geschwindigkeit link/rechts.


> und was ist der vom Drehgeber gemessene Ist-Wert ?

mleft_speed und mright_speed


> Die Regelabweichung ist error_left und error_right

Ja.

> Und welche Variable ist die Stellgröße?

mleft_power / mright_power = der PWM Wert.
Der wird aber nochmal langsam nachgeregelt!
(im Timer Interrupt - ab Zeile 1560 - Soft PWM Adjustment - erst hier wird der richtige PWM Wert eingestellt)


> beim Geradeausfahren müssen beide Ketten so geregelt werden das sie gleichschnell laufen.
> Ist das im Programmcode auch so realisiert, oder funktioniert das anders ?

Das ist NICHT mit dem Code in der RP6Lib implementiert worden.
Die Geschwindigkeit beider Ketten wird unabhängig voneinander eingeregelt. Das hat schon relativ gut funktioniert (im Vergleich zu Robotern mit normalem zweirad Antrieb... ).

Hier müsste man einen dritten Regler einführen, der die beiden Geschwindigkeiten aneinander angleicht.

Das geht alles (hab ich auch selbst schonmal gemacht - bei einem anderen Roboter) - aber Du solltest erstmal die Motorregelung der RP6Library ansich verstanden haben bevor Du Dich an sowas heranwagst...

MfG,
SlyD

[Lieber_Gott]

Vielen Dank für die schnelle Antwort !
Das hilft mir auf alle fälle schon mal weiter, ich werde den Programmcode mal schritt für schritt zerlegen und versuchen alle Teile zu verstehen.

schöne Grüße

Thomas

[Lieber_Gott]

Ich hab jetzt mal einen Teil des Programmcodes mit Komentaren versehen:



// Left motor speed control: Zeile 660 (Implementierter Regler)

//Verwendete Größen und Variablen
#define MC_LEFT_IMAX 420 //was bedeutet das ???
#define MC_LEFT_IMIN -420
#define MC_RIGHT_IMAX 420
#define MC_RIGHT_IMIN -420


int16_t right_i; // esum (Summe der Regelabweichung)
int16_t left_i;
int16_t mleft_power; // y (Stellgröße für den Motor)
int16_t mright_power;

// int16_t error_left // e (Regelabweichung unten definiert)

uint16_t mleft_des_speed; // w (vorgegebener Sollwert)
uint16_t mright_des_speed;

volatile uint16_t mleft_speed; // x (gemessener Istwert)
volatile uint16_t mright_speed;

// Left motor speed control:
int16_t error_left = mleft_des_speed - mleft_speed; // e = w - x
left_i = left_i + error_left; // esum = esum + e
if(left_i > MC_LEFT_IMAX) left_i = MC_LEFT_IMAX; // Begrenzung esum[-420;420]
if(left_i < MC_LEFT_IMIN) left_i = MC_LEFT_IMIN;
if(mleft_speed == 0 && mleft_des_speed == 0) // wenn x und w 0 dann esum auch 0
left_i = 0;
mleft_power = left_i / 2; // y = esum / 2 oder y=esum * 0,5
if(mleft_power > 210) mleft_power = 210; // begrenzung von y [0;210]
if(mleft_power < 0) mleft_power = 0;


was bedeutet MC_LEFT_IMAX ?
was bedeutet volatile ?

in kürze zusammengefasst:
e=w-x
esum = esum + e
y=0.5*esum

das sieht schon stark nach dem I regler aus dem RN wiki aus:

esum = esum + e
y = Ki * Ta * esum

was ich nicht verstehe ist die letzte Zeile. Wo kommt in dem Programmcode Ta (abtastzeit ?) vor ???
oder wie ist die letzte zeile genau zu verstehen ?

wäre nett wenn einer mal kurz drüber schaut ob das so stimmt.

herzliche Grüße

Thomas

[SlyD]

Hallo,

MC_LEFT_IMAX
MC = MotorControl,
Left = Links ;)
I = Integrator,
MAX = Maximum


Der I Wert muss ja begrenzt werden - hier auf 420 da 420 / 2 = 210 ist (PWM maximalwert)
Wird ganz zum Schluss dann nochmal begrenzt - das kann eigentlich sogar wegfallen (für den pos. MAX Wert) - ist nur drin falls man doch mal noch andere Terme ergänzt...
(ja genau - DU brauchst die Begrenzung am Schluss dann wieder ;) )


volatile = flag für den Compiler, Variable die in einer Interrupt Routine jederzeit verändert werden kann.


/ 2 ist für die 8-Bit CPU sehr einfach zu berechnen (shift um 1 nach rechts). Man kann da natürlich auch mit anderen Werten experimentieren und das ganze entweder weiter mit Integer Werten berechnen und einfach skalieren (*1000 (auf long Variablen ändern) dann rechnen hinterher wieder durch 1000 teilen - ganz grob gesagt)
Oder doch floatingpoint verwenden - dann kannst Du auch anfangen und die normalen Formeln mit ki, kp und kd zu benutzen.

Der Code in der RP6 Bibliothek ist da an dieser Stelle schon etwas "optimiert" damit das nicht viel Rechenzeit kostet und mehr für das Anwenderprogramm übrig bleibt.
Der MEGA32 kann natürlich auch komplexere floating point Berechnungen durchführen... je nachdem wie komplex macht es dann aber ggf. sinn den Controller mit dem I2C Slave Programm nur noch als Motorcontroller (und ACS usw.) zu verwenden und alles andere einem zweiten Controller auf einem Erweiterungsmodul zu überlassen.

MfG,
SlyD

[BolleAlex]

Hi, wir sind gerade dabei den Regler des RP6 zu verbessern.

Hierfür brauchen wir einen zyklischen Aufruf der "task_RP6System"

Kann uns vielleicht jemand sagen, wie wir einen zyklischen Aufruf implementieren können?

Danke schonmal für euere Hilfe!

Mit freundlichen Grüßen


Bolle und Alex

[RP6conrad]

Das lauft ja in der "tast_motion_control". Diese wird normalerweise jeden 200 mSek interruptgesteurt aufgerufen. Siehe mal die library an. In diesen task kan der PID-Regler implementiert werden.

[BolleAlex]

Danke für die Hilfe :-)

Wenn die FKT. sowieso schon regelmäßig aufgerufen wird ist das super!

[dal]

Hallo,

wollte mal hören ob einer von euch einen funktionierenden PID-Regler geschrieben und getestet hat?

Ich beschäftige mich auch grade mit dieser Problematik und bin mir nicht ganz sicher wie ich die Faktoren ki, kd wählen soll. Auch mit Ta bin ich nicht ganz sicher.

Wäre schön wenn einer mal seinen Lösung zum Vergleich zeigen könnte.

Gruß

Daniel

[oberallgeier]

... wollte mal hören ob einer von euch einen funktionierenden PID-Regler geschrieben und getestet hat ...Aber klar - schau mal hier. (https://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=450795&sid=3d765e99ea936c12c27198324a772b9b#450795) Ist ein bisschen sehr ausführlich geworden, alles Notwendige ist im Thread beschrieben (und eben mehr dazu auch noch - must ja nicht alles lesen) - auch auf den Seiten davor. Es gibt auch Codestückchen dazu, Du findest meine Ergebnisse zur Sprungantwort und ich glaube auch ein bisschen was zum Berechnen meiner Regelungsparameter. Mein Regler läuft recht gut, auch wenn ich noch am verbessern bin *ggg*.

Eine sehr gute Erläuterung mit Beispielen gibt es seit langem hier. (http://www.rn-wissen.de/index.php/Regelungstechnik#PID-Regler) Die entsprechenden Einstellarbeiten sind z.B. da beschrieben. (http://www.rn-wissen.de/index.php/Regelungstechnik#Dimensionierung_nach_Einstellrege ln)