kramann.info
© Guido Kramann

Erstellen des Simulationsmodells

Die Modellklasse besteht aus einem Antrieb, dessen Übertragungsverhalten einem PT₂-Übertragungsglied mit Totzeit entspricht und das durch einen PID-Regler geregelt werden soll.

Da davon ausgegangen wird, dass die PID-Regelung über Software erfolgt, die auf einem Mikrocontroller läuft, ergeben sich für das System besondere Eigenschaften, die gleich mit modelliert werden sollen:

Es wird vorausgesetzt, dass die Totzeit T_t hauptsächlich aufgrund der Berechnung des Stellsignals aus dem Sensorsignal entsteht und konstant und bekannt ist.
Außerdem wird der I- und der D-Anteil nicht exakt, sondern in Schritten von der Größe der Totzeit T_t berechnet.
Die entsprechenden Modellgleichungen im Zeitbereich lauten:
(Die verwendeten Skalierungsfaktoren entsprechen denen des zugrundeliegenden realen Systems)

Bild 0-1: Zu simulierendes Modell mathematisch formuliert.

Vorbereitend für die numerische Integration wird die Differentialgleichung in ein Differentialgleichungssystem ersten Grades umgewandelt:

Bild 0-2: Umwandlung der Modellgleichung in ein DGLS erster Ordnung.

Für den später erfolgenden Optimierungsvorgang ist es sinnvoll die Parameter so zu substituieren, dass keine sie als Linearfaktoren vor den einzelenen Termen erscheinen:

Bild 0-3: Substitution der Modellparameter vorbereitend auf die Optimierung.

Das vorangegangene Kapitel über die Modellierung eines Elektromotors und die darin ausgedrückten physikalischen Gegebenheiten legen nahe, dass alle Parameter (a, b, c und damit auch K, L, M) als positiv angenommen werden und später entsprechend optimiert werden.

Für die angegebenen Beispielwerte ergeben sich folgende konkrete Werte:
(Dabei ist zu berücksichtigen, dass beim COACH-Vehikel ein stärkerer Motor verwendet wird, der Fahrwiderstand hinzu kommt und die Wirkung des Getriebes.)

a=0.00009
b=0.24
c=0.98
M=11111
K=2671
L=10833

Code 0-1: Parameter für das Beispiel des besprochenen Elektromotors.

Anmerkungen zur nachfolgenden Java-Basisklasse für das Simulationsmodell:

Der aktuelle Steigung (Berechnung der rechten Seite des DGLS) wird im Array f gespeichert.
anzahlgleichungen: Anzahl der Simulationsgleichungen im DGLS ersten Grades.
Die Berechnungsmethode berechneRechteSeite(..) muß von erbenden Klassen überschrieben werden.
Das Modell kann durch Überschreiben der Methode paint(..) in die Lage versetzt werden, seinen aktuellen Systemzustand grafisch darzustellen.
Die Methode paint(..) wird von der paint-Methode eines Canvas-Objekts her aufgerufen.

package opti;
import java.awt.*;
public class Simulationsmodell
{
    public double[]   f = null;
    public Simulationsmodell(int anzahlgleichungen)
    {
        f = new double[anzahlgleichungen];        
    }
    public int getAnzahlGleichungen()
    {
        return f.length;
    }
    public double[] berechneRechteSeite(double[] yalt, double t)
    {
        return f;
    } 
    public void paint(Graphics2D g)
    {
    }
}

Code 0-2: Basisklasse des Simulationsmodells in der Java-Quelltext-Datei Simulationsmodell.java

Bei der folgenden Modell-Beschreibung als Java-Klasse sind die Eigenheiten der konkreten Umsetzung mit berücksichtigt.
Insbesondere kann die Stellgröße nur in einem bestimmten Zeitintervall Tt durchgeführt werden.
Siehe auch die Kommentare im Quellcode.

