kramann.info
© Guido Kramann

Entwurf und Ergänzung eines Fuzzy-Reglers für das Hängependel

Für Winkelgeschwindigkeit ω und die Pendelwinkel φ sind die Eingangsgrößen des Reglers.
Für Winkelgeschwindigkeit ω und die Pendelwinkel φ werden Fuzzy-Größen eingeführt.
Ausgangsgröße ist die horizontale Stellkraft F_A.
Alle Größen erhalten Fuzzy-Quantitäten Negativ-Groß, Negativ-Klein, Null, Positiv-Klein, Positiv-Groß, also
NG, NK, NN, PK, PG.
Die Bezeichnungen der Größen lauten:
P für den Pendelwinkel φ
W für die Pendelwinkelgeschwindigkeit ω
F für die Stellkraft F_A.
Das jeweilige Minimum und Maximum der zunächst gleich verteilten Fuzzygrößen soll sein:
P: -1..1 [rad]
W: -20..20 [rad/s]
F: -5..5 [N]

Anmerkungen:
Wenn das Pendel über +/-π/2 hinausgeht, soll die Stellkraft Null sein.
Dies setzt voraus, dass bei PNG und PPG keine Stellkraft wirkt.
Dann aber liegt es nahe, dass bei der Optimierung die Bereiche PNG und PPG klein gemacht werden, da hier der Regler unwirksam ist.
Da hier keine Regeldifferenzen betrachtet werden, taucht bei der Stellgröße immmer ein zu den Eingangsgrößen umgekehrtes Vorzeichen auf.

Die folgende Tabelle repräsentiert nun die verwendeten Fuzzy-Regeln.
Für die meisten, aber nicht alle Kombination von P und W wird ein F eingetragen.
Da, wo keine Regeln stehen, stehen Winkel und Winkelgeschwindigkeit im Widerspruch zueinander.
Man beachte die Symmetrie bei den Regeln.

     PNG PNK PNN PPK PPG
WNG  FNN FPG FPG  -  FNN
WNK  FNN FPK FPK  -  FNN
WNN  FNN FPK  -  FNK FNN
WPK  FNN  -  FNK FNK FNN
WPG  FNN  -  FNG FNG FNN

Code 0-1: Entwurf der Fuzzy-Regeln für das Hängependel.

Dies soll mit dem Java-Framework aus dem vorangegangenen Kapitel umgesetzt werden.
Hierzu mußten zunächst zwei Korrekturen durchgeführt werden:

Korrektur 1

Beim vorliegenden System treten auch Fälle auf, wo keine der Regeln aktiviert ist.
Dabei ist dann die Gesamtfläche Null.
Da bei der Schwerpunktberechnung durch die Gesamtfläche geteilt wird, muß dieser Fall abgefangen werden.
Dahingehend mußte die Methode "public double berechneAusgang(double[] eingang)" in FuzzyRegler.java deshalb korrigiert werden.

        if(gesamtflaeche==0.0)
            return 0.0;
        else
            return ergebnis/gesamtflaeche;

Code 0-2: Korrektur in Methode berechneAusgang(...).

Korrektur 2

Bei der Methode "public double getZugehoerigkeitsgrad(int i,double input)" in der Klasse FuzzyEingangsSet blieb der Fall unberücksichtigt, dass exakt die Spitze einer Fuzzy-Größe getroffen wird.
Dies wurde folgendermaßen korrigiert:

statt: 
...
        if(i>0 && input<maxpos[i]) //positive Steigung
...
        if(i<maxpos.length-1 && input>maxpos[i]) //negative Steigung
...
heißt es jetzt:
...
        if(i>0 && input<=maxpos[i]) //positive Steigung
...
        if(i<maxpos.length-1 && input>=maxpos[i]) //negative Steigung
...

Code 0-3: Korrektur in getZugehoerigkeitsgrad(...).

Die Umsetzung des Fuzzy-Reglers wird wieder direkt in die Java-Klasse Antrieb eingefügt:

