PID Simulator

[Matthias K. (koellomat)]

Hallo,

ich habe 2 Implementierungen eines PID-Stromreglers in c-Code für 2 
unterschiedliche Controller. Es geht dabei aber weniger um die 
unterschiedliche Hardware, als die Tatsache, dass wohl die beiden 
Implementierungen unterschiedlich skaliert sind.

Da die Hardware nur begrenzt zur Verfügung steht und die Last im Moment 
auch nicht verfügbar ist, kam ich auf die Idee, den Regelkreis auf dem 
PC mit beiden Implementierungen zu simulieren und zu vergleichen.

Der Regler ist nicht das Problem, da der Code ja vorhanden ist.

Das Problem ist die Regelstrecke. Ich gehe von einem einfachen RL-Glied 
aus.
Für die Sprungantwort, also Ein- und Ausschalten, gibt es die bekannten 
Formeln.

Wenn das RL-Glied am Regler hängt, wird es ja zu diskreten Zeitpunkten 
mit unterschiedlichen Spannungen beaufschlagt.
Erst hab ich versucht mir vorzustellen, dass ich eine Aneinanderreihung 
von Sprungantworten habe, hab mich aber schwer getan mit der 
Formulierung der Zeit und der Spannung in jedem diskreten Zeitpunkt.
Dann habe ich nach Simulation im Netz gesucht. Da tauchen dann Begriffe 
wie "Backward Euler" auf. Ich finde aber keine konkrete Umsetzung für 
eine Spule.
Dann habe ich mich nach Source-Code von Simulatoren umgeschaut. Ich habe 
den Source-Code von Ngspice vorliegen. Den müsste ich aber debuggen, um 
zu verstehen, was bei der Analyse passiert.

Habt ihr noch Ideen, wie ich da weiterkomme?

Gruß Matthias

[Joe G. (feinmechaniker)]

So wie ich deine Aufgabenstellung verstanden habe, möchtest du eine 
diskrete Strecke mit einem zeitdiskreten Regler simulieren.
Der übliche Weg wäre aus meiner Sicht der folgende:

Variante 1:
Du erstellst ein Modell deiner Strecke (kontinuierlich).
Du überführst das Modell vom Zeit- in den Frequenzbereich mittels 
Lapalce-Transformation.
Anschließend überführst du dieses Modell mittels Z-Transformation in den 
zeitdiskreten Bereich.

Variante 2
Du erstellst das Modell der Strecke kontinuierlich als Dgl.-System.
Du überführst die Zeitableitungen durch Abtastung mit einer Abtastzeit T 
und einer dir genehmen Regel (z.B. bilineare Transformation nach Tustin) 
in die zugehörigen Differenzengleichungen.

[Joe G. (feinmechaniker)]

Hier noch ein kleines Beispiel. Wie man sieht, sind die Sprungantworten 
für eine diskrete und kontinuierliche s-T2 Strecke gleich, wenn ein 
Abtast- und Halteglied verwendet wird.

[Matthias K. (koellomat)]

Könnte mir noch mal jemand helfen und in die von Joe angefügte 
Übertragungsfunktion die entsprechenden physikalischen Größen R, L, U, I 
eintragen?

[Frank S. (tueftler81)]

Um Regelstrecken zu optimieren oder zu untersuchen habe ich mit 
Winfact/Boris gute Erfahrungen gemacht 
(https://www.kahlert.com/simulationssystem-boris) dort gibt es auch eine 
Demoversion, die Privatlizenz ist günstig im Vergleich zu Simulink&Co.

[Joe G. (feinmechaniker)]

Matthias K. schrieb:
> Könnte mir noch mal jemand helfen und in die von Joe angefügte
> Übertragungsfunktion die entsprechenden physikalischen Größen R, L, U, I
> eintragen?

Dann zeige doch mal deine Schaltung.

[Matthias K. (koellomat)]

Für die Simulation würde ich der Einfachheit halber das Tastverhältnis 
mit der Versorgungspannung multiplizieren und als Eingangsgröße für die 
Regelstrecke verwenden.

@Frank
Ich möchte kein Simulationsprogramm verwenden, da es mir wichtig ist, 
die Effekte von Datentypen und Rundung im PID-Algorithmus zu 
berücksichtigen.

[Abdul K. (ehydra)]

Soweit ich das überblicke, unterstützt QSPICE alles was du haben willst.

C-Code und Verilog kannst du einbinden.

[Matthias K. (koellomat)]

@Abdul
Das sieht gut aus, werde ich ausprobieren. Danke

[Weinga U. (weinga-unity)]

Du könntest die Differentialgleichungen der Strecke mit dem 
Euler-Verfahren zeitdiskretisieren und dann einfach parallel im selben 
C-Programm mitlaufen lassen. Dabei nicht vergessen die Zeitschrittweite 
des Euler-Verfahrens ca. 10x schneller zu wählen als die Regler laufen, 
damit quasikontinuierlicher Betrieb der Strecke angenommen werden kann.

RLC Serienschwingkreis:

$$\dfrac{\mathrm{d}}{\mathrm{d}\,t} u_C=\dfrac{1}{C}\,i_L$$

$$\dfrac{\mathrm{d}}{\mathrm{d}\,t} i_L=\dfrac{1}{L}\left(u_e-u_C-R\cdot i_L\right)$$

wird dann nach dem Euler-Verfahren mit der Zeitschrittweite T_s zu

$$u_{C,k+1}=u_{C,k}+T_s\,\dfrac{1}{C}\,i_{L,k}$$

$$i_{L,k+1}=i_{L,k}+T_s\,\dfrac{1}{L}\,\left(u_{e,k}-u_{C,k}-R\cdot i_{L,k}\right)$$

Lg.

[Josef B. (Firma: Hard- &Software) (jbernhardt)]

Ich benutze für die Simulation folgende Funktion:

float PT2_Simulation(float Stellgroesse)
{
  // Parameter
  const float deltaT = 1.0; //  max 10
  const float k1 = 82.0 / 100;
  const float k2 = 1.0;
  const float k3 = 1.0;
  const float T1 = 100.0;
  const float T2 = 8.0;
  const float T3 = 10.0;

  // Variablen
  static float x1_k = 0;
  static float x2_k = 0;
  static float x3_k = 0;
  static float x1_punkt;
  static float x2_punkt;
  static float x3_punkt;

  // Modellgleichungen, Euler-Integration
  x1_punkt = (k1 * Stellgroesse - x1_k ) / T1;
  x1_k = x1_punkt * deltaT + x1_k;

  x2_punkt = (k2 * x1_k - x2_k ) / T2;
  x2_k = x2_punkt * deltaT + x2_k;

  x3_punkt = (k3 * x2_k - x3_k ) / T3;
  x3_k = x3_punkt * deltaT + x3_k;

  return x3_k;
}

[Michael B. (laberkopp)]

Matthias K. schrieb:
> Habt ihr noch Ideen

Weniger simulieren, mehr echte Hardware.

z.B. Motor-Drehzahlregelung, Temperaturregelung, Lasertracking eines CD 
Player regeln, schwebende Kugel etc

[Josef B. (Firma: Hard- &Software) (jbernhardt)]

Hier ein Praxisbeispiel für einen Fuzzy Logic Regler mit dem PSOC5