package opti;
import java.awt.*;
public class PIDgeregelterAntrieb extends Simulationsmodell
{
    /**
    Die folgenden Variablen sind die Modellparameter, die später
    optimiert werden können.<br/>
    Als Startwert sind die zu erwartenden Extremwerte eingestellt, damit
    später automatisiert GUI-Elemente erzeugt werden können.<br/>
    Da positive Extremwerte vorgegeben sind, ist damit festgelegt, dass
    alle Modell-Parameter nicht negativ werden dürfen.
    */
    public double K = 100000.0;
    public double L = 100000.0;
    public double M = 100000.0;
    /**
    Die folgenden Variablen sind die Parameter des PID-Reglers, die später
    ebenfalls optimiert werden können.<br/>
    Als Startwert sind die zu erwartenden Extremwerte eingestellt, damit
    später automatisiert GUI-Elemente erzeugt werden können.<br/>
    Da positive Extremwerte vorgegeben sind, ist damit festgelegt, dass
    alle Modell-Parameter nicht negativ werden dürfen.<br/>
    Für die Parameteridentifikation des Modells (Bestimmung von K,L und M)
    können die Parameter des Reglers (P, I, D) zunächst zu Null gesetzt werden.<br/>
    Für die Identifikation der Regelstrecke wird zunächst die Totzeit Tt zu Null gesetzt.<br/>
    In einem ersten Ansatz für die Identifikation der Regelparameter wird Tt auf 0,01s gesetzt.
    */
    public double P = 1000.0;
    public double I = 10.0; //Faktor 0.01, da Tt=0.01s mit enthalten
    public double D = 100000.0; //Faktor 100, da 1/Tt=100.0 1/s enthalten
    public double Tt = 0.01;
    /**Sollwert für den Regler:*/
    public double omega_viertel_soll = 100.0;
    /**
    Bei jeder Aktualisierung des Stellwertes wird der Zeitpunkt registriert.<br/>
    Eine neue Aktualisierung findet erst statt, 
    wenn seit dem ein Zeitintervall von der Dauer der Totzeit Tt vergangen ist.<br/>
    Um eine konsistente Simulation zu gewährleisten, wird vorausgesetzt, dass eine
    neue Simulation immer bei t=0s startet.
    */
    private double t_aktualisiert = 0.0;
    private double e_alt = 0.0; //Alte Regeldifferenz.
    private double e_sum = 0.0; //Aufsummierte Regeldifferenz.
    private double pwm_alt = 0.0; //gemerkte Stellgröße, bleibt bis zur nächsten Aktualisierung erhalten.
    public PIDgeregelterAntrieb()
    {
        super(2); //Zwei Simulationsgleichungen
    }
    public double[] berechneRechteSeite(double[] yalt, double t)
    {
        /**temporäre Variablen deklarieren:<br/>
           Die verwendete Zustandsgröße omega_viertel (y[0]) hat die Einheit Omega/4, 
           d.h. die tatsächliche Winkelgeschwindigkeit kann zu omega = 4*omega_viertel bestimmt werden.<br/>
           Damit werden genau die im Mikrocontrollerprogramm verfügbaren Größen simuliert.
        */
        double e             = e_alt;   //Regeldifferenz
        double pwm           = pwm_alt; //Stellgröße -1023..+1023, entspricht u im Standardregelkreis.
        double omega_viertel = yalt[0]; //für eine bessere Lesbarkeit 
        double v             = yalt[1]; //für eine bessere Lesbarkeit
        /**Notwendige Initialisierungen bei Start einer neuen Simulation durchführen.*/
        if(t==0.0)
        {
            t_aktualisiert = 0.0;
            e       = 0.0;
            e_alt   = 0.0;      
            e_sum   = 0.0;
            pwm     = 0.0;
            pwm_alt = 0.0;
        }
        /**Bedingungen für die Aktualisierung der Stellgröße.*/
        if(t==0.0 || t_aktualisiert+Tt<=t)
        {
            e = omega_viertel_soll - omega_viertel;
            pwm = P*e + I*e_sum + D*(e-e_alt);
            t_aktualisiert=t; //Merken dieses neuen Aktualisierungszeitpunktes.
            e_alt = e;           //Merken der neuen aktuellen Regeldifferenz für D-Anteil          
            e_sum += e;          //Aktualisierung der Summe der Regeldifferenzen für I-Anteil 
            pwm_alt =  pwm;      //Merken/Aktualisierung der Stellgröße
        } 
        /**Eigentliche Bestimmung der rechten Seite (Steigungsvektor)*/
        f[0] = v;
        f[1] = - K*v - L*omega_viertel + M*pwm;
        return f;
    } 
    /** paint(..) wird bei der Konsolenanwendung nicht verwendet.*/
    public void paint(Graphics2D g)
    {
    }
}

Code 0-3: Simulationsmodell der Regelstrecke mit PID-Regler als Java-Quelltextdatei PIDgeregelterAntrieb.java