kramann.info
© Guido Kramann

DAY BY DAY zu SRT -- Simulations- und Regelungstechnik

(EN google-translate)

(PL google-translate)

Übersicht

Die vorliegende Seite stellt den Einstiegspunkt für diese Lehrveranstaltung dar und verzeichnet chronologisch die behandelten Inhalte.
Aber ein großer Teil der Inhalte findet sich nicht direkt hier, sondern die Seite hier verlinkt auf andere Bereiche von kramann.info.
Die Prüfung findet Semester begleitend in elektronischer Form statt (E-Test).

Die Lehrveranstaltung Simulations- und Regelungstechnik richtet sich an Studierende der Ingenieurwissenschaften im vierten Semester. In ihr werden regelungstechnische Konzepte auf dynamische Systeme angewendet. Dabei wird davon ausgegangen, dass es andere Lehrveranstaltungen gibt, in denen eingebettete Systeme und die Verwendung von Mikrocontrollern für die Bewältigung regelungstechnischer Aufgaben behandelt werden. Hier in Simulations- und Regelungstechnik kommen vornehmlich CAE-Werkzeuge (Computer Aided Engineering) zum Einsatz, namentlich Scilab, um dynamische Systeme zu modellieren und diese in Kombination mit Regelkreisen zu simulieren. Vermittelt wird deshalb Grundwissen in Simulations- und Regelungstechnik und praktisches Wissen zur Verwendung von Scilab.

Chronologisches Verzeichnis der im Verlauf des Semesters behandelten Themen

#1 Do 17.03.2022

Motivation

08_Technologie/10_Start2019/05_Systemtheorie -- Lottka-Volterra-Modell (Räuber/Beute)

08_Technologie/10_Start2019/04_Anthropozaen

Teil 1: Behandlung einführender Fragestellungen

Woher stammt die Regelungstechnik?
Was bedeutet der Begriff Simulationstechnik?
Warum werden dynamische Systeme modelliert und simuliert, anstatt sie einfach aufzubauen?

Fliehkraftregler nach James Watt -- https://www.youtube.com/watch?v=nnPImWZ1O2s

Dampfmaschine nach James Watt -- https://www.youtube.com/watch?v=n6B4ogz3sic

Norbert Wiener - Anti-Aircraft Gun 1950

Motivation / Diskussion ... Grey Walter's tortoises 1949

SYSTEM -- 50_Simulationstechnik/01_Systemtheorie/01_System

MODELL -- 50_Simulationstechnik/01_Systemtheorie/02_Modell

VERIFIKATION -- 50_Simulationstechnik/01_Systemtheorie/03_Verifikation

Teil 2: Einführung in Scilab

Scilab, erste Schritte -- 37_Scilab/01_Erste_Schritte

Scilab, Skripte -- 37_Scilab/02_Skripte

Scilab, Funktionen -- 37_Scilab/03_Funktionen

Teil 3: Scilab und ein erstes Simulationsmodell

Seerosenteich -- 50_Simulationstechnik/01_Systemtheorie/04_Seerosen

Euler-Integration -- 50_Simulationstechnik/01_Systemtheorie/05_Eulerintegration

Saalübung -- 50_Simulationstechnik/01_Systemtheorie/06_Saaluebung

Umsetzung mit Scilab -- 50_Simulationstechnik/01_Systemtheorie/07_scilab

Im Unterricht enstandener Code für die Euler-Integration des Seerosenteiches

clear;
w = 0:0.1:5;
A = 2^w;
plot(w,A);

//Numerische Lösung

Aalt = 1;
dw = 0.1;
k = log(2)

Averlauf = Aalt;
wverlauf = 0;

for w=dw:dw:5
    Aneu = Aalt + (k*Aalt)*dw;
    Averlauf = [Averlauf,Aneu];
    wverlauf = [wverlauf,w];
    Aalt = Aneu;
end

plot(wverlauf,Averlauf,'red');

Code 0-1: see.sce

#2 Do 24.03.2022

In der heutigen Lehrveranstaltung sollen die letzte Woche theoretisch eingeführten Inhalte praktisch umgesetzt und noch etwas erweitert werden. Neue präsentierte und erübte Themen sind:

Funktionen in Scilab
Die ODE-Funktion in Scilab und die Berechnung des "Seerosenteiches" damit
Modellierung und Simulation des Räuber-Beute-Modells mit Scilab als Übung
Das Runge-Kutta-Integrationsverfahren und seine Implementierung in Scilab

Funktionen in Scilab

37_Scilab/03_Funktionen

Die ODE-Funktion in Scilab und die Berechnung des "Seerosenteiches" damit

54_Kinetik/01_Newton/04_ODE

k=log(2);

function f = rechteSeite(t,A)
    f = k*A;
endfunction

//Zeitverlauf:
w = 0:0.1:5;

//Anfangsbedingung:
A0 = 1;
w0 = 0; //wird nicht benutzt, muss aber formal definiert sein.

A = ode(A0,w0,w,rechteSeite);

//Zum Vergleich:
Aexp = 2^w;

plot(w,A,'red',w,Aexp,'*blu');

Code 0-2: Im Unterricht entstanden: Umsetzung "Seerosenteich" mit ODE-Funkrtion

Bild 0-1: Plot zu obigem Skript.

plot()-Beispiel mit Achsbeschriftungen: 50_Simulationstechnik/01_Systemtheorie/07_scilab

ÜBUNG 1: Modellierung und Simulation des Räuber-Beute-Modells mit Scilab als Übung

Übernehmen Sie die Differentialgleichungen und die Parameter für das Räuber-Beute-Modell von hier:

08_Technologie/03_Lottka_Volterra

