Asuro: Linienfolger mit PD-Regler

[waste]

Wenn man nun genau das Gegenteil von dem, was der PT1-Block macht, in den Regler integriert, dann wäre alles wieder in Butter. Das geht mit einem Differenzierglied. Im Bild "D-Anteil.gif" ist der Frequenzgang des Differenzierglieds (rote Kurve) gezeigt, der genau den Frequenzgang des PT1-Blocks (grüne Kurve) kompensiert. Im Regler wird das mit einem D-Anteil realisiert, der eine Zeitkonstante von 120ms hat.

Jetzt wollen wir mal sehen, wie sich das auf den Phasenrand und auf die Sprungantwort ausgewirkt hat. Siehe dazu die Bilder "olg2.gif" und "Sprungantwort2.gif". Na, das sieht doch gut aus! Der Phasenrand ist jetzt 85 Grad und es ist auch noch Raum für eine Erhöhung des P-Anteils. Aber schöner noch ist die Sprungantwort mit D-Anteil (rote Kurve). Zum Vergleich ist auch noch das Einschwingen ohne D-Anteil (grüne Kurve) eingezeichnet.

Im nächsten Beitrag versuchen wir noch am P-Anteil zu drehen.
Bis dann.

Waste

Fortsetzung folgt

[ähM_Key]

Ich störe ja ungern deine genialen Ausführungen, aber es gibt ein kleines Update von RoboSim!

https://www.roboternetz.de/phpBB2/vi...=107941#107941

Grüße; ähM_Key

[waste]

Ah, danke, jetzt sehe ich erst deinen Thread.
Werd es gleich testen.

Gruss Waste

[Sternthaler]

Hallo zusammen,
da ich zum weiteren verfolgen des Threads erst den Keller nach meinen alten Regelungstechnikunterlagen durchsuchen musste, hat's etwas gedauert bis ich den Ausführungen von waste wieder folgen konnte.
Nachdem ich so die Bode- und Zeitdiagramme wieder halbwegs verstehe, habe ich vor allem (über mein geliebtes EXCEL) zugesehen, das auch bei mir ein negativ wirkender D-Anteil stärker wirkt.
Ausserdem hat waste schön dargelegt, das die Regelzeit so um 120 ms betragen wird.
Entsprechend habe ich (schon wieder im EXECL) das Verhältniss von Ti (Nachstellzeit) und Ta (Abtastzeit) darauf angepasst.

waste hat wohl richtig gerechnet.
Die Grafiken im EXECL 'Tabelle2' zeigen im oberen Bild eine von mir in der Strecke erzeugte Störung (und deren Ausreglung). Im unteren Teil kann man auch noch gut sehen, dass die Motorgeschwindigkeiten dafür sehr sanft geregelt werden. Das macht sich auch sehr schön in der recht ruhigen Fahrt vom Asuro bemerkbar.

Klasse dieser Thread!

Schöne Grüße von Sternthaler

ACHTUNG: auch hier ist wieder der rechte Motor mit 50 höher betrieben in MotorSpeed.

[waste]

Fortsetzung:
Der D-Anteil bewirkt ein Vorhalten der Ansteuerung um die Verzögerung in der Regelstrecke auszugleichen. In unserem Fall kennen wir die Zeitkonstante des Antriebs und können dem Regler genau sagen wie er vorhalten muss. Das Vorhalten hat allerdings Grenzen, denn sonst bräuchte man unbegrenzt Power.

Jetzt optimieren wir nochmal den Regler, indem der P-Anteil um den Faktor 3 erhöht wird. Das ist für die Stabilität kein Problem, da genügend Phasenreserve im vorigen Beispiel war. Sehen wir uns dazu die Sprungantwort an (grüne Kurve V(s) im Bild "unbegrenzt.gif"). Das Einschwingen hat sich nochmal um den Faktor 3 verbessert. Achtung, die Zeitskala ist jetzt 0.5s anstatt 2s wie im vorigen Beitrag. Die Optimierung nach dem Bodediagramm könnte man noch weiter ausreizen, aber wie schon angesprochen sind uns da von anderen Seiten her Grenzen gesetzt. Das sieht man in den darüber angeordneten Kurven. Die rote Kurve V(v) bedeutet die Geschwindigkeit und die violette Kurve V(m) die Ansteuerspannung. Man sieht, für diese Beschleunigung bräuchte man kurzzeitig 100V als Ansteuerspannung für den Motor. Die haben wir leider nicht.

