Regler Grundlagen, Basiswissen (PID....)

[NBGer]

ich lege hier mal diesen Thread an als Fortführung der Diskussion in viewtopic.php?f=15&t=5566

[NBGer]

ich mach's mal ganz konkret...
ich habe mal eigene Sourcen aus dem Jahr 2015 rausgekramt...die waren für ein reales embedded Projekt, nicht für fischertechnik.
die Implementierung hat für das damalige Projekt gut funktioniert, aber es gibt bestimmt Verbesserungspotential!

es ist eine gute Gelegenheit für mich, das ganze Thema Regler auch für mich wieder aufzufrischen.

Code: Alles auswählen

typedef struct
{
	float Ta;                    	// Sampling Time in ms
	float kP;                     // Proportional gain
	float kI;                   	// Integral gain
	float kD;                      // Derivative gain
	float WindupThreshold;
	float e;                      // current error
	float esum;                   // sum of the instantaneous error over time
	float eold;                   // error at time t-1
	float y;						// output value

}PID_DataT;                  //

/**** functions declarations **************************************************/
void PID_Init(PID_DataT* pPID,float Ta,float kP,float kI,float kD, float antiWindupThr);
void PID_Reset(PID_DataT* pPID);
SNUM16 PID_Cyclic (PID_DataT* pPID,float x, float w);

//========================================================================================
// PID Controller
//========================================================================================

void PID_Init(PID_DataT* pPID,float Ta,float kP,float kI,float kD, float antiWindupThr)
{
	pPID->Ta = Ta;
	pPID->kP = kP;
	pPID->kI = kI;
	pPID->kD = kD;
	pPID->WindupThreshold = antiWindupThr;

	PID_Reset(pPID);
}

void PID_Reset(PID_DataT* pPID)
{
	pPID->esum= 0.0f;
	pPID->e= 0.0f;
	pPID->eold = 0.0f;
}

//
// x => Actual (measured) value 
// w => Setpoint 

SNUM16 PID_Cyclic (PID_DataT* pPID, float x, float w)
{
  pPID->e = w - x;                                   // current error

  pPID->esum = pPID->esum + pPID->e;				// sum of the instantaneous error over time
  if ( pPID->esum > pPID->WindupThreshold )	// Anti Windup
  {
	  pPID->esum = pPID->WindupThreshold;
  }
  else if ( pPID->esum < -pPID->WindupThreshold )	// Anti Windup
  {
	  pPID->esum = -pPID->WindupThreshold;
  }


  pPID->y = (pPID->kP*pPID->e) + (pPID->kI*pPID->Ta*pPID->esum) + (pPID->kD*((pPID->e-pPID->eold))/pPID->Ta);    // PID control algorithm
  pPID->eold = pPID->e;
  return (SNUM16)pPID->y;	// return of resulting output value
}

Der Code ist in C und müsste eigentlich hardware-unabhängig sein.

Der Regler arbeitet mit P,I und D. Außerdem ist ein Anti-Windup Mechanismus implementiert

[NBGer]

Nachtrag:
Ich habe den Großteil des Codes auch irgendwo abgeschrieben; letztenendes habe ich aber verstanden, wie er funktioniert

[MasterOfGizmo]

Da ist aber der Anti-Windup wieder nicht das, was Peter beschrieben hat, oder? Hier begrenzt es den akzeptierten Fehler, im anderen Thread war es eine Begrenzung des Ausgangssignals und in Peters Beschreibung was es eher ein kompletter Reset, wenn ich das richtig verstanden habe.

[NBGer]

ich weiß nicht, ob Anti-Windup 100% genau definiert ist.
meine Lösung hat die integrale Summe des Reglers auf einen Maximalwert begrenzt (also eingefroren).
Wenn die mechanische Störung behoben war, war der Wert nicht jenseits von Gut und Böse und der Regler war schnell wieder im Regelbereich. Vielleicht wäre es auch besser, esum komplett auf 0 zu setzen unter bestimmten Bedingungen.
Wenn man esum auf 0 setzt, dann wirkt ja erst mal der I-Anteil gar nicht. Das ist von Nachteil, wenn die Bewegung eine Zeit lang außerplanmäßig gebremst wird und dann wieder frei fahren kann. In meiner Anwendung konnten Menschen hineingreifen. Die neigen dazu, dass sie auch gerne mal mit so einer Technik spielen.

