PWM-Füllstands-Regelung, simuliert mit Simulink (mit ...kero0001/fuelpwm/PWM_Fuellstands... ·...

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

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):

A40

Belüftungs-

Rohr

Ausfluß

Pumpe

Rückschlag-

Ventil

Vorrats-Wanne

A34A23A12

h1

h2

h3

h4

A1 A2 A3 A4

Sensor

für h4

Zufluß

Q1

Sensor

für h1

Wasser


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)

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 Tephys-

Simulation 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}

PID-Regler

aYPW

Strecke

Dreieck-

Generator

Y

X

YPID

pid

YPW

W

X

uV

Vergleicher

Wahl-

Schalter


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) Simulink-

Methode.

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 Word-

Dokument einfügen.


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.

f(u)= (u[2]<1)*(u[1]>3)*(u[1]-3)*kQ

Datei fuelPWM1.MDL 4-Tank-FüllstandsRegelung. wahlweise PID-

oder Zweipunkt-Regler mit verzögert-nachgebender Rückführung.

Zusätzlich Regelung mit Pulsweite-Modulation (PWM)

Überlaufschutz für Höhe h1

Schwellen h1o, h1u. Wenn

aktiv, pumpt Pumpe nicht.

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;

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;

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

vn2Pkt

PWM

Nach

zwei

kon

h1o,h1u

UnivReg

begrenzt

Int

Uma,0

X

int

uM

W

Q1

h4

h1

S4tank

QW

In1

PWM

Out1

PWM

Mux

NOT

Uma

kh

f(u)

Anschließend das Subsystem PWM: Es realisiert die Pulsweitenmodulation.

Es ist dem oben behandelten Tephys-Programm nachgedichtet

Subsystem PWM 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

YPID

YPWM

1

Out1

SZ

Schalter

>

NOT

Uma

Umau * fPWM - floor (u * fPWM)

Erzeugung Saegezahn,

floor(x)=Ganzzahlteil von x

z.B. floor(17.8) = 17

2

PWM

1

In1

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


% 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),';'];


% 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:


% 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


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).

0 50 100 150 200 250 300 350 400 450 500

-0.5

0

0.5

1

1.5

2

2.5

3

3.5

4

4.5

5

Bild=21;vma=40;vmi=-40;aW=2;tW=0.1;

PWM=1;fPWM=0.15;Ap=30;Td=0;Ti=100000;inma=1000;kon=1;kW=1;

Zeit in sec

Zeit W X Q1*0.5e4 h1 int

72.6 2 1.86 0 0.291 0.000404

153 4 4.02 0 0.638 0.00109

195 4 3.9 0.84 0.67 0.0012

239 4 3.82 0 0.599 0.00132

W

X

Q1*0.5E4

h1

int

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


0 50 100 150 200 250 300 350 400 450 500

-0.5

0

0.5

1

1.5

2

2.5

3

3.5

4

4.5

5

Bild=22;vma=40;vmi=-40;aW=2;tW=0.1;

PWM=1;fPWM=0.15;Ap=30;Td=6.37;Ti=100000;inma=1000;kon=1;kW=1;

Zeit in sec

W

X

Q1*0.5E4

h1

int

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.

0 50 100 150 200 250 300 350 400 450 500

-0.5

0

0.5

1

1.5

2

2.5

3

3.5

4

4.5

5Bild=23;vma=40;vmi=-40;aW=2;tW=0.1;


Zeit in sec


168 4 4.77 0.84 0.802 0.973

356 2 1.53 0 0.301 -0.321

W

X

Q1*0.5E4

h1

int

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 Pump-

Fö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.


Tephysbild 3: Parameter wie beim obigen Simulink-Bild 32

0 50 100 150 200 250 300 350 400 450 500

-0.5

0

0.5

1

1.5

2

2.5

3

3.5

4

4.5

5

Bild=24;vma=0.049;vmi=-0.049;aW=2;tW=0.1;


Zeit in sec


81.8 2 2 0.84 0.366 0.189

157 4 4.18 0 0.719 0.427

W

X

Q1*0.5E4

h1

int

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


0 50 100 150 200 250 300 350 400 450 500

-0.5

0

0.5

1

1.5

2

2.5

3

3.5

4

4.5

5

Bild=34;vma=0.04;vmi=-0.049;aW=2;tW=8;


Zeit in sec


161 3.97 4.05 0.84 0.677 0.329

250 4 4.01 0.84 0.72 0.294

W

X

Q1*0.5E4

h1

int

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)

0 50 100 150 200 250 300 350 400 450 500

0

1

2

3

4

5

6

7

8Bild=26;vma=0.047;vmi=-0.047;aW=4;tW=8;


Zeit in sec


222 7 5.44 0 0.938 2.12

407 3.01 5.45 0.84 0.827 2.56

W

X

Q1*0.5E4

h1

int

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!


0 50 100 150 200 250 300 350 400 450 500

0

1

2

3

4

5

6

7

8

Bild=27;vma=0.047;vmi=-0.047;aW=4;tW=8;

PWM=1;fPWM=0.15;Ap=30;Td=6.37;Ti=64;inma=0.5;kon=1;kW=1;

Zeit in sec


88.7 2.99 3 0.84 0.533 0.253

257 7 5.46 0.84 0.941 0.5

432 3 3.01 0 0.499 0.248

W

X

Q1*0.5E4

h1

int

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!

PWM-Füllstands-Regelung, simuliert mit Simulink (mit ...kero0001/fuelpwm/PWM_Fuellstands... ·...

Documents

Transcript of PWM-Füllstands-Regelung, simuliert mit Simulink (mit ...kero0001/fuelpwm/PWM_Fuellstands... ·...