Aber wie sieht es in der Realität aus, wenn die Ansteuerung die Befehle des Reglers, auf das was möglich ist, begrenzt. Im Bild "begrenzt.gif" sieht man das Dilemma, das flotte Einschwingen ist wie eine Seifeblase zerplatzt. Und es kommt noch dicker! Wenn man beim Asuro nur die PWM-Ansteuerung für die Regelung verwendet, dann ist der Asuro beim Herunterregeln der Geschwindigkeit im Freilauf. Das liegt an der Ansteuerschaltung. Die Auswirkung ist in Bild "Freilauf.gif" zu sehen. Der Freilauf ist an der abfallenden Spannung (violett) im Bereich 70ms bis 240ms zu sehen. Zu dem Zeitpunkt ist die Ansteuerung hochohmig und es ist die Gegen-EMK des Motors zu sehen. In dem Bereich wird der Asuro nur durch die Reibung gebremst. Die Bremsphase ist dadurch sehr viel länger geworden.

Wie man sieht, ist so eine Dimensionierung eines Reglers noch von Randbedingungen abhängig. Man kann nicht alles mit einer Regelung kompensieren bzw. verbessern. Irgendwo sind durch die Mechanik und Elektronik die Grenzen gesetzt. Um weitere Verbesserungen zu erzielen, muss dort angesetzt werden. Glücklicherweise wird durch den D-Anteil bei Korrekturen immer voll ausgesteuert, so dass man beim Asuro zum Bremsen "BREAK" verwenden kann. Das macht allerdings die Ausführung des Reglers im Programm etwas komplizierter. Notfalls kann auch noch Rückwärts mit einbezogen werden, aber ob das sinnvoll ist, müssen erst noch Praxistests zeigen.

Tipp an Regelschleifenbauer anderer Projekte, womöglich lesen welche mit. Diese Erkenntnisse gelten auch für andere Positions- oder Lageregelungen, wie z.B. beim Quattrocopter. Die Ansteuerung der Motoren sollte für eine effektive Regelung mit genügend Reserven ausgestattet sein und aktiv bremsen können. Desweiteren ist auf eine sorgfältige Auswahl der Motoren bezüglich des Trägheitsmoments zu achten. Man sollte sich genau überlegen, ob ein Brushless Aussenläufer die richtige Wahl ist. In der Hinsicht sind bestimmt Glockenankermotoren die beste Wahl.

Im nächsten Beitrag wird eine vorläufige Parametrierung des Reglers festgelegt und dann geht es an die Umsetzung in Code.

Waste

Fortsetzung folgt

[waste]

Fortsetzung:
Heute geht es darum, wie man vom Bodediagramm auf die Parameter Kp, Ki und Kd für den Regler kommt.

Ich habe nochmal die Sprungantwort auf die Begrenzung optimiert. Ich musste dazu den D-Anteil etwas zurücknehmen, damit das Einschwingen besser wird. Die Sprungantwort ist im Bild "PD1.gif" als grüne Kurve zu sehen. Das zugehörige Bodediagramm ist im Bild "olg3.gif". Die rote Kurve ist die "open loop gain" und die grüne Kurve ist die Verstärkung des Reglers. Zusätzlich habe ich noch einen I-Anteil hinzugefügt, da die Verstärkung des P-Anteils nicht ausreichen wird, um auch enge Kurven zu fahren. Eine Verstärkung von nur 3 kann die Ansteuerung (PWM) um maximal 3*60 = 180 verändern, weil der Sensor max. nur 60 liefert und das reicht nicht aus um das innere Rad soweit zu drosseln, dass auch sehr enge Kurven gefahren werden können. Ursprünglich war ich der Meinung der P-Anteil würde höher sein und da kann ich auf den I-Anteil verzichten, also brauch nur einen PD-Regler zu realisieren, aber das hat sich jetzt zerschlagen, ich muss doch einen PID-Regler machen. Das hat jetzt den Vorteil, dass auch der I-Anteil in die Erklärung mit einbezogen wird. Der I-Anteil ist im Bodediagramm links an dem Abfall der grünen Kurve bis ca. 1Hz zu sehen.