package opti;
import java.awt.*;
import fuzzy.*; //Fuzzy-Package importieren.
public class Antrieb extends Simulationsmodell
{
//Fuzzy-Regler einfügen:
    FuzzyRegler fuzzyregler = null;
    public Antrieb()
    {
        super(2); //Zwei Simulationsgleichungen
        //Fuzzy-Regler initialisieren:
        //1. Fuzzy-Regler erstellen:
        fuzzyregler = new FuzzyRegler(); 
        //2. Fuzzy-Eingangs-Sets erstellen:
        FuzzyEingangsSet[] fes = new FuzzyEingangsSet[2];
        FuzzyEingangsSet   phi   = new FuzzyEingangsSet();
        phi.erzeugeFuzzyGroessen(5);
        phi.verteileFuzzyGroessenGleichmaessig(-1.0,1.0);
        fes[0] = phi;        
        FuzzyEingangsSet   omega   = new FuzzyEingangsSet();
        omega.erzeugeFuzzyGroessen(5);
        omega.verteileFuzzyGroessenGleichmaessig(-20.0,20.0);
        fes[1] = omega;        
        fuzzyregler.setFuzzyEingangsSet(fes);
        //3. Fuzzy-Ausgangs-Set erstellen:
        FuzzyAusgangsSet fas = new FuzzyAusgangsSet();
        fas.erzeugeFuzzyGroessen(5+2); //Fünf Fuzzygrößen und Minimum und Maximum
        fas.verteileFuzzyGroessenGleichmaessig(-5.0,5.0);
        fuzzyregler.setFuzzyAusgangsSet(fas);
        //4. Fuzzy-Regeln hinzufügen:
        int[][] regeln = new int[20][];
//     PNG PNK PNN PPK PPG
//
//WNG  FNN FPG FPG  -  FNN
//
//WNK  FNN FPK FPK  -  FNN
//
//WNN  FNN FPK  -  FNK FNN
//
//WPK  FNN  -  FNK FNK FNN
//
//WPG  FNN  -  FNG FNG FNN  //Spaltenweise umgesetzt:
        regeln[0]  = new int[] {2, 0,0, 1,0};
        regeln[1]  = new int[] {2, 0,0, 1,1};
        regeln[2]  = new int[] {2, 0,0, 1,2};
        regeln[3]  = new int[] {2, 0,0, 1,3};
        regeln[4]  = new int[] {2, 0,0, 1,4};
        regeln[5]  = new int[] {4, 0,1, 1,0};
        regeln[6]  = new int[] {3, 0,1, 1,1};
        regeln[7]  = new int[] {3, 0,1, 1,2};
        regeln[8]  = new int[] {4, 0,2, 1,0};
        regeln[9]  = new int[] {3, 0,2, 1,1};
        regeln[10] = new int[] {1, 0,2, 1,3};
        regeln[11] = new int[] {0, 0,2, 1,4};
        regeln[12] = new int[] {1, 0,3, 1,2};
        regeln[13] = new int[] {1, 0,3, 1,3};
        regeln[14] = new int[] {0, 0,3, 1,4};
        regeln[15] = new int[] {2, 0,4, 1,0};
        regeln[16] = new int[] {2, 0,4, 1,1};
        regeln[17] = new int[] {2, 0,4, 1,2};
        regeln[18] = new int[] {2, 0,4, 1,3};
        regeln[19] = new int[] {2, 0,4, 1,4};
        fuzzyregler.setFuzzyRegeln(regeln);        
    }
    public double[] berechneRechteSeite(double[] yalt, double t)
    {
        double FA = fuzzyregler.berechneAusgang(yalt);
        double m = 1.0;
        double r = 0.5;
        double d = 0.05;
        double g = 9.81;
        double J = 0.25*m*(0.5*d)*(0.5*d)+(1.0/12.0)*m*(2.0*r)*(2.0*r);
        f[0] = yalt[1];
        f[1] = - (( m*r*g )/(J+m*r*r))*Math.sin(yalt[0]) + ((2.0*r)/(J+m*r*r))*Math.cos(yalt[0])*FA ;
        return f;
    } 
}

Code 0-4: Klasse Antrieb mit Hängependel-Modell und Fuzzy-Regler.

fuzzypendel.zip - Fuzzy geregeltes Pendel als Java-Simulation.

Bild 0-1: Simulationsverlauf des Fuzzy-geregelten Hängependels.