kramann.info
© Guido Kramann

Login: Passwort:










Robuste Systemintegration
1 Grundlagen
..1.1 Newton
....1.1.1 LinearSchwinger
....1.1.2 Daempfung
....1.1.4 ODE
....1.1.5 Saaluebung
..1.2 NewtonEuler
....1.2.1 Traegheitsmomente
....1.2.2 Modellgleichungen
....1.2.3 Einfachpendel
..1.3 Scilab
....1.3.1 Erste_Schritte
....1.3.2 Skripte
....1.3.3 Funktionen
..1.4 Laplace
....1.4.1 Eigenwerte
....1.4.2 PT1
..1.5 Regleroptimierung
....1.5.1 Guetefunktion
....1.5.2 Heuristiken
....1.5.3 Scilab
..1.6 Einstellregeln
....1.6.1 Totzeit
....1.6.2 Methode1
....1.6.3 Methode2
....1.6.4 Scilab
..1.7 Zustandsregler
..1.8 Polvorgabe
..1.8 Polvorgabe_alt
..1.9 Beobachter
....1.9.1 Haengependel
..1.10 Daempfungsgrad
..1.11 Processing
....1.11.1 Installation
....1.11.2 Erste_Schritte
....1.11.3 Mechatronik
....1.11.4 Bibliotheken
....1.11.5 Uebung
....1.11.6 Snippets
......1.11.6.1 Dateioperationen
......1.11.6.2 Bilder
......1.11.6.3 GUI
......1.11.6.4 Text
......1.11.6.5 PDF
......1.11.6.8 Maus
......1.11.6.10 Zeit
......1.11.6.13 Animation
......1.11.6.15 Simulation
....1.11.7 Referenzen
..1.12 Breakout
2 Beispiel
3 Beispielloesung
4 Praxis
5 javasci
6 Fehlertoleranz1
7 Reglerentwurf
..7.1 Sprungantwort
..7.2 Messdaten
..7.3 Systemidentifikation
..7.4 Polvorgabe
..7.5 Beobachter
..7.6 Robuster_Entwurf
..7.7 SIL
8 Systementwicklung
9 Arduino
..9.1 Lauflicht
..9.2 Taster
..9.3 Sensor
..9.12 Motor_PWM1
..9.13 Motor_PWM2_seriell
..9.14 Motor_PWM3_analogWrite
..9.15 Scheduler
..9.20 AV
..9.21 Mikrofon
..9.22 Universal
....9.22.1 Laborplatine
....9.22.2 LED_Leiste
....9.22.3 Motortreiber
....9.22.4 Sensoreingaenge
....9.22.5 Taster
....9.22.6 Tests
....9.22.7 Mikrofon
....9.22.8 Lautsprecher
....9.22.9 Fahrgestell
..9.23 Zauberkiste
..9.24 OOP
....9.24.1 Uebungen
..9.25 AVneu
....9.25.1 Tests
..9.26 DA_Wandler
..9.27 CompBoard
....9.27.1 Tastenmatrix
....9.27.2 ASCIIDisplay
..9.28 CTC
..9.29 Tonerzeugung
10 EvoFuzzy
..10.1 Fuzzy
....10.1.1 Fuzzylogik
....10.1.2 FuzzyRegler
....10.1.3 Uebung9
....10.1.5 Softwareentwicklung
......10.1.5.1 AgileSoftwareentwicklung
......10.1.5.2 FuzzyRegler
......10.1.5.3 Uebung
....10.1.6 Umsetzung
......10.1.6.1 FuzzyRegler
......10.1.6.2 Simulation
......10.1.6.3 Optimierung
......10.1.6.4 Uebung
....10.1.7 Haengependel
......10.1.7.1 Haengependel
......10.1.7.2 Simulation
......10.1.7.3 FuzzyRegler
......10.1.7.4 Optimierer
......10.1.7.5 Genetisch
....10.1.8 Information
....10.1.9 Energie
..10.2 Optimierung
....10.2.1 Gradientenverfahren
....10.2.2 Heuristiken
....10.2.3 ModifizierteG
....10.2.4 optim
..10.3 Genalgorithmus
..10.4 NeuronaleNetze
....10.4.1 Neuron
....10.4.2 Backpropagation
....10.4.3 Umsetzung
....10.4.4 Winkelerkennung
..10.5 RiccatiRegler
11 Agentensysteme
12 Simulation
20 Massnahmen
21 Kalmanfilter
..21.1 Vorarbeit
..21.2 Minimalversion
..21.3 Beispiel
30 Dreirad
31 Gleiter
..31.1 Fehlertoleranz
80 Vorlesung_2014_10_01
81 Vorlesung_2014_10_08
82 Vorlesung_2014_10_15
83 Vorlesung_2014_10_22
84 Vorlesung_2014_10_29
10.1.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 10.1.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 10.1.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 10.1.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 10.1.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 10.1.7.3-1: Simulationsverlauf des Fuzzy-geregelten Hängependels.