Teil 1: Nehmen Sie dann das Simulationsprogramm für den Seerosenteich von letzter Woche als Vorbild, um nun auf gleiche Weise das Räuber-Beute-Modell mit Scuilab zu modellieren und zu simulieren (numerische Integration mit Hilfe des Eulerschen Integrationsverfahrens).

clear
clc

Balt = 8;
Ralt = 2;
dt = 0.1;
a = 0.1;
b = 0.01;
c = 0.01;
d = 0.1;

Bverlauf = Balt;
Rverlauf = Ralt;
tverlauf = 0;

for t = dt:dt:400;
    Bneu = Balt + (a*Balt - b*Ralt*Balt)*dt;
    Rneu = Ralt + (c*Ralt*Balt - d*Ralt)*dt;
    Balt = Bneu;
    Ralt = Rneu;
    Bverlauf = [Bverlauf,Bneu];
    Rverlauf = [Rverlauf,Rneu];
    tverlauf = [tverlauf,t];
end

plot(tverlauf,Bverlauf,'--blu',tverlauf,Rverlauf,'red');
a = gca();
a.x_label.text = 't/s';
a.y_label.text = 'Populationen';
a.title.text = 'Räuber-Beute-Modell';
hl=legend(['Beute';'Räuber']);

Code 0-3: Studentische Lösung.

Bild 0-2: Plot zu obigem Skript. Die Zeitschrittweite für das Euler-Verfahren wurde hier zu groß gewählt, darum "explodiert" hier die Population.

Teil 2: Analysieren Sie nun die zuvor eingeführten Beispiele zur Verwendung der ODE-Funktion und übertragen Ihr Räuber-Beute-Modell auf ein neues Scilab-Skript, das eben diese ODE-Funktion zur numerischen Integration verwendet.

clear
clc

Balt = 8;
Ralt = 2;
dt = 0.1;
a = 0.1;
b = 0.01;
c = 0.01;
d = 0.1;

function f = rechteSeite(t,y)
   B = y(1,1);
   R = y(2,1);
   f(1) = a*B - b*R*B;
   f(2) = c*R*B - d*R;
endfunction

y0 = [Balt;Ralt];
t0 = 0;

t = 0:dt:400;

y = ode(y0,t0,t,rechteSeite);

tverlauf = t;
Bverlauf = y(1,:);
Rverlauf = y(2,:);

plot(tverlauf,Bverlauf,'--blu',tverlauf,Rverlauf,'red');
a = gca();
a.x_label.text = 't/s';
a.y_label.text = 'Populationen';
a.title.text = 'Räuber-Beute-Modell';
hl=legend(['Beute';'Räuber']);

Code 0-4: Gleiches System mit ODE integriert.

Bild 0-3: Besserer Verlauf gegenüber Euler. Das Euler-Verfahren führt zu einer negativen Dämpfung, die unrealistisch ist.

Das Runge-Kutta-Integrationsverfahren und seine Implementierung in Scilab

Hier finden Sie am Ende der Seite die Formulierung des Integrationsverfahrens nach Runge und Kutta: Wir werden es mit dem Euler-Verfahren vergleichen.

30_Informatik3/16_Nuetzliches/03_RungeKutta

Eine Umsetzung des Verfahrens mit Scilab findet sich hier:

62_Regelungssysteme/07_Einstellregeln/01_Totzeit

Übung 2: Räuber-Beute-Modell mit Runge-Kutta simulieren

Analysieren Sie die zuvor dargestellte Scilab-Funktion, die das Runge-Kutta-Integrationsverfahren implementiert und versuchen Sie nun auch damit das Räuber-Beute-Modell zu integrieren.
Vergleichen Sie die Ergebnisse aus den drei Simulationsvarianten (Euler, ODE, Rnge-Kutta).

Preview: Newton-Gleichung und linearer Feder-Masse-Dämpfer-Schwinger

54_Kinetik/01_Newton

54_Kinetik/01_Newton/01_LinearSchwinger

54_Kinetik/01_Newton/02_Daempfung

54_Kinetik/01_Newton/04_ODE

#3 Do 31.03.2022

Themen:

Wiederholung Integrationsverfahren und neu: Implementierung des Runge-Kutta-Integrationsverfahrens
Einführung des Newtonschen Gesetzes als theoretische Grundlage für die Modellierung dynmaischer mechanischer Systeme
Einführung des Feder-Masse-Dämpfer-Schwingers
Diskussion der Idee eines aktiven Dämpfers zur Beruhigung eines Systems, das keine natürlichen Dämpfungseigenschaften hat
Umsetzung eines ersten Regelkreises in Form eines aktiven Dämpfers

1. Wiederholung Integrationsverfahren und neu: Implementierung des Runge-Kutta-Integrationsverfahrens

30_Informatik3/16_Nuetzliches/03_RungeKutta

Eine Umsetzung des Verfahrens mit Scilab findet sich hier:

62_Regelungssysteme/07_Einstellregeln/01_Totzeit

Saalübung

Umsetzung der Simulation des "Räuber-Beute-Modells" mit Hilfe des Runge-Kutta-Integrationsverfahrens

clear
clc
function yneu=ruku(y,t,dt,modell)
       k1=modell(t,y);
       k2=modell(t+0.5*dt,y+0.5.*dt.*k1);
       k3=modell(t+0.5*dt,y+0.5.*dt.*k2);
       k4=modell(t+dt,y+dt.*k3);
       yneu=y+dt.*(k1+2.*k2+2.*k3+k4)./6;
endfunction

