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
10.1.6.2 Verknüpfung des Antriebs mit einem Fuzzy-Regler und Simulation.

Nun soll der Antrieb aus Kapitel 6.1 mit einem passenden Fuzzy-Regler versehen werden. Zunächst werden Modell und Simulator ohne Regler bereitgestellt:

Bereitstellen von Antriebs-Modell und Simulator ohne Regler:

  • Eine passende Simulation steht bereit in Form des Programms TestAntrieb.java, bzw. Antrieb.java im Package opti.
  • Mit dem Skript starten.bat kann das Programm kompiliert, gestartet und das Ergebnis in Scilab angeschaut werden.
  • Nachfolgend kann dieses Beispiel heruntergeladen werden:
antrieb2.zip - Stellt u.a. ein noch ungeregeltes Simulationsmodell für den Antrieb bereit.
package opti;
import java.awt.*;
public class Antrieb extends Simulationsmodell
{
    /**
    Die folgenden Variablen sind die Modellparameter, die später
    optimiert werden können.
    Als Startwert sind die zu erwartenden Extremwerte eingestellt, damit
    später automatisiert GUI-Elemente erzeugt werden können.
    Da positive Extremwerte vorgegeben sind, ist damit festgelegt, dass
    alle Modell-Parameter nicht negativ werden dürfen.
    */
//ACHTUNG: K und L sind gegenüber Scilab-Musterlösung vertauscht!
    public double K = 100000.0;
    public double L = 100000.0;
    public double M = 100000.0;
    public double pwm = -1023.0;
    public Antrieb()
    {
        super(2); //Zwei Simulationsgleichungen
    }
    public double[] berechneRechteSeite(double[] yalt, double t)
    {
        /**Eigentliche Bestimmung der rechten Seite (Steigungsvektor)*/
        f[0] = yalt[1];
        f[1] = - K*yalt[1] - L*yalt[0] + M*pwm;
        return f;
    } 
    /** paint(..) wird bei der Konsolenanwendung nicht verwendet.*/
    public void paint(Graphics2D g)
    {
    }
}

Code 10.1.6.2-1: Klasse Antrieb

package opti;
public class TestAntrieb
{
    public static void main(String[] args)
    {
        Antrieb antrieb = new Antrieb();
        RungeKuttaIntegrator rungekuttaintegrator = new RungeKuttaIntegrator();
        rungekuttaintegrator.add(antrieb);
//ACHTUNG: K und L sind gegenüber der Scilab-Musterlösung in Kaptiel 5.6 vertauscht!
        antrieb.K=1576.1789;
        antrieb.L=11542.314;
        antrieb.M=372.33722;
        antrieb.pwm = 1023.0;
        double dt = 0.001;
        double  t = 0.0;
        double[] y;
        double[] yalt = {0.0,0.0};
        for(int i=0;i<473;i++)
        {
            System.out.println(t+" "+yalt[0]);
            y = rungekuttaintegrator.zeitschritt(yalt,t,dt);
            yalt[0] = y[0];
            yalt[1] = y[1];
            t+=dt;
        }
    }
}

Code 10.1.6.2-2: Klasse TestAntrieb

Entwurf des Fuzzy-Reglers

  • An der Simulation der Sprungantwort ist zu sehen, dass maximal 30 erreicht wird (Einheit Omega/4).
  • Also wird als Sollwert 20 vorgegeben.
  • Der Fuzzy-Regler soll einfach aufgebaut werden:
  • Eingangsgröße soll nur die Regelabweichung e sein, Ausgangsgröße das PWM-Signal.
  • Die Fuzzy-Sets werden folgendermaßen entworfen:
  • Fuzzy-Eingangsgröße: E mit den Ausprägungen:
  • ENG - Regeldifferenz negativ groß
  • ENK - Regeldifferenz negativ klein
  • ENN - Regeldifferenz quasi Null
  • EPK - Regeldifferenz positiv klein
  • EPG - Regeldifferenz positiv groß
  • Fuzzy-Ausgangsgröße: P mit den Ausprägungen:
  • PNG - PWM negativ groß
  • PNK - PWM negativ klein
  • PNN - PWM quasi Null
  • PPK - PWM positiv klein
  • PPG - PWM positiv groß
  • E wird zunächst im Intervall +/-10 gleichverteilt.
  • P wird zunächst im Intervall +/-1023 gleichverteilt.
  • Intuitiv erstellte Fuzzy-Regeln:
  • WENN ENG DANN PNG
  • WENN ENK DANN PNK
  • WENN ENN DANN PNN
  • WENN EPK DANN PPK
  • WENN EPG DANN PPG
  • Um die Programmstruktur möglichst unverändert zu lassen, wird die Klasse Antrieb direkt mit dem Fuzzy-Regler versehen.
  • Die Klassen der Fuzzy-Regelung werden noch vorher in ein Package mit Namen fuzzy gelegt (s. antrieb3.zip).
package opti;
import java.awt.*;
import fuzzy.*; //Fuzzy-Package importieren.
public class Antrieb extends Simulationsmodell
{
    public double K = 100000.0;
    public double L = 100000.0;
    public double M = 100000.0;
    public double pwm = -1023.0;
//Fuzzy-Regler einfügen:
    FuzzyRegler fuzzyregler = null;
    private double[] e_aktuell = new double[1];
    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[1];
        FuzzyEingangsSet   regeldifferenz   = new FuzzyEingangsSet();
        regeldifferenz.erzeugeFuzzyGroessen(5);
        regeldifferenz.verteileFuzzyGroessenGleichmaessig(-10.0,10.0);
        fes[0] = regeldifferenz;        
        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(-1023.0,1023.0);
        fuzzyregler.setFuzzyAusgangsSet(fas);
        //4. Fuzzy-Regeln hinzufügen:
        int[][] regeln = new int[5][];
        regeln[0] = new int[] {0, 0,0};//WENN ENG DANN PNG
        regeln[1] = new int[] {1, 0,1};//WENN ENK DANN PNK
        regeln[2] = new int[] {2, 0,2};//WENN ENN DANN PNN
        regeln[3] = new int[] {3, 0,3};//WENN EPK DANN PPK
        regeln[4] = new int[] {4, 0,4};//WENN EPG DANN PPG
        fuzzyregler.setFuzzyRegeln(regeln);
    }
    public double[] berechneRechteSeite(double[] yalt, double t)
    {
        /**Eigentliche Bestimmung der rechten Seite (Steigungsvektor)*/
        e_aktuell[0] = 20.0 - yalt[0];
        pwm = fuzzyregler.berechneAusgang(e_aktuell);
        f[0] = yalt[1];
        f[1] = - K*yalt[1] - L*yalt[0] + M*pwm;
        return f;
    } 
    /** paint(..) wird bei der Konsolenanwendung nicht verwendet.*/
    public void paint(Graphics2D g)
    {
    }
}

Code 10.1.6.2-3: Modifizierte Klasse Antrieb mit Fuzzy-Regler.

  • Bei den anfänglichen Einstellungen ergibt sich folgender Verlauf:
Verlauf bei den intuitiv gewählten Fuzzy-Regeln.

Bild 10.1.6.2-1: Verlauf bei den intuitiv gewählten Fuzzy-Regeln.

antrieb3.zip - Antrieb mit Fuzzy-Regler.