Die Parameter für den PID-Regler sind folgendermassen definiert:
Kp ist die Verstärkung des P-Teils
Ki = 1/Ti (Ti ist die Zeitkonstante des Integrators)
Kd = Td (Td ist die Zeitkonstante des Differenzierglieds)
Die Zeitkonstanten können zum einen aus der Simulationsschaltung direkt bestimmt werden als auch aus dem Bodediagramm. Dazu sind in dem Bild "regler_bode.gif" die Anteile des Reglers P, I und D einzeln dargestellt um die Zeitkonstanten herauszufinden. Die Zeitkonstanten errechnen sich aus den 0dB-Durchgängen der I- und D-Kurve. Der D-Anteil ist die rote Kurve, die kreuzt bei 0.712Hz die 0dB-Linie, d.h. fd=0.712Hz.
Damit ist: Kd = Td = 1/(2*pi*fd) = 0.225

Der I-Anteil ist die hellblaue Kurve, die kreuzt bei 1.59Hz die 0db-Linie, d.h. fi=1.59Hz.
Damit ist: Ki = 1/Ti = 2*pi*fi = 10

Der P-Anteil ist einfach, das ist die violette Kurve. Wie schon früher festgestellt ist Kp = 3 das entspricht den 9.5dB.

Somit sind die Parameter des Reglers bestimmt und es kann im nächsten Beitrag mit der Umsetzung in Code weitergehen.

Waste

[waste]

Fortsetzung:
Heute geht es darum, wie das bisherige Wissen in einen Code umsetzt wird.

Hierzu eine Zusammenstellung der Formeln. Wer eine Herleitung der Formeln will, kann sich im WWW informieren, es gibt darüber genügend Literatur.

Begriffsdefinitionen:

• W = Sollwert
  X = Istwert
  Xw = Regelabweichung
  Y = Stellgrösse
  Yp = P-Anteil von Y
  Yi = I-Anteil von Y
  Yd = D-Anteil von Y
  Kp = Proportionalbeiwert
  Ki = Integrierbeiwert
  Kd = Differenzierbeiwert
  dt = Taktzeit des Reglers

Formeln zur Berechnung:

• Xw = W - X
  Yp = Kp * Xw
  Yi = Ki * (Isum + Xw * dt)
  Isum: ist die Summe aller vergangenen (Xw * dt) Berechnungen
  Yd = Kd * (Xw - Xwalt)/dt
  Xwalt: ist der Xw-Wert des letzten Zyklus
  
  Y = Yp + Yi + Yd

Zum besseren Verständnis habe ich in das Blockschaltbild die benützten Kürzel eingetragen (siehe Bild). Der Regler ist jetzt detailierter dargestellt.
Der Sollwert W ist in unserem Fall Null. Der Istwert X ist der ausgelesene Wert des Liniensensors. Die berechnete Stellgrösse Y ist die Korrektur, die auf den PWM-Wert zur Ausregelung gebracht wird. Man hat die Wahl, entweder die Stellgrösse Y je zur Hälfte im entgegengesetzten Sinn auf beide Motore zu geben oder nur einen Motor zu verlangsamen oder zu beschleunigen. Auf das Vorzeichen muss geachtet werden, sonst regelt er nicht aus.

So, jetzt kann mit dem Programmieren losgelegt werden! Wer will es selbst versuchen?
Mit den Parametern aus dem letzten Beitrag hat man alles, was man dazu braucht.
Kp = 3; Ki = 10; Kd = 0.225;
dt = 0.0016