function ysim = rki(y0,t0,tvek,rechteSeite)
    zs = size(tvek);
    schritte = zs(2);
    ysim=y0;
    yalt=y0;
    tt  = tvek(1);
    dt  = tvek(2)-tvek(1);
    talt = tvek(1);
    for i=2:1:schritte
        t=tvek(i);
        yneu=ruku(yalt,t,dt,rechteSeite);   
        yalt=yneu;
        ysim=[ysim,yalt];
        tt  =[tt,t];
        dt = t - talt;
        talt = t;
    end
endfunction

Balt = 8;
Ralt = 2;
dt = 0.1;
a = 0.1;
b = 0.01;
c = 0.01;
d = 0.1;

function f = rechteSeite(t,y)
   B = y(1,1);
   R = y(2,1);
   f(1) = a*B - b*R*B;
   f(2) = c*R*B - d*R;
endfunction

y0 = [Balt;Ralt];
t0 = 0;

t = 0:dt:400;

y = rki(y0,t0,t,rechteSeite);

tverlauf = t;
Bverlauf = y(1,:);
Rverlauf = y(2,:);

plot(tverlauf,Bverlauf,'--gre',tverlauf,Rverlauf,'blk');
a = gca();
a.x_label.text = 't/s';
a.y_label.text = 'Populationen';
a.title.text = 'Räuber-Beute-Modell';
hl=legend(['Beute';'Räuber']);

Code 0-5: Runge-Kutta-Integrator wie ode() benutzen, am Beispiel des Räuber-Beute-Modells

2. Einführung des Newtonschen Gesetzes als theoretische Grundlage für die Modellierung dynmaischer mechanischer Systeme

54_Kinetik/01_Newton

In Worten: "Die Impulsänderung eines starren Körpers ergibt sich aus der Summe der an ihn angreifenden äußeren Kräfte."

3. Einführung des Feder-Masse-Dämpfer-Schwingers

54_Kinetik/01_Newton/01_LinearSchwinger

54_Kinetik/01_Newton/02_Daempfung

54_Kinetik/01_Newton/04_ODE

clear
clc

//Anfangsbedingungen
x0 = 1; //Anfangsauslenkung 1m
v0 = 0; //Anfangsgeschwindigkeit 0m/s
dt = 0.1;

//Modellparameter
m = 1;  // Masse 1kg
C = 1;  // Federkonstante 1 N/m

//  dx/dt = v
//  dv/dt = -(C/m)*x

//  C = 1 N/m
//  m = 1 kg

//  v0 = 0m/s
//  x0 = 1m

function f = rechteSeite(t,y)
   x = y(1,1);
   v = y(2,1);
   f(1) = v;
   f(2) = -(C/m)*x;
endfunction

y0 = [x0;v0];
t0 = 0;

t = 0:dt:40;

y = ode(y0,t0,t,rechteSeite);

x_verlauf = y(1,:);
v_verlauf = y(2,:);

plot(t,x_verlauf,'--blu',t,v_verlauf,'red');
a = gca();
a.x_label.text = 't/s';
a.y_label.text = 'y';
a.title.text = 'Linearer Feder-Masse-Schwinger';
hl=legend(['x/m)';'v/(m*s^-1)']);

Code 0-6: Modellierung und Simulation des lonearen Feder-Masse-Schwingers.

Bild 0-4: Plot zu obigem Skript.

..mit Dämpfung:

clear
clc

//Anfangsbedingungen
x0 = 1; //Anfangsauslenkung 1m
v0 = 0; //Anfangsgeschwindigkeit 0m/s
dt = 0.1;

//Modellparameter
m = 1;  // Masse 1kg
C = 1;  // Federkonstante 1 N/m
D = 0.1; // Dämpfungskonstante 0.1 Ns/m

//  dx/dt = v
//  dv/dt = -(C/m)*x

//  C = 1 N/m
//  m = 1 kg

//  v0 = 0m/s
//  x0 = 1m

function f = rechteSeite(t,y)
   x = y(1,1);
   v = y(2,1);
   f(1) = v;
   //f(2) = -(C/m)*x;
   f(2) = -(C/m)*x - (D/m)*v;
endfunction

y0 = [x0;v0];
t0 = 0;

t = 0:dt:40;

y = ode(y0,t0,t,rechteSeite);

x_verlauf = y(1,:);
v_verlauf = y(2,:);

plot(t,x_verlauf,'--blu',t,v_verlauf,'red');
a = gca();
a.x_label.text = 't/s';
a.y_label.text = 'y';
a.title.text = 'Linearer Feder-Masse-Schwinger';
hl=legend(['x/m)';'v/(m*s^-1)']);

Code 0-7: Gleiches System mit Dämpfungskraft.

4. Diskussion der Idee eines aktiven Dämpfers zur Beruhigung eines Systems, das keine natürlichen Dämpfungseigenschaften hat

Saalübung

Wie kann man sich praktisch eine aktive Dämpfung vorstellen?
Welchen Unterschied macht eine aktive im Vergleich zu einer passiven Dämpfung in der Modellbeschreibung aus?

5. Umsetzung eines ersten Regelkreises in Form eines PD-Reglers

Saalübung

Wie könnte man eine aktive Vorichtung ergänzen, die entgegen einer bestehenden Auslenkung arbeitet?
Einführung des Begriffs der negativen Rückkopplung

Preview

Regelungstechnische Grundbegriffe

62_Regelungssysteme/02_Heizregelkreis

#4 Do 07.04.2022

Themen:

Eigenwerte
Zustandsregler

Eigenwerte

50_Simulationstechnik/02_Eigenwerte

Bild 0-5: Tafelbild 1 zur Einführung der Eigenwertberechnung.

Bild 0-6: Tafelbild 2 zur Einführung der Eigenwertberechnung.

Übung zu Eigenwerten

