kramann.info
© Guido Kramann

Login: Passwort:










13.7.3 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 FA.
  • 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 FA.
  • 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 13.7.3-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 13.7.3-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 13.7.3-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 13.7.3-4: Klasse Antrieb mit Hängependel-Modell und Fuzzy-Regler.

fuzzypendel.zip - Fuzzy geregeltes Pendel als Java-Simulation.
Simulationsverlauf des Fuzzy-geregelten Hängependels.

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