Der reale Anwendungsfall hat bei mir so ausgesehen: Eine relativ schwere Last war drehbar gelagert. Wenn der Motor gedreht hat, wurde die Last hochgefahren. In diesem Fall war man immer schön innerhalb der Regelvorgaben. Die Mechanik hatte konstruktionsbedingt relativ viel Spiel. Hatte man beim Bewegen den oberen Totpunkt überschritten, hat die Last erstmal wegen der Schwerkraft ungebremst beschleunigt, bis das Spiel überwunden war. Dann musste man es möglichst schnell wieder schaffen, die Last geregelt weiter zu drehen. Auf jeden Fall rechtzeitig, bevor auf die Endlage positioniert wurde.
Der Winkelgeber war aber direkt am Motor, so dass der kurze freie Fall vom Winkelsensor erst mal nicht erkannt werden konnte. Zusätzlich konnte man aber noch den Motorstrom auslesen und in die Berechnung einbeziehen. Das war aber außerhalb des Reglers. Soweit ich mich erinnere, haben wir die Ist-Position interpoliert.

[NBGer]

Da ist aber der Anti-Windup wieder nicht das, was Peter beschrieben hat, oder? Hier begrenzt es den akzeptierten Fehler, im anderen Thread war es eine Begrenzung des Ausgangssignals und in Peters Beschreibung was es eher ein kompletter Reset, wenn ich das richtig verstanden habe.

achso...ich glaube, das was Peter meinte, war hier durch PID_Reset() realisiert. Mit dieser Funktion wurden die internen Werte zurückgesetzt.

[PHabermehl]

Hi zusammen,
ich bin ja nun auch kein Regelungstechniker, sondern kann nur mein unfreiwillig erworbenes Praxiswissen teilen.

Das ungewünschte Weiterrechnen des Integrators, als windup bezeichnet, ist ein prinzipielles Problem eines I-Reglers.

In der Praxis gibt es eben eine ganze Reihe von Maßnahmen dagegen, unter dem Sammelbegriff Anti-windup.

Als Möglichkeiten wurden ja schon genannt
- Begrenzung des Reglerausgangs
- Einfrieren des Integrators
- konditionales oder kontinuierliches Reinitialisieren des Reglers

Diese Funktionen können auch kombiniert werden.

Gruß
Peter

[NBGer]

für eine Motorsteuerung (Geschwindigkeit oder Position) ist ja der Regler nur ein Teil.
Außenrum ist ja auch noch einiges zu programmieren:

Anfahr- und Bremsrampen
Mindest-PWM für das Losbrechmoment
Spiel-Kompensation
Max. PWM
Max. Beschleunigung
Max. Geschwindigkeit
....

das führt oft dazu, dass man entweder den Regler ganz deaktiviert oder den Ausgangswert überschreibt.
In diesem Fall laufen die Reglerwerte auch davon. Als Gegenmaßnahme ist Anti-Windup auch hilfreich.

Ich kann mich an das Thema Losbrechmoment erinnern. Das wurde mit einer Mindest-PWM gelöst, bis sich der Motor endlich bewegt. Allerdings kommt hier noch das Spiel ins Spiel (schönes Wortspiel... -spiel,-spiel) ...Der Positionsgeber sitzt am Motor. Das Spiel liegt aber in der Mechanik.
Der Motor läuft also los (ab einer Mindest-PWM), läuft aber eigentlich erst leer, bis das Spiel der Mechanik überwunden ist. Dann geht plötzlich die Posiitionsänderung gegen 0 und man muß die PWM hochdrehen, bis sich die Mechanik endlich in Gang setzt. Ein Regler übersteuert dann stark, was man mit Anti-Windup in Griff bekommen kann.