Bestimmen Sie die Eigenwerte folgender linearer Differentialgleichungen zweiten zweiten Grades und überprüfen Sie im Anschluß Ihr Ergebnis auf Richtigkeit mittels spec(...) mit Hilfe von Scilab:

$ \ddot x = -x $

Formel 0-1: DGL. Nr.1

$ \ddot x = -x - \dot x $

Formel 0-2: DGL. Nr.2

$ \ddot x=x - \dot x $

Formel 0-3: DGL. Nr.3

$ 4 \ddot x =-2 \cdot x - \dot x $

Formel 0-4: DGL. Nr.4

Zustandsregler

64_Regelungssysteme/08_Polvorgabe

Übung zum Zustandsregler

Versehen Sie nachfolgendes dynamisches System mit einem Zustandsregler, der die Eigenwerte des Gesamtsystems nach -1+i und -1-i verschiebt.

Als Stellgröße gilt hier die externe Kraft F.

$ m \cdot \ddot x = -Cx + F $

Formel 0-5: mit m=1kg & C=1m/s & F ist die Stellkraft.

Bild 0-7: Tafelbild 1 zur konkreten Auslegung dieses Zustandsreglers, zunächst: Welche Bedeutung hat die unterschiedliche Lage der Eigenwerte.

Bild 0-8: Tafelbild 2 Ersatz der Stellgröße durch u = -R*y (Regalmatrix mal negativem Systemzustand).

Bild 0-9: Tafelbild 3 Bestimmung der veränderten Systemmatrix A*.

Bild 0-10: Tafelbild 4 Allgemeine Bestimmung der Eigenwerte, um schließlich r1 und r2 zu bestimmen.

Lösung ist: 
r1 = 1
r2 = 2

mit Scilab:

A = [0,1;-1,0]
B = [0;1];

R = ppol(A,B,[-1-%i,-1+%i]);

------------

Neue Aufgabe:

x.. = -x -v
..hierfür eine Zustandsregler finden, so, dass die EW liegen bei:
Lambda 1/2 = -1 +/- i*sqrt(3)/2

Vorab mit Scilab:
A2 = [0,1;-1,-1]
B = [0;1];
R = ppol(A2,B,[-1-%i*sqrt(3)/2,-1+%i*sqrt(3)/2])
...liefert:
R =    [0.75 ,  1]

Code 0-8: Lösung und neue Aufgabe

#5 Do 21.04.2022

Zur Konsolidierung des vor den Ostern eingeführten Verfahrens zur Auslegung von Regelkreisen mittels Polvorgabe (Eigenwert-Vorgabe), sollen im ersten Teil weitere Übungsaufgaben gerechnet werden. Im zweiten Teil wird ein komplexeres Simulationsmodell hergeleitet, nämlich das eines autonomen Fahrzeugs, das mit einer Lenkregelung versehen werden soll.

Teil 1 -- Übungsteil (gerne in Zweiergruppen)

Aufgabe 1:

Bestimmen Sie für nachfolgende Systemmatrizen die Eigenwerte von Hand und überprüfen Ihre Ergebnisse mit Hilfe von Scilab. Geben Sie außerdem jeweils an, ob das entsprechende System stabil, instabil, oder grenzstabil ist und ob es schwingungsfähig ist, oder nicht:

$ A=\left[\begin{array}{cc}0 & 1 \\ -2 & 0\end{array}\right] $

Formel 0-6: Systemmatrix 1.

$ A=\left[\begin{array}{cc}0 & 1 \\ 2 & 0\end{array}\right] $

Formel 0-7: Systemmatrix 2.

$ A=\left[\begin{array}{cc}0 & 1 \\ 2 & -2\end{array}\right] $

Formel 0-8: Systemmatrix 3.

$ A=\left[\begin{array}{cc}0 & 1 \\ -2 & -2\end{array}\right] $

Formel 0-9: Systemmatrix 4.

Aufgabe 2:

Gegeben sei ein lineares Feder-Masse-Dämpfer-System mit folgenden Parametern: m=2kg, C=1N/m, D=0Ns/m.

Leiten Sie die Modellgleichung des Systems mit Hilfe der Newton-Gleichung her.
Geben Sie die Lage der Eigenwerte des Systems an (Bitte von Hand berechnen und mit Scilab überprüfen).

Über eine zusätzlich auf den starren Körper einwirkende Stellkraft F, soll nun ein Zustandsregler umgesetzt werden. Die beiden Eigenwerte des geregelten Systems sollen beide bei -2 liegen. Das heißt, die haben keinen Imaginärteil. Hinweis: Man nennt so etwas eine doppelte Polstelle.

Stellen Sie die Modellgleichungen für das um den Zustandsregler ergänzten System auf.
Bestimmen Sie die Komponenten r1 und r2 der Regelmatrix, wenn die gewünschten Eigenwerte beim geregelten System gelten sollen.
Überprüfen Sie Ihr Ergebnis mit Hilfe von ppol mit Scilab.

Teil 2: Einfache Modellierung eines autonomen Vehikels

Das Nachfolgende ist eine Zusammenfassung. Das Modell wird im Unterricht Schritt für Schritt hergeleitet. Statt es wie nachfolgend mit Java/Processing zu simulieren, wird noch eine Version mit Scilab erarbeitet werden.

Hilfs-Beispiele:

78_Processing/06_Snippets/13_Animation -- Animation mit Processing

30_Informatik3/16_Nuetzliches/03_RungeKutta -- Formel des Runge-Kutta-Integrators

78_Processing/06_Snippets/15_Simulation -- Simulationsmodell mit Processing unter Verwendung des Runge-Kutta-Integrators

