PWM-Füllstands-Regelung, simuliert mit Simulink (mit Cursor) und

Prof. Dr. R. Kessler, FH-Karlsruhe, Sensorsystemtechnik, PWM_Fuellstands_Regelung_2.doc, Seite 1/1
PWM-Füllstands-Regelung,
simuliert mit Simulink (mit Cursor)
und mit Tephys
A1
Sensor
für h4
Sensor
für h1
A2
A3
A4
BelüftungsRohr
h1
h3
h2
h4
Zufluß
Q1
Ausfluß
A12
A23
A34
A40
RückschlagVentil
Pumpe
Wasser
Vorrats-Wanne
Zusätzlich zu der bereits realisierten Simulation mit PID-Regler und mit
Zweipunktregelung (mit verzögert-nachgebenden Rückführung) soll hier noch die
Pulsweiten-Modulation (PWM) simuliert werden.
Die bisherige Füllstandsregelung mit Tephys-Simulation findet man unter:
http://www.home.hs-karlsruhe.de/~kero0001/Textfuel1/textfuel3.html
Die bisherige Füllstandsregelung mit Simulink-Simulation findet man unter:
http://www.home.hs-karlsruhe.de/~kero0001/fuel523simul/fuel523simul.html
Die Simulation der PWM-Regelung einer Strecke aus 4 gleichen PT1-Gliedern findet man
mit Simulink: http://www.home.hs-karlsruhe.de/~kero0001/pwmsimul/pwmsimul.html
mit Tephys:
http://www.home.hs-karlsruhe.de/~kero0001/PWM/PWM_PID_3.html
Ergebnis vorweggenommen
Erkenntnisse zum Vergleich PWM und „stetige“ PID-Regelung:
Wenn die Modulationsfrequenz fPWM „genügend groß“ gewählt wird, dann sind die
Kurven Regelgröße X (entspricht Höhe h4) und sogar Höhe h1 bei PWM-Betrieb nahezu
identisch mit den entsprechenden Ergebnissen bei „stetigem“ Betrieb. Aber es ergibt sich
der beabsichtigte Vorteil, dass die Pumpe nur entweder voll oder gar nicht fördert.
Über den Vorteil der PWM-Regelung gegenüber der PID-Regelung wird in dem zitierten Tephys-Text
zur PWM-Regelung nachgedacht. Daraus einige Zeilen kopiert und hier eingefügt (Schrift Arial):
Prof. Dr. R. Kessler, FH-Karlsruhe, Sensorsystemtechnik, PWM_Fuellstands_Regelung_2.doc, Seite 2/2
Jetzt soll aber wahlweise die Realisierung der Stellgröße Y auch als „pulsweiten-moduliertes“
Signal probiert werden. Wozu denn das? Man stelle sich vor, die Stellgröße Y soll eine Leistung von
Kilowatt oder mehr steuern. Dann würde ein „stetig“ arbeitendes „Stellorgan“ Probleme bringen.
Leichter könnte man die Kilowatts dadurch steuern, indem man sie nur „ein“ und „aus“- schaltet, z.B.
eine elektrische Heizung oder auch eine Pumpe. Die Schaltung einer elektrischen Heizung könnte
man z.B. mit einem „Halbleiter-Relais“ aufbauen, das mit Thyristortechnik „Puls-Pakete“ von der
Minimal-Länge einer halben Netzperiode beim Strom-Nulldurchgang ein- bzw. -ausschaltet.
Das Ganze klingt nach „Zweipunktregelung“, aber bitte mit „verzögert- nachgebender
Rückführung“.
Hier und heute zur Abwechslung mal „Pulsweitenmodulation“. Der „Modulator“ wird wie folgt
realisiert: Eine geeignete „Vergleichs-Spannung“ ( hier uV genannt) ist eine positive
Dreieckspannung (Maximalwert aV, Minimalwert 0, ..) mit der Frequenz fd . Die Spannung uV wird
verglichen mit der vom PID-Regler gelieferten stetigen Stellgröße (diese wird ab jetzt YPID genannt).
Der „Vergleicher“ soll bewirken, dass die wirklich auf die Strecke einwirkende Stellgröße (nach wie vor
Y genannt) nur Ein/Aus-Verhalten hat.
Der Vergleicher arbeitet nach dem einfachen Prinzip: wenn die PID-Stellgröße YPID größer als der
momentane Wert uV der Vergleichs-Spannung ist, dann ist die Stellgröße Y „high“ und liefert den Wert
aYPW , sonst den Wert Null. In Tephys-Formulierung: YPW = aYPW * ja( YPID – uV ) .... In
MATLAB wäre das YPW = aYPW * ( YPID > uV ), in SIMULINK müsste man ein entsprechendes
Blockschaltbild malen, so wie im nachfolgenden Bild angedeutet.
Mit dem Wahlschalter kann man die Art der verwendeten Stellgröße wählen: Beim Parameter pid =1
ist Y = YPID (also die stetige Stellgröße ), bei pid = 0 ist Y=YPW (also die Pulsweiten-Stellgröße)
pid
W
YPID
PID-Regler
Strecke
X
DreieckGenerator
aYPW
uV
Vergleicher
X
Y
YPW
WahlSchalter
Es haben sich also drei neue Parameter ergeben, nämlich die Dreieckfrequenz fd, die
Dreieckamplitude aV und die Amplitude aYPW des Pulsweitensignals. Ziel des nachfolgenden
Textes ist es, für die vorliegende Aufgabe diese drei neuen Parameter zu optimieren, so dass die
Regelung mit Pulsweiten-Stellgröße möglichst genau so gut ist wie die Regelung mit stetiger
Stellgröße Y.
Tephys-Simulation
Die nachfolgende Tephys-Datei ist entstanden aus der (in der oben zitierten TephysSimulation der homepage stehenden) Tephys-Datei 4ta_110.txt. Nur die 4
(groß geschriebenen) Zeilen 19, 20, 21, 22 sind anders. Sie realisieren die zusätzliche
Pulsweiten-Modulation (PWM)
Tephysdatei 4TAPWM1.TXT
1 W0 = aW*ja(t-t1)*ja(t2-t)+aW0{ W0=Quelle für Sollwert. Summe von aW0 und
Rechteckimpuls
im Zeitbereich t1 bis t2..}
2 W = W+begr((W0-W)/tW,vma,vmi)*dt {W = Sollwert, anstiegsbegrenzt und verrundet}
3 h1 = h1+(Qz-A12*torr(h1-h2))*dt/A1 { h1 = Wasserhöhe im Tank 1. Info zu torr s.u.}
4 h2 = h2+(A12*torr(h1-h2)-A23*torr(h2-h3))*dt/A1 { h2= Wasserhöhe im Tank 2}
5 h3 = h3+(A23*torr(h2-h3)-A34*torr(h3-h4))*dt/A1 { h3=Wasserhöhe im Tank 3}
6 h4 = h4+(A34*torr(h3-h4)-A40*torr(h4))*dt/A1 { h4= Wasserhöhe im Tank 4}
Prof. Dr. R. Kessler, FH-Karlsruhe, Sensorsystemtechnik, PWM_Fuellstands_Regelung_2.doc, Seite 3/3
7 X = kh*h4 { X = Regelgröße, kh = Sensorkonstante}
8 S1 = ja(ja(h1-h1o)+S1*ja(h1-h1u)) { S1= „Schalter“ für Überlaufschutz. S1=1 oder 0.
Wenn S1=1, soll Pumpe nicht pumpen. Funktion: wenn h1 >h1o, dann S1=1, wenn h1 > h1u,
dann S1=“alter“ Wert von S1, wenn h1 < h1u, dann S1 = 0. Im Experiment wird S1 durch
invertierenden "OP- Schmitt-Trigger“ realisiert }
9 int = begr(int+(W-X)*dt/Ti,inma,-inma) { int = Integral(W-X)*dt/Ti,
aber int begrenzt auf inma, inmi. Si=1 oder 0, s. Zeile 10}
10 Eind = ja(konv)*(W-X)-nein(konv)*X
11 uM = begr(Ap*(kW*W-X+int+(Eind-uCd)*Td/Td1),Uma,Umi)
{ uMPID = Ausgang des PID-Reglers, begrenzt auf Uma, Umi. Im P-Kanal Abschwächung
auf kW*W. kW <1 kann „Überschwingen“ infolge I-Anteil verhindern}
12 uCd = uCd+(Eind-uCd)*dt/Td1
13 Ein2 = W-X-Kr*Ur { Ein2 = Eingang in den Zweipunkt-Regler: Kr= „Rückführ-Faktor“,
Ur = Ausgangs-Spannung des Rückführ-Netzwerks, vgl. Schaltung }
14 ST2 = ja(ja(Ein2-swo)+ST2*ja(Ein2+swo)) { ST2 = „Schmitt-Trigger“ der Zweipunktregelung.
ST2 =1 oder 0. Funktion: wenn Ein2 > swo, dann ST2=1, wenn Ein2+swo > 0, dann ST2 gleich
dem „alten“ Wert von ST2. Wenn Ein2 +swo <=0 (d.h. wenn Ein2 < -swo ), dann ST2 =0 }
15 uM2pkt = Uma*ST2 { uM2pkt = Motorspannung im Falle der Zweipunktregelung}
16 uCT = uCT+(uM2pkt-uCT)*dt/TTp { uCT = Spannung am Tiefpass-Kondensator
CT des
„Rückführ-Netzwerks“, Zeitkonstante ist TTp, Eingang ist die Motorspannung uM2pkt
. Vgl.
Schaltung }
17 uCH = uCH+(uCT-uCH)*dt/THp { uCH = Spannung am Hochpass-Kondensator CH des
Rückführ-Netzwerks, Zeitkonstante ist THp, Eingang ist uCT. Vgl. Schaltung }
18 Ur = uCT-Nach*uCH { Ur= Ausgangs-Spannung des Rückführ-Netzwerks. Falls Nach = 0,
dann Ur = uCT, falls Nach = 1, dann Ur = Ausgang des Hochpasses des Rückführ-Netzwerks }
19 SZ = saeg(fPWM*t)*aPWM {SZ = Sägezahnfunktion Frequenz fPWM,
Amplitude aPWM }
20 uPWM = ja(uM-SZ)*aPWM {uPWM= Stellgröße der Pulsweiten-Modulation:
hat Wert aPWM, wenn uM > SZ, sonst den Wert Null}
21 uM1 = nein(PWM)*uM+ja(PWM)*uPWM{ uM1 = Motorspannung bei
analoger Regelung (bei PWM=0) oder bei PWM-Regelung (bei PWM > 0) }
22 Qz = nein(S1)*kQ*(nein(zwei)*ja(uM1-3)*(uM1-3)+ja(zwei)*uM2pkt)
{ Qz = Förderleistung der Pumpe (Volumen pro Zeit) für die 3 Arten der Regelung.
Wenn der Überlaufschutz anspricht (also bei S1=1), dann Qz = 0.
Erst bei uM >3 Volt pumpt die Pumpe. }
23 t = t+dt { t = Zeit}
Hinweis zu Vergleich Tephys und Simulink:
Man beachte die enorm platz-sparende (und damit auch zeit-sparende!) Form
derTephys-Methode gegenüber der (nachfolgend dargestellten) SimulinkMethode.
In den obigen 23 Zeilen Tephys-Algorithmus ist „Alles“ enthalten. Um das Gleiche mit Simulink zu
erreichen, werden außer der Simulink-Schaltung noch 5 „Subsysteme“ benötigt (nur aus Platzgründen, sonst
würde die Simulink-Zeichnung total unübersichtlich werden!). Außerdem benötigt man zum „eleganten“
Laufenlassen der Simulink-Simulation noch für jeden Parametersatz je eine „Parameter-Datei“ und muss
mühsam eine „Stringdatei“ programmieren. Um den Cursor zu benutzen, benötigt man schließlich noch die
„Cursor-Datei“ simcurs2.m.
Bei Tephys ist das „Laufenlassen“ viel einfacher: Man wählt die Parameter und startet die Simulation (mit
Menüpunkt Run). In dem dann folgenden Tephys-Bild sind in der Parameter-Tabelle ALLE Parameter
enthalten. Mit dem Cursor kann man ohne den geringsten Aufwand die Werte abfragen und die Cursorwerte
werden automatisch als Tabelle ins Bild geschrieben. In das Tephys-Bild kann man einen Text schreiben (mit
Taste „T“) und mit der Taste „s“ wird das Tephysbild abgespeichert. Dabei kann man noch einen
Kommentar eingeben. Das auch in PCX-Form abgespeicherte Tephysbild kann man schließlich in ein WordDokument einfügen.
Prof. Dr. R. Kessler, FH-Karlsruhe, Sensorsystemtechnik, PWM_Fuellstands_Regelung_2.doc, Seite 4/4
Anschließend das Simulink-Modell fuelPWM1.MDL. Es ist entstanden aus der oben
zitierten Simulink-Schaltung der homepage. Die Pulsweiten-Modulation ist
hinzugekommen, realisiert mit dem Subsystem PWM. Dessen Innenschaltung s.u.
Datei fuelPW M1.MDL 4-Tank-FüllstandsRegelung. wahlweise PIDoder Zweipunkt-Regler mit verzögert-nachgebender Rückführung.
Zusätzlich Regelung mit Pulsweite-Modulation (PW M)
Überlaufschutz für Höhe h1
Schwellen h1o, h1u. Wenn
aktiv, pumpt Pumpe nicht.
kh
X
h1
uM
Q1
In1
Uma,0
QW
UnivReg
begrenzt
Int
W
kon
Out1
PWM
Mux
PWM
PWM
h4
aW=2; aW0=2; tW=0.2;vma=4.7;vmi=-4.7;
A1=0.00286;A2=A1;A3=A1;A4=A1; kh=10;
A12=7.4e-5; A23=6.45e-5; A34=8e-5; A40=3.5e-5;
t1=100; t2=300; dt=0.1; tmax=500; Uma=15;
vn2Pkt
zwei
h1o,h1u
f(u)= (u[2]<1)*(u[1]>3)*(u[1]-3)*kQ S4tank
int
Uma
Nach
f(u)
NOT
Programm laufen lassen: Die beiden rechten Textblöcke
einzeln markieren, kopieren, in MATLAB einfügen
und mit Return aktivieren.
Oder viel (!!) besser mit Parameter-Datei
fuelPWMx.m mit x= 21,22,23,24,25,26,27,35,45
h1o=0.95; h1u=0.90;
Ap=30; Td=6.37; Td1=0.5; Ti=64; inma=15; inmi=-15;
kQ=1.4e-5; kon=1; kW=1; zwei=0;fPWM=0.15; PWM=1;
Nach =0; TTp=6.4; THp=64; Kr=0.033; swo=0.07;
sim('fuelPWM1');
figure(1); plot(t,W, t,X, t,h1, t,Q1*0.5e4 ); grid;
Anschließend das Subsystem PWM: Es realisiert die Pulsweitenmodulation.
Es ist dem oben behandelten Tephys-Programm nachgedichtet
Subsystem PWM
1
In1
YPID
Funktion: Wenn der Steuereingang PWM=0 ist, dann legt der Schalter
die "kontimuierliche" PID-Stellgröße YPID auf den Ausgang out1.
Wenn PWM=1 ist, dann ist out1.=YPWM
YPWM: if YPID > SZ then YPWM= Uma else YPWM = 0
u * fPWM - floor (u * fPWM)
Uma
Erzeugung Saegezahn,
floor(x)=Ganzzahlteil von x
z.B. floor(17.8) = 17
2
PWM
>
1
Out1
Uma
YPWM
Schalter
SZ
NOT
Um die Parameter leicht variieren zu können, wird für jeden Parameter-Satz je eine eigene
„Parameter-Datei“ geschrieben (hier fuelPWMPar21C.m bis fuelPWMPar27C.m). Sie
ruft die (immer gleiche) „Stringdatei“ auf (hier fuelPWMS1C.m ), die ihrerseits die
Simulink-Simulation startet, die Ergebnis-Kurven zeichnet und den Cursor aufruft
Anschließend ein Beispiel für eine Parameter-Datei:
% Datei fuePWMPar21C Zum Betreiben der Simulink-Schaltung fuelPWM.MDL
%
% Zum Betreiben des FuellstandsRegelung-Modells fuelPWM.MDL (Matlab 5.3)
% 4-Tank-System. Höhe h4 soll geregelt werden, Zufluß zu Tank 1
Prof. Dr. R. Kessler, FH-Karlsruhe, Sensorsystemtechnik, PWM_Fuellstands_Regelung_2.doc, Seite 5/5
% Wahlweise PID-Regelung oder PWM oder
% Zweipunktregler mit verzögert-nachgebender Rückführung
% Die Parameter sind etwa wie bei Tephys-Datei 4ta152.txt
% 16.Juni 2000, auf Matlab 5.3 geändert am 8.6.2002
% einiges verbessert am 3.12.02., PWM am 10.5.2004
% Prof. Dr. R. Kessler, FH-Karlsruhe, Sensorsystemtechnik
%-----------------------------------------------------------------------%
% Die Parameter aus SIMULINK-Schaltung fuel532.m kopiert und hier eingefügt:
t1=100; t2=300; aW=2; aW0=2; tW=0.1;
vma=40; vmi=-40; dt=0.05;
A1=0.00286; A2=A1; A3=A1; A4=A1; kh=10;
A12=7.4e-5; A23=6.45e-5; A34=8e-5; A40=3.5e-5;
h1o=0.95;
h1u=0.90;
h1u=0.92;
Uma=15;
% Ti=64; inma=0.5; inmi=-0.5;kon=1;kW=1; Td=6.37; Td1=0.1; Ap=30;
Ti=1e5; inma=1e3; inmi=-1e3; kon=1; kW=1; Td=0; Td1=0.1; Ap=30;
zwei = 0; Nach=1; TTp=6.37; THp=64; Kr=0.033; swo=0.08;
kQ=1.4e-5; tmax=500;
PWM=1; % PWM-Regelung
fPWM=0.15; % Frequenz des Sägezahns
Bild=21;
fuelPWMS1C;
% Stringdatei fuelPWMS1C.m aufrufen mit Cursor
% Ende der Parameter-Datei fuelPWMP21C.m
Anschließend die (immer gleiche) Stringdatei fuelPWMS1C.m
% Datei fuelPWMS1C.m mit Cursor
% Stringdatei zum Betreiben der Simulink-Schaltung fuel523.MDL
% Wird aufgerufen von Parameter-Datei fuelPWMParxC.m mit x=1,2,3....
if Bild == 1 fuelPWM1; end; % Simulink-Schaltung auf Bildschirm
if Bild ==21 fuelPWM1; end; % Simulink-Schaltung auf Bildschirm
if zwei ==0; % Erzeugung von Strings für die Paramter-Ausgabe auf das Bild:
SPWM= ['PWM=',num2str(PWM),';'];
SfPWM= ['fPWM=',num2str(fPWM),';'];
SAp= ['Ap=',num2str(Ap),';'];
STd= ['Td=',num2str(Td),';'];
STi= ['Ti=',num2str(Ti),';'];
Sinma= ['inma=',num2str(inma),';'];
SkW= ['kW=',num2str(kW),';'];
Skon= ['kon=',num2str(kon),';'];
end;
if zwei == 1; % Erzeugung von Strings für die Paramter-Ausgabe auf das Bild:
SKr= ['Kr=',num2str(Kr),';'];
Sswo= ['swo=',num2str(swo),';'];
STTp= ['TTp=',num2str(TTp),';'];
STHp= ['THp=',num2str(THp),';'];
SNach=['Nach=',num2str(Nach),';'];
end;
% Erzeugung weiterer Strings für die Paramter-Ausgabe auf das Bild :
SBild= ['Bild=',num2str(Bild),';'];
Svma= ['vma=',num2str(vma),';'];
Svmi= ['vmi=',num2str(vmi),';'];
SaW= ['aW=',num2str(aW),';'];
SaW0= ['aW0=',num2str(aW0),';'];
StW= ['tW=',num2str(tW),';'];
St2= ['t2=',num2str(t2),';'];
Stmax= ['tmax=',num2str(tmax),';'];
Prof. Dr. R. Kessler, FH-Karlsruhe, Sensorsystemtechnik, PWM_Fuellstands_Regelung_2.doc, Seite 6/6
% Die Simulation starten:
sim('fuelPWM1'); % das ist für Matlab 5.3
set(0,'DefaultLineLineWidth', 1.5); % Kurven dicker; normal:1.0
figure(Bild);
if zwei == 0,
plot(t,W,t,X,t,h1,'k',t,int);
hold on;
set(0,'DefaultLineLineWidth', 1.0); % Kurven dünn
plot(t,Q1*0.5e4,'b'); hold off;
grid on;
end;
if zwei == 1,
plot(t,W,t,X, t,h1,'k'); hold on;
set(0,'DefaultLineLineWidth', 1.0); % Kurven dünn
plot(t,Q1*0.5e4,'b');
grid; hold off;
end;
axis([0,max(t),-0.5,aW+aW0+ 1]); % Definition der Achsen
if Bild ==1 disp ('Fadenkreuz verlangt Mausklick '); end;
gtext({[SBild,Svma,Svmi,SaW,StW]},'fontsize',11); % Textausgabe beginnt beim Fadenkreuz
if zwei == 0,
gtext({[SPWM,SfPWM,SAp,STd,STi,Sinma,Skon,SkW]},'Fontsize',12);
legend('W','X','Q1*0.5E4', 'h1','int'); % neu am 4.11.02
end;
if zwei == 1,
gtext({[SKr,Sswo,STTp,STHp,SNach]},'fontsize',11);
legend('W','X','h1','Q1*0.5e4'); % neu am 4.11.02
end;
%///////// cursor aktivieren:
if zwei == 0
%plot(t,W,t,X,t,Q1*0.5e4,'b',t,h1,'k',t,int);
tc= t; % Vektor der x-Achse, hier die Zeit
yc= [W'; X'; Q1'*0.5e4; h1'; int'];
% als Spaltenvektor, drum hier transponiert (x', y')
ofsc= [0, 0, 0, 0, 0,0 ]; % Der Vektor der y-Offsets
%.....5....1....5....2....5....1....5....3....5....4....5....
Stry=['
Zeit
W
X
Q1*0.5e4
h1
int'];
% Tabellenkopf
tab=1;% Tabelle auf Bildschirm erwünscht
% Jetzt Zeitcursor aufrufen
while 1 SimCurs2; end; % Aufruf des Cursors
end; % if zwei ==0
if zwei ==1
tc= t; % Vektor der x-Achse, hier die Zeit
yc= [W'; X'; h1'; Q1'*0.5e4'];
% als Spaltenvektor, drum hier transponiert (x', y')
ofsc= [0, 0, 0, 0, 0,0 ]; % Der Vektor der y-Offsets
%.....5....1....5....2....5....1....5....3....5....4....5....
Stry=['
Zeit
W
X
h1
Q1*0.5e4'];
% Tabellenkopf
tab=1;% Tabelle auf Bildschirm erwünscht
% Jetzt Zeitcursor aufrufen
while 1 SimCurs2; end; % Aufruf des Cursors
end; % if zwei ==1
xlabel('Zeit in sec')
%///////////////////
% Ende der StringDatei fuelPWMS1C.m mit Cursor
Und der Vollständigkeit wegen noch die Cursor-Datei simcurs2.m
% Datei SimCurs2.m Zeitcursor für Matlab-Bilder
% Bei Simulink sind die to workspace Felder Spaltenvektoren,
% also müssen die to workspace-Vektoren transponiert übertragen werden
% R. Kessler FH-Karlsruhe, 23.10.2003, Endfassúng 12.5.2004
% Zeit-Cursor: wird aufgerufen von "beliebigem" Programm
% übergabewerte:
Prof. Dr. R. Kessler, FH-Karlsruhe, Sensorsystemtechnik, PWM_Fuellstands_Regelung_2.doc, Seite 7/7
% xVektor tc, DatenMatrix yc, OffsetVektor ofsc, string Tabellenkopf
xlabel('Fadenkreuz auf Beginn der zu erstellenden Tabelle + Klick');
disp ('Fadenkreuz auf Beginn der zu erstellenden Tabelle + Klick');
[xtext,ytext] = ginput(1); % ziemlich oben z.B.rechte Hälfte
axen=axis; % V = AXIS returns a row vector containing the scaling
% for the current plot.
ystep = 0.06 * ( axen(4)-axen(3) ); % ySchrittweite der Tabelle
[zeil,spalt]=size(yc); % zeil = Anzahl Zeilen, spalt=Anzahl Spalten
kzeil=1:zeil; % Vektor
clear Zeittab; % Zunächst Löschen, damit bei Mehrfach-Aufruf
% dieses Cursorprogramms die Tabelle leer ist !!
N=0;
xlabel('
');
xlabel('Cursorwerte in Tabelle schreiben? Taste 1<Return>, Ende: Taste 6<Return>')
disp (' Cursorwerte in Tabelle schreiben? Taste 1<Return>, Ende: Taste 6<Return>')
disp('--------------------------------------------------------------------------')
while N < 10 % maximal N-1 Cursor-Klicks möglich
N=N+1;
Ax= input('');
if Ax == 1, % Taste 1 zum Beginn des Cursors
% Abfangen Klicken ausserhalb zulässigem x-Bereich
OK=-1;
while OK <0
OK=1;
[Xcurs,Ycurs]= ginput(1);
if ( Xcurs < min(tc)), OK =-1; end;
if ( Xcurs > max(tc)), OK =-1; end;
end;% while OK < 0
if N == 1,
text(xtext,ytext,Stry); % Tabellenkopf aufs Bild schreiben
end;
[wert,NrX]= min( abs( Xcurs- tc) );
zeit= tc(NrX);
Zeittab(N,1)= zeit; % 1. Spalte der Zeit-Tabelle
for ktab=1:zeil
Zeittab(N,ktab+1)= yc(ktab, NrX) ;
end;
% Zeile N der Tabelle aufs Bild schreiben:
text(xtext,ytext-N*ystep, num2str(Zeittab(N,1:1+zeil),3));
% Jetzt vertikale Linien bei den selektierten Zeiten:
hold on;
Lix(N,:)= [tc(NrX),tc(NrX)];
y_li_max=max(ytext,0.9*axen(4));
Liy=[0.9*axen(3),y_li_max];
plot(Lix(N,:),Liy,':m'); hold on; % Vertikale punktierte Linien
for kzeil =1:zeil,
% Kreise an den Cursor-Klick-Stellen
plot(Lix(N,:), yc(kzeil,(NrX))+ofsc(kzeil),'o');
end;
hold off
end; % if Ax == 1,
if Ax== 6, % Taste 6 zum Beenden des Cursors
% Jetzt Tabelle auf Bildschirm schreiben:
if (tab > 0) & (N > 1)
disp(Stry); % Tabellenkopf schreiben
disp( Zeittab(:,:) );
end;
break, % Cursor beenden
end; % if Ax== 6,
end;% while N < 10
xlabel('
')
break; % Rückkehr zur Aufrufstelle
% Hinweis:
% Die Tabelle im Bild ist eine Datei mit Namen Zeittab.
% Speichern der Tabelle mit dem neuem Namen Zeittab1:
%
save Zeittab1 Zeittab - ascii ;
% Laden der Tabelle:
%
Tab1=load('Zeittab1'), sie heißt jetzt Tab1
% Ende Matlab-Datei SimCurs2.m
Prof. Dr. R. Kessler, FH-Karlsruhe, Sensorsystemtechnik, PWM_Fuellstands_Regelung_2.doc, Seite 8/8
Anschließend Bilder mit PWM-Simulink-Simulation, meist mit einigen Cursor-Abfragen,
(gelegentlich das entsprechende Tephys-Bild)
Erkenntnisse zum Vergleich PWM und „stetige“ PID-Regelung:
Wenn die Modulationsfrequenz fPWM „genügend groß“ gewählt wird, dann sind die Kurven Regelgröße X
(entspricht Höhe h4) und sogar Höhe h1 bei PWM-Betrieb nahezu identisch mit den entsprechenden
Ergebnissen bei „stetigem“ Betrieb. Aber es ergibt sich der beabsichtigte Vorteil, dass die Pumpe nur
entweder voll oder gar nicht fördert (s. Kurve Q1 * 0.5E4).
5
Bild=21;vma=40;vmi=-40;aW =2;tW =0.1;
4.5
PWM=1;fPWM=0.15;Ap=30;Td=0;Ti=100000;inma=1000;kon=1;kW=1;
4
W
X
Q1*0.5E4
h1
int
3.5
Zeit
3
72.6
W
2
X
Q1*0.5e4
1.86
0
h1
int
0.291 0.000404
2.5
2
153
4
4.02
0
195
239
0.638
0.00109
4
3.9
0.84
0.67
0.0012
4
3.82
0
0.599
0.00132
1.5
1
0.5
0
-0.5
0
50
100
150
200
250
Zeit in sec
300
350
400
450
500
Bild 1. Aufruf war fuelPWMPar21C. P-Regler, Ap = 30.
Die Periode T der Regelschwingung kann mit Cursor gefunden werden: T=41.5 sec.
Nach dem Vorschlag von Tietze-Schenk ergibt Td = T/6.28 = 6.6 sec und Ti = 10*Td = 66.7 sec
Tephysbild 1 die gleichen Parameter wie beim obigen Simulink-Bild 21
Prof. Dr. R. Kessler, FH-Karlsruhe, Sensorsystemtechnik, PWM_Fuellstands_Regelung_2.doc, Seite 9/9
5
Bild=22;vma=40;vmi=-40;aW =2;tW =0.1;
4.5
PWM=1;fPWM=0.15;Ap=30;Td=6.37;Ti=100000;inma=1000;kon=1;kW=1;
4
W
X
Q1*0.5E4
h1
int
3.5
3
2.5
2
1.5
1
0.5
0
-0.5
0
50
100
150
200
250
Zeit in sec
300
350
400
450
500
Bild 2: Aufruf war fuelPWMPar22C PD-Regler Td=6.37 (gemäß Vorschlag Tietze-Schenk, s. Bild 1).
Die Regelschwingung ist infolge des D-Anteils gedämpft. Man erkennt, dass noch Regelabweichung
vorhanden ist. Kein Wunder, denn da die Pumpe pumpen soll, benötigt sie eine Spannung. Folglich muss bei
PD-Regelung eine Regelabweichung auftreten.
Bild=23;vma=40;vmi=-40;aW =2;tW =0.1;
5
PWM=1;fPWM=0.15;Ap=30;Td=6.37;Ti=64;inma=10;kon=1;kW=1;
4.5
4
3.5
Zeit
W
X
Q1*0.5e4
168
4
4.77
0.84
356
2
1.53
0
0.802
h1
W
X
Q1*0.5E4
h1
int
int
0.973
3
0.301
-0.321
2.5
2
1.5
1
0.5
0
-0.5
0
50
100
150
200
250
Zeit in sec
300
350
400
450
500
Bild 3: Aufruf war fuelPWMPar23C PID-Regler mit Ti = 64 sec, gemäß Vorschlag Tietze-Schenk. Zwar
wird das Ziel Regelabweichung = 0 erreicht, aber nach den Sprüngen von W ergibt sich eine beachtliche
"Überschwingung" bzw. "Unterschwingung" der Regelgröße X. Man ahnt, warum das so ist: Die PumpFörderleistung Q1 geht sowohl beim Aufwärtssprung als auch beim Abwärtssprung der Führgröße in
Begrenzung. Dadurch steigt (bzw. fällt) die Regelgröße X mit begrenzter Geschwindigkeit. Folglich nimmt
das Integral der Regelabweichung unnötig große Werte an und muss dann erst wieder kleiner werden, um
den Endzustand (Regelabweichung = 0 ) zu erreichen. Aus dem Bild findet man die maximale
Geschwindigkeit von X zu 0.049 Volt/sec.
Prof. Dr. R. Kessler, FH-Karlsruhe, Sensorsystemtechnik, PWM_Fuellstands_Regelung_2.doc, Seite 10/10
Tephysbild 3: Parameter wie beim obigen Simulink-Bild 32
5
Bild=24;vma=0.049;vmi=-0.049;aW =2;tW =0.1;
4.5
PWM=1;fPWM=0.15;Ap=30;Td=6.37;Ti=64;inma=10;kon=1;kW=1;
4
3.5
Zeit
81.8
W
2
X
2
Q1*0.5e4
0.84
0.366
h1
W
X
Q1*0.5E4
h1
int
int
0.189
3
157
4
4.18
0
0.719
0.427
2.5
2
1.5
1
0.5
0
-0.5
0
50
100
150
200
250
Zeit in sec
300
350
400
450
500
Bild 4: Aufruf war fuelPWMPar24C PID-Regler, aber Führgröße W mit Anstiegsbegrenzung ( vma bzw
vmi gemäß dem vorherigen Bild berechnetem Wert). Man erkennt, dass infolge der Anstiegsbegrenzung die
Überschwinger sehr viel kleiner sind
Prof. Dr. R. Kessler, FH-Karlsruhe, Sensorsystemtechnik, PWM_Fuellstands_Regelung_2.doc, Seite 11/11
5
Bild=34;vma=0.04;vmi=-0.049;aW =2;tW =8;
4.5
PWM=1;fPWM=0.15;Ap=30;Td=6.37;Ti=64;inma=10;kon=1;kW=1;
W
X
Q1*0.5E4
h1
int
4
3.5
3
2.5
Zeit
W
161
3.97
250
4
X
Q1*0.5e4
4.05
0.84
h1
0.677
int
0.329
2
4.01
0.84
0.72
0.294
1.5
1
0.5
0
-0.5
0
50
100
150
200
250
Zeit in sec
300
350
400
450
500
Bild 34: Aufruf war fuelPWMPar34C Wieder PID-Regler, Aber Anstiegsgeschwindigkeit noch kleiner
(vmwa= .04 statt 0.049) und Sollwert verrundet (mit tW= 8 statt 0.1). Dadurch Überschwinger vermieden
(vgl. vorhergehendes Bild)
Bild=26;vma=0.047;vmi=-0.047;aW =4;tW =8;
8
PWM=1;fPWM=0.15;Ap=30;Td=6.37;Ti=64;inma=100;kon=1;kW=1;
7
6
W
X
Q1*0.5E4
h1
int
5
4
Zeit
W
222
7
407
3.01
X
5.44
5.45
Q1*0.5e4
0
0.84
h1
0.938
0.827
int
2.12
2.56
3
2
1
0
0
50
100
150
200
250
Zeit in sec
300
350
400
450
500
Bild 6: Aufruf war fuelPWMPar26C PID-Regler in der obigen "optimalen" Dimensionierung. ABER Sollwert
W so hoch, dassder Überlaufschutz von Tank 1 anspricht ( siehe das stoßweise Pumpen, Kurve Q1, und die
konstante Höhe h1). Erstaunlicherweise bleibt bei der Abnahme des Sollwertes die Regelgröße X noch lange
Zeit konstant, deutlich oberhalb des Sollwertes und der Überlaufschutz bleibt ebenfalls noch lang aktiv,
obwohl der Sollwert schon längst wieder auf kleinem Wert ist! Grund für dies Verhalten: der Integralwert
steigt unnötig hoch an und benötigt lange Zeit zum Wieder-Abnehmen.
Als Abhilfe gegen das Hochlaufen des Integrierers bietet sich natürlich an: Integralwert begrenzen!
Prof. Dr. R. Kessler, FH-Karlsruhe, Sensorsystemtechnik, PWM_Fuellstands_Regelung_2.doc, Seite 12/12
Bild=27;vm a=0.047;vm i=-0.047;aW =4;tW =8;
8
PWM=1;fPWM=0.15;Ap=30;Td=6.37;Ti=64;inma=0.5;kon=1;kW=1;
7
W
X
Q1*0.5E4
h1
int
6
Zeit
5
4
W
X
3
Q1*0.5e4
88.7
2.99
257
7
5.46
0.84
0.84
432
3
3.01
0
0.533
0.941
0.499
h1
int
0.253
0.5
0.248
3
2
1
0
0
50
100
150
200
250
Zeit in sec
300
350
400
450
500
Bild 7: Aufruf war fuelPWMPar27C Hier wird der Integralwert int auf die Werte inma = 0.5 Volt bzw. inmi
= - 0.5 Volt begrenzt, folglich schnelles Reagieren der Regelgröße X bei Abnahme des Sollwertes W, trotz
Überlaufschutz!