Während Ihr inzwischen fleissig programmiert, werde ich mein vorläufiges Programm noch auf Vordermann bringen, um es hier reinstellen zu können.

Tipps:
Mit etwas Geschick kann man auf floating point verzichten und man kommt mit Integer aus.
Sorgfalt ist geboten um Überläufe zu verhindern.
Beim D-Anteil kommt prinzipbedingt ein sehr hoher Wert in der Berechnung vor. Die Weitergabe an den PWM-Wert muss begrenzt werden, aber der Rest darf nicht verworfen werden, sonst stimmt das Verhalten nicht mehr.

Waste

Fortsetzung folgt

[Vogon]

Ohhh, liegt es am guten Wetter ?
Ich kann mir nicht vorstellen das sich da keiner traut.

Aber ich werde mal meine Versuche mit PD-Regler (mit float und long) mit deinen Werten umschreiben

[waste]

Fortsetzung:
Hier ist mein Programm. Es ist soweit kommentiert, dass jeder damit klar kommen sollte.

/*******************************************************************************
*
* Description: Asuro Linienverfolgung mit PID-Regler
* Version 1: Korrektur auf beide Motoren verteilt
* Autor: Waste	26.8.05
*
*****************************************************************************/
#include "asuro.h"
#include <stdlib.h>

unsigned char speed;
int speedLeft,speedRight;
unsigned int lineData[2];
int x, xalt, don, doff, kp, kd, ki, yp, yd, yi, drest, y, y2, isum;

void FollowLine (void)
{
unsigned char leftDir = FWD, rightDir = FWD;
	FrontLED(OFF);
	LineData(lineData);						// Messung mit LED OFF
	doff = (lineData[0] - lineData[1]);	// zur Kompensation des Umgebungslicht
	FrontLED(ON);
	LineData(lineData);						// Messung mit LED ON
	don = (lineData[0] - lineData[1]);	
	x = don - doff;						// Regelabweichung
	isum += x;
	if (isum > 16000) isum =16000;			//Begrenzung um Überlauf zu vermeiden
	if (isum < -16000) isum =-16000;
	yi = isum/625 * ki;					//I-Anteil berechnen
	yd = (x - xalt)*kd;					// D-Anteil berechnen und mit
	yd += drest;							// nicht berücksichtigtem Rest addieren
	if (yd > 255) drest = yd - 255;		// merke Rest
	else if (yd < -255) drest = yd + 255;
	else drest = 0;
	if (isum > 15000) BackLED(OFF,ON);	// nur zur Diagnostik
	else if (isum < -15000) BackLED(ON,OFF);
	else BackLED(OFF,OFF);
	yp = x*kp;								// P-Anteil berechnen
	y = yp + yi + yd;						// Gesamtkorrektur
	y2 = y/2;								// Aufteilung auf beide Motoren
	xalt = x;								// x merken
	speedLeft = speedRight = speed;
	MotorDir(FWD,FWD);
	if ( y > 0) {							// nach rechts
		StatusLED(GREEN);
		speedLeft = speed + y2;			// links beschleunigen
		if (speedLeft > 255) {
			speedLeft = 255;				// falls Begrenzung
			y2 = speedLeft - speed;		// dann Rest rechts berücksichtigen
		}
		y = y - y2;
		speedRight = speed - y;			// rechts abbremsen
		if (speedRight < 0) {
			speedRight = 0;
		}
	}
	if ( y < 0) {							// nach links
		StatusLED(RED);
		speedRight = speed - y2;			// rechts beschleunigen
		if (speedRight > 255) {
			speedRight = 255;				// falls Begrenzung
			y2 = speed - speedRight;		// dann Rest links berücksichtigen
		}
		y = y - y2;
		speedLeft = speed + y;				// links abbremsen
		if (speedLeft < 0) {
			speedLeft = 0;
		}
	}
	leftDir = rightDir = FWD;
	if (speedLeft < 20)  leftDir = BREAK; // richtig bremsen
	if (speedRight < 20) rightDir = BREAK; 
	MotorDir(leftDir,rightDir);
	MotorSpeed(abs(speedLeft),abs(speedRight));
}