80_Robuste_Systemintegration/30_Dreirad -- Früheres komplettes Beispiel

MECHANIK

Bild 0-11: AV

Bild 0-12: Geometrie und Kräfte

Bild 0-13: Geometrie und Kräfte

Bild 0-14: Mögliche Regegelung

UMSETZUNG IN PROCESSING

Schritt 1: Koordinatensystem passend transformieren -- AV001_Koordinatensystem.zip

Schritt 2: Visualisierung des Fahrzeugs -- AV002_Koordinatensystem.zip

Schritt 3 (unvollständig): Simulation und Animation bei konstanten Antriebskräften.

Schritt 4, vollständig, aber ohne Radquerkraft schleudert das Fahrzeug: AV004_FirstExperiment.zip

Schritt 5, Querkraft entlang L-R implementiert: AV005_Querkraft.zip

Schritt 6, Darstellung der Trajektorie: AV006_SavePath.zip

Schritt 7, Lenkregelung, um das Fahrzeug auf einer Kreisbahn zu halten: AV007_FeedbackControl.zip

Bild 0-15: Screenshot zu AV007.

#6 Do 28.04.2022

Die Verwendung eines Reglers in dem Modell des autonomen Vehikels soll erst noch zurück gestellt werden.

Statt dessen erfolgt nun die klassische Einführung der Regelungstechnik mittels Laplace-Transformation.

62_Regelungssysteme/04_Laplace

Eigenwerte können auch über Nullstellen des Nenner einer Übertragungsfunktion bestimmt werden. Nutzen Sie diese Möglichkeit bei der vorangehenden Übung (Formel 0-1 bis 0-4).

Einige Übertragungsfunktionen im Zeitbereich als Grundlage für Übungen

$ \ddot x + 3 x = 4 u $

Formel 0-10: a\right)

$ \dot x - x = u $

Formel 0-11: b\right)

$ 3 \ddot x + \dot x = u $

Formel 0-12: c\right)

$ \ddot x + x = u $

Formel 0-13: d\right)

$ \dot x + 2 x = u $

Formel 0-14: e\right)

$ \dot x - 3 x = u $

Formel 0-15: f\right)

$ \dot x + 5 x = 5 u $

Formel 0-16: g\right)

Schalten Sie a) und b) in Reihe und geben die Gesamtübertragungsfunktion im Lapalce-Bereich an.
Schalten Sie c) und d) in Reihe und geben die Gesamtübertragungsfunktion im Lapalce-Bereich an.
Schalten Sie e), f) und g) in Reihe und geben die Gesamtübertragungsfunktion im Lapalce-Bereich an.

#7 Do 05.05.2022

Themen:

Übertragungsfunktionen in Scilab simulieren
Die Auslegungsmethoden für Regelkreise nach Ziegler und Nichols

In der letzten LV wurde die Laplace-Transformation eingeführt und im Zusammenhang mit Übertragungsgliedern geübt.

Ferner wurde bereits gezeigt, wie Übertragungsfunktionen mit csim in Scilab simuliert werden können und wie genau dann mit ode zu verfahren ist, um identische Ergebnisse zu erhalten. Dies soll zunächst noch einmal wiederholt werden:

Übertragungsfunktionen in Scilab simulieren:

62_Regelungssysteme/01_day_by_day -- siehe 2 -- Dienstag 26.03.2019

Ein wichtiges Instrument, um ein Übertragungsverhalten zu charakterisieren, ist die Sprungantwort. Dazu gibt man einen konstanten Wert u an den Eingang der Übertragungsfunktion und plottet das sich daraus ergebende y/u = G(s) in seinem Verlauf im Zeitbereich. Etwas in der Art war schon Teil der Darstellung von Übertragungsfunktionen mit Scilab.

Mit Hilfe der Sprungantwort lassen sich Eigenschaften erkennen, wie:

Schwingungsfähigkeit: Kurve schwingt, statt beispielsweise "zu kriechen"
Stabilität: Endliche Eingangswerte führen nach endlicher Zeit zu endlichen Ausgangswerten (Einschwingen).

Übung 1

Plotten Sie mit Scilab für folgende Systeme den Einheitssprung. Führen Sie dazu die notwendige Laplace-Transformation aus und finden Sie selber eine sinnvolle Simulationsdauer:

$ \ddot x + \dot x + 3 x = 4 u $

Formel 0-17: a\right)

$ 3 \ddot x + \dot x = u $

Formel 0-18: b\right)

$ \ddot x + x = u $

Formel 0-19: c\right)

$ \dot x + 2 x = u $

Formel 0-20: d\right)

$ \dot x - x = u $

Formel 0-21: e\right)

Beispiellösungen nebst den Plots:

//Formel 0-17:
//   x.. + x. + 3x = 4u
//                 4
//   x/u = ------------------
//             s^2 + s + 3
//s als Argument für ein Polynom definieren:
s = poly(0,"s"); 
//Übertragungsfunktion definieren:
G = syslin('c',[4],[s*s+s+3]);
t=[0:0.01:10]; 
u=ones(1,1001);
y=csim(u,t,G);
subplot(121);
plot2d(t,y);
subplot(122);
plzr(G);

Code 0-9: zu Formel 0-17

Bild 0-16: Plot zu obigem Skript.

//Formel 0-21:
//   x.  -x = u
//                 1
//   x/u = ------------------
//               s - 1
//s als Argument für ein Polynom definieren:
s = poly(0,"s"); 
//Übertragungsfunktion definieren:
G = syslin('c',[1],[s-1]);
t=[0:0.01:10]; 
u=ones(1,1001);
y=csim(u,t,G);
subplot(121);
plot2d(t,y);
subplot(122);
plzr(G);

Code 0-10: Skript zu Formel 0-21

Bild 0-17: Plot zu obigem Skript.

Die Sprungantwort zu erzeugen, ist nur hier als Simulation ausgeführt. Bei realen Systemen wird dies typischerweise als Experiment ausgeführt.

Ein Vorgehen, bei dem auch ein Experiment mit der Regelstrecke durchgeführt wird und aus dem heraus dann ein passender Regler gefunden werden kann, stellen die beiden Varianten des Verfahrens nach Ziegler- und Nichols dar, die im folgenden behandelt werden sollen.

Da aber bei dem ersten Verfahren eine gewisse Totzeit bei der Regelstrecke Voraussetzung ist, wird diese zunächst eingeführt:

62_Regelungssysteme/07_Einstellregeln/01_Totzeit

Bild 0-18: Neu: Darstellung der Sprungantwort eines mit Zeitverzögerung behafteten Systems mit xcos.

xcos.zip -- xcos-Beispiel zum Herunterladen und entpacken.

(Code 0-1 dort wird gleich als Beispiel für die Anwendung der ersten Methode verwendet.)

Bild 0-19: Variante, hier mit angezeigten Simulationsbedingungen.

Die Auslegungsmethoden für Regelkreise nach Ziegler und Nichols

...mit xcos:


Mit Scicos ermittelt für:
          1
G(s) = ------- exp(-0.1*s)
        s + 1

Kkrit = 16,35
Tkrit = 0,388 s

P-Regler:
K = 0.5 Kkrit = 8,175

PI-Regler:
K = 0.45 Kkrit = 7,3575
TN = 0.85 Tkrit = 0,3298

PID-Regler
K = 0.6 Kkrit = 9,81
TN = 0.5 Tkrit = 0,194
TV = 0.12 Tkrit = 0,04656

Code 0-11: Musterlösung

Bild 0-20: Kkrit finden mit xcos

Bild 0-21: PID-Regler einbauen und testen mit xcos

z.zip -- Beide xcos-Umsetzungen.

Umsetzung der gleichen Aufgabe mit Scilab, vergl. Skript unten bei:

62_Regelungssysteme/07_Einstellregeln/01_Totzeit

clear();

xtot=0;

function f=modell(y,t,dt)
       x=y(1,1);

       Kkrit = 16.35;       
       xsoll = 1.0;
       //e     = xsoll - x;
       e     = xsoll - xtot;
       u=Kkrit*e;
       
       f(1,1)=-x+u;
endfunction

function yneu=ruku(y,t,dt)
       k1=modell(y,t,dt);
       k2=modell(y+0.5.*dt.*k1,t+0.5*dt);
       k3=modell(y+0.5.*dt.*k2,t+0.5*dt);
       k4=modell(y+dt.*k3,t+dt);
       yneu=y+dt.*(k1+2.*k2+2.*k3+k4)./6;
endfunction

tmax = 10.0;
dt   = 0.0001;
schritte = ceil(tmax/dt);

yalt = [0]';
ysim = yalt;
t=0.0;
tt=t;

Ttot = 0.1;
anztot = round(Ttot/dt)
xtotarr = zeros(anztot,1);

for i=1:1:schritte
    yneu=ruku(yalt,t,dt);   
    yalt=yneu;
    ysim=[ysim,yalt];
    tt  =[tt,t];
    t=t+dt;

    xtot = xtotarr(modulo((i-1),anztot)+1);
           xtotarr(modulo((i-1),anztot)+1)=yneu(1);
end

plot(tt,ysim(1,:))

Code 0-12: Finden von Kkrit

62_Regelungssysteme/07_Einstellregeln/02_Methode1

62_Regelungssysteme/07_Einstellregeln/03_Methode2

Übung 2

Siehe Übung 5 hier:

62_Regelungssysteme/07_Einstellregeln/04_Scilab

Um Methode 1 anzuwenden, müssen hier die Systeme in den Zeitbereich zurück transformiert und mit dem Skript mit Totzeit simuliert werden. Jedoch werden wir in diesem Kurs zunächst auf xcos ausweichen, um genau das erst einmal nicht machen zu müssen. Somit:

Versuchen Sie mit Hilfe des xcos-Beispiels einen Weg zu finden, das erste Verfahren nach Ziegler und Nichols mit xcos umzusetzen.
Lösen Sie Systeme mit Totzeit zunächst mir xcos und erst dann im Zeitbereich mit ode.

Methode 2 soll einfach durch Anlegen eines Lineals (Wendetangente) an einen groß dargestellten Plot angewendet werden.

nur falls zuviel Zeit übrig: Herleitung mechanisches Modell für Invertierendes Pendel.

62_Regelungssysteme/98_day_by_day_WS2021_SoSe21 -- siehe dort: "Musterlösung zu Übung 2 vom 15.12.2020"

#8 Do 12.05.2022

Themen

Modellieren eines invertierenden Pendels
Linearisieren des Modells
Auslegung eines Zustandsreglers
Auslegung eines Reglers nach der Methode von Ziegler und Nichols nach Hinzufügen eines Totzeitelements

Früheres Tafelbild zur Modellbildung, siehe dort Bild 0-2 und 0-3:

62_Regelungssysteme/98_day_by_day_WS2021_SoSe21

invers.zip -- Scilab-Skripte als Musterlösung.

#9 Do 19.05.2022

...weiter mit dem invertierenden Pendel

Themen:

Einbau von Totzeit in das Simulationsmodell
Anwendung der ersten Auslegungsmethode nach Ziegler und Nichols auf das invertierende Pendel
Ausregeln des gesamten Systemzustands mit Hilfe eines Zustandsreglers