int main(void)
{
unsigned char sw;
	Init();
	MotorDir(FWD,FWD);
	StatusLED(GREEN);
	speed = 150;
	kp = 3; ki = 10; kd = 70;		// Regler Parameter kd enthält bereits Division durch dt
	sw = PollSwitch();
	if (sw & 0x01)
		{ki=20;}
	if (sw & 0x02)
		{speed = 200;}
	if (sw & 0x04)
		speed = 100;
	if (sw & 0x08)
		kd = 35;
	if (sw & 0x10)
		kd = 70;
	if (sw & 0x20)
		kd = 140;
	FrontLED(ON);
	LineData(lineData);
	speedLeft = speedRight = speed;
	while(1){
		FollowLine();
	}
    return 0;
}

Ergänzende Hinweise:
Ich habe den Differenzierbeiwert kd gleich durch dt geteilt, damit ich mit Integer rechnen kann.
kd/dt = 0.225/0.0016 = 140
Mit diesem Wert zittert (schwingt) der Asuro leicht. Als gute Werte haben sich 40 bis 70 herausgestellt. Da fährt der Asuro schön stabil. In der main Routine kann man die Parameter verändern, wenn man nach dem Einschalten des Asuros eine der Tasten drückt bis die Motore anlaufen. Da kann man verschiedene Einstellungen testen.

Das Zittern bei kd=140 liegt vermutlich an dem zu grossen Getriebespiel. Meinen Asuro kann ich etwa 2mm hin und her schwenken ohne dass sich die Motoren mitdrehen. Dadurch ergibt sich eine zusätzliche Totzeit , die das Schwingen erklären könnte. Ganz sicher bin ich mir aber nicht, das müsste man noch genauer untersuchen. Aber mit kleineren kd-Werten funktioniert der Regler wunderbar. Bei Kd=70 ist er sehr schnell und stabil. Bei kd=35 ist er schon deutlich langsamer aber immer noch sehr stabil. Bei noch kleineren Werten sieht man schon leichtes Nachschwingen.

Die Regelabweichung ist in meinem Programm x anstatt Xw. Da der Sollwert 0 ist, habe ich gleich den Istwert x für die Berechnungen genommen. Ansonsten sollten die Variablen mit meinem letzten Beitrag übereinstimmen.

Der I-Anteil wird durch Begrenzen von Isum auch begrenzt. Bei ki=10 ist der Grenzwert 256, das ist praktisch Vollausschlag an den Motoren. Mehr braucht man nicht, es könnte sogar eine niedrigere Begrenzung sinnvoll sein, um bei S-Kurven nicht auszurasten.

Der D-Anteil kann sehr hohe Werte annehmen, die in einem Zyklus gar nicht verwertet werden können. Um dennoch das richtige Verhalten des Reglers zu erreichen, wird der nicht verwertete Rest in der Variable "drest" gespeichert und bei den nächsten Zyklen wieder berücksichtigt.

Das Programm ist auch noch komplett mit hex-File in einer zip-datei angehängt. Probiert es mal aus. Da mein Asuro mit den grösseren Akkus etwas schwerer ist als im Original, können sich bei Euch etwas andere Ergebnisse herausstellen. Ich selber werde auch noch mit den Parametern spielen und einige Freiheitsgrade testen.

Waste

[Vogon]

Als vorhin nachhause kam, habe ich dein fertiges Programm gesehen. Das musste ich doch sofort testen.

Soweit ich es bisher sehen kann ist die Regelung, ausgezeichnet.
Ich habe bei 100,150 und 200 keine Fehler bemerkt. Kein zittern oder ausbrechen !

Meine Linie ist ein 3m langer schwarzer Klebestreifen 24mm breit auf einer Sperrholzplatte 120+80 cm. Kurvenradius 140 mm.

Ich habe auch 4 AA Akkus auf meinem Asuro von denen zwei hinten überstehen. Er wiegt 270 Gramm. Auf dem Vorderrad, ein durchbohrter KugelKnopf mit 14mm Durchmesser liegen nur noch 20 Gramm.