Zur Übersicht sind hier noch einmal die Herleitung und die Ergebnisse dargestellt:

Modell des invertierenden Pendels:

Bild 0-22: Herleitung zum invertierenden Pendel, Teil 1.

Bild 0-23: Herleitung zum invertierenden Pendel, Teil 2.

$ \ddot \phi = \frac {-m \cdot h^2 \cdot \dot \phi ^2 \cdot \sin \phi \cdot \cos \phi + h \cdot m \cdot g \cdot \sin \phi + h \cdot \cos \phi \cdot F_A}{J+m \cdot h^2 \cdot \left( \sin \phi \right)^2} $

Formel 0-22: Modellteil des invertierenden Pendels für die Verkippung \phi .

$ \ddot x = \frac {F_A}{m} $

Formel 0-23: Modellteil des invertierenden Pendels für die Position x auf der Schiene.

Linearisierung

$ \ddot \phi = \frac {h \cdot m \cdot g \cdot \phi + h \cdot F_A}{J} $

Formel 0-24: Erster Modellteil nach der Linearisierung.

Hier tritt deutlich die In- bzw. Grenzstabilität des Ausgangssystems zutage: kein negatives Vorzeichen vor dem Termin mit phi.

Quadratische Terme entfallen, phi statt sin(phi), 1 statt cos(phi) gemäß Taylor-Entwicklung.

$ \ddot x = \frac {F_A}{m} $

Formel 0-25: Der zweite Modellteil ist bereits linear.

1. Einbau von Totzeit in das Simulationsmodell

Vergleiche das Beispiel hier:

62_Regelungssysteme/07_Einstellregeln/01_Totzeit

ÜBUNG:

Wenden Sie das Verfahren nach Ziegler und Nichols auf das vorbereitete Simulationsskript an.

invers_totzeit.zip

2. Anwendung der ersten Auslegungsmethode nach Ziegler und Nichols auf das invertierende Pendel

62_Regelungssysteme/07_Einstellregeln/02_Methode1

3. Ausregeln des gesamten Systemzustands mit Hilfe eines Zustandsreglers

Da hier neben der Verkippung nun auch das Verfahren auf der x-Achse hinzukommt, erhalten wir vier Differentialgleichungen erster Ordnung, um das System zu beschreiben und in der linearisierten Fassung eine Systemmatrix der Größe 4 mal 4.

Wir werden ppol in Scilab verwenden, um den Zustandsregler auszulegen.

invers_4mal4.zip -- Ausregeln des Gesamtzustands mit einem Zustandsregler.

#10 Do 02.06.2022

Themen

Behandelte Themen
Ergänzungen
ÜBUNG: Modellierung und Regelung eines hängenden Pendels
ÜBUNG: Modellierung und Regelung eines Zwei-Masse-Schwingers

1. Behandelte Themen

Zur Orientierung folgt hier eine Liste der in der Lehrveranstaltung behandelten Themen ohne Anspruch auf Vollständigkeit. Diese Themen sind prüfungsrelevant. Das heißt, diese Themen sollten Ihnen geläufig sein und deren zugrundeliegende Theorie kann in anderen Aufgaben auftauchen.

"Seerosenteiche" (Modell in Form einer linearen Differentialgleichung)
Parameterbestimmung aus Messungen und Anfangsbedingungen
Newton-Gleichungen als theoretische Grundlage zur Modellierung mechanischer dynamischer Systeme
Euler-Integrationsverfahren
Runge-Kutta-Integrationsverfahren
Scilab als geläufiges CAE-Tool, insbesondere auch: Funktionen schreiben.
Totzeit und deren Implementierung in Scilab
Linearer Feder-Masse-Dämpfer-Schwinger
Grundlegende Begriffe in der Regelungstechnik
Laplacetransformation im Rahmen linearer dynamischer Systeme
PnTt-Übertragungsglieder
Sprungantwort
Hin- und Rücktransformation Laplace/Zeitbereich, sowie csim (Scilab)
Eigenwerte (Bedeutung in der Mechanik, Berechnung aus Systemmatrix und als Polstellen der Laplace-Transformierten)
Auslegen eines Zustandsreglers von Hand und mit ppol (Scilab)
Erste Methode zur Auslegung eines Reglers nach Ziegler und Nichols
Euler-Gleichung zur Modellierung rotatorischer mechanische Systeme
Kinematik (Koordinatentransformation in der Ebene verdrehter und verschobener Körper)
Linearisieren einer nicht linearen Differentialgleichung
Invertierendes Pendel als Modell und mit Zustandsregler
Ergänzen "virtueller" Systemzustände, insbesondere um das Integral von Zuständen in der Simulation zur Verfügung zu stellen.

2. Ergänzungen

Eine Reihe nicht unwichtiger Themen innerhalb der klassischen Regelungstechnik sollten wenigstens kurz angesprochen werden, auch wenn sie im Rahmen dieser Lehrveranstaltung nicht mit ausführlichen Beispielen vertieft werden.

62_Regelungssysteme/07_Einstellregeln/03_Methode2 -- Methode 2 nach Ziegler und Nichols

62_Regelungssysteme/07_Einstellregeln/05_Daempfungsgrad -- Dämpfungsgrad und technische Stabilität

62_Regelungssysteme/05_Regleroptimierung/07_Stoerverhalten -- Definition Störverhalten

62_Regelungssysteme/11_Stabilitaet -- Asymptotische Stabilität und das Nyquist-Kriterium

62_Regelungssysteme/11_Stabilitaet/04_Bode -- Das Bode-Diagramm

62_Regelungssysteme/08_Polvorgabe -- Koordinatentransformation bei der Polvorgabe #hl

Ausblick auf SRT2:

62_Regelungssysteme/09_Beobachter -- Zustandsregler mit Beobachter

62_Regelungssysteme/05_Regleroptimierung -- Optimierungsmethoden

62_Regelungssysteme/18_Fuzzy -- Fuzzy-Regler (Softcomputing)

62_Regelungssysteme/13_Analyse/02_Nichtlinear -- Regelung nicht-linearer Systeme

3. ÜBUNG: Modellierung und Regelung eines hängenden Pendels

Ein homogener zylindrischer Stab, Länge 1m, Radius 0.1m, Masse 1kg, sei an einem Ende gelenkig mit einem rotatorischen Freiheitsgrad aufgehangen und der Schwerkraft ausgesetzt.

Die Ruhelage phi=0rad soll im hängenden Zustand sein, eine Drehung gegen den Uhrzeigersinn sei positiv (phi>0).

Skizzieren Sie das System.
Schneiden Sie das System frei.
Stellen Sie die dynamischen Gleichungen auf.
Erstellen und testen Sie ein Simulationsmodell mit Scilab (AB!=0).
Ersetzen den Integrator durch einen RungeKutta-Integrator und fügen 0,1s Totzeit hinzu.
Wenden Sie auf das System die erste Methode nach Ziegler und Nichols an und legen einen PID-Regler für das System aus.
Ergänzen Sie den gefundenen PID-Regler im Simulationsprogramm.
Linearisieren Sie nun die dynamische Gleichung, und legen damit einen Zustandsregler für das System mittels ppol aus.
Simulieren (testen) Sie den gefundenen Zustandsregler gemeinsam mit dem nicht linearisierten Modell.
Versuchen Sie den gleichen Zustandsregler von Hand (Handrechnung ohne ppol) auszulegen.

4. ÜBUNG: Modellierung und Regelung eines Zwei-Masse-Schwingers

Schauen Sie sich das System hier an:

54_Kinetik/01_Newton/05_Saaluebung -- siehe ganz unten.

Versuchen Sie selber die Modellierung so hinzubekommen, dass sich die gleiche Systemmatrix ergibt, wie bei dem angegebenen Link.

Legen Sie nun einen Zustandsregler mittels ppol für das System aus.

#11 Do 09.06.2022 Probe-E-Test

#12 Do 16.06.2022

Themen

Herleitung der dynamischen Gleichungen für ein lineares eindimensionales Zwei-Massen-Feder-Dämpfer-System
Entwicklung eines Zustandsregler für des Systems mit Scilab mittels ppol
Interpretation der Ergebnisse zu diesem System
Herleitung des Frequenzgangs
Verwendung des Frequenzgangs zur Bestimmung des Bodediagramms und Anwendung des Bodediagramms zur Reglerauslegung

1.,2.,3. werden im Unterricht an der Tafel entwickelt.

clear;
C1 = 1; // N/m
C2 = 1; // N/m
C3 = 1; // N/m
m1 = 1; //kg
m2 = 1; //kg
A = [     0,      1,   0,         0;
     (-C1-C2)/m1, 0,   C2/m1,     0;
          0,      0,   0,         1;
          C2/m2,  0, (-C2-C3)/m2, 0];

disp(A);
clean(spec(A))
disp("Regelmatrix, wenn nur FA da ist:");
EW = [-1.7320508+%i*1.7320508,-1.7320508-%i*1.7320508,-1+%i,-1-%i]
B  = [0;1/m1;0;0]
RA = ppol(A,B,EW)



disp("Regelmatrix, wenn FA und FB da sind:");
EW = [-1.7320508+%i*1.7320508,-1.7320508-%i*1.7320508,-1+%i,-1-%i]
BB  = [0,0;1/m1,0;0,0;0,1/m2]
RAB = ppol(A,BB,EW)


function f = rechteSeiteA(t,y)
    f = (A-B*RA)*y; 
endfunction

function f = rechteSeiteB(t,y)
    f = (A-BB*RAB)*y; 
endfunction

t = linspace(0,30,3000);
y0 = [1,0,2,0]';
t0 = 0;
yA  = ode(y0,t0,t,rechteSeiteA);
yB  = ode(y0,t0,t,rechteSeiteB);

plot(t,yA(1,:)','red--',t,yA(3,:)','blu--',t,yB(1,:)','blk',t,yB(3,:)','gre');

Code 0-13: Im Unterricht hierzu entstandener Scilab-Code.

Bild 0-24: Zugehöriger Plot.

4., siehe:

62_Regelungssysteme/11_Stabilitaet/02_Nyqusitkriterium

5., siehe:

62_Regelungssysteme/11_Stabilitaet/04_Bode

Übung

Gegeben sei folgendes dynamische System:

$ 2 \cdot \ddot x = -4x + F $

Formel 0-26: Lineares dynamisches System im Zeitbereich.

x sei die Zustandsgröße. F sei die Stellgröße.

Transformieren Sie das System in den Laplacebereich.
Legen Sie für das System einen PID-Regler nach der ersten Methode von Ziegler und Nichols aus.
Erstellen Sie mit Scilab für den offenen Regelkreis von 2. das Bodediagramm.
Geben Sie die Phasenreserve an.
Bestimmen Sie mit Hilfe des Bodediagramms, ob das System technisch stabil ist.
Erstellen Sie mittels Scilab nun auch für das gleiche System einen Zustandsregler, bei dem auch das Integral der Regelabweichung als Zustand mit verwendet wird.
Kann das so gewonnene Ergebnis des Zustandsregler auch von Hand gewonnen werden?
Vergleichen Sie das Ergebnis für den Zustandsregler mit dem gewonnenen Regler nach Ziegler und Nichols.