Contents

clear all
close all
clc

%{
Simulationsbeispiel zum Deadbeat-Regler (Kompensationsregler mit endlicher Einschwingzeit)
Benjamin Hartmann, 01.07.2008
%}

1. Wahl der Abtastzeit

%{
Zunächst wird die Abtastzeit vorgegeben. Generell ist beim Einsatz eines
Deadbeat-Reglers darauf zu achten, dass die Abtastzeit nicht zu klein ge-
wählt wird, weil dies zu sehr großen Stellgrößen führen kann. Der Zusammen-
hang zwischen Stellgröße und Abtastzeit wird in diesem Tutorial noch
gezeigt.
%}

% Abtastzeit
T0 = 0.3;

2. Vorgabe von drei Regelstrecken (analog):

%{
Ein Deadbeat-Regler hat den Vorteil, dass er strukturvariabel ist. Das
bedeutet, dass sich der Regler an die Prozess-Struktur automatisch
anpassen kann. Um dies zu illustrieren sollen folgende drei Regelstrecken
untersucht werden:
%}

% Leicht schwingendes PT2-Verhalten; Pole bei -3+i, -3-i
Gs1c = tf([20],[1 6 10]);
figure
step(Gs1c)
title('PT2-Prozess','fontsize',13)
xlabel('Zeit','fontsize',13)
ylabel('Amplitude','fontsize',13)
set(gca, 'fontsize',13, 'XColor','k', 'YColor','k')
axis([0 6 0 2.5])

% PT1-Verhalten mit Zeitkonstante T=0.5sec; Pol bei -2
Gs2c = tf([1],[0.5 1]);
figure
step(Gs2c)
title('PT1-Prozess','fontsize',13)
xlabel('Zeit','fontsize',13)
ylabel('Amplitude','fontsize',13)
set(gca, 'fontsize',13, 'XColor','k', 'YColor','k')
axis([0 6 0 1.5])

% PT3-Verhalten; Pole bei -4, -1+2i, -1-2i
Gs3c = tf([20], [1 6 13 20]);
figure
step(Gs3c)
title('PT3-Prozess','fontsize',13)
xlabel('Zeit','fontsize',13)
ylabel('Amplitude','fontsize',13)
set(gca, 'fontsize',13, 'XColor','k', 'YColor','k')
axis([0 6 0 1.5])

3. Diskretisierung (Halteglied 0. Ordnung 'zoh')

%{
Die Diskretisierung der vorgegebenen zeitkontinuierlichen Regelstrecken
erfolgt mit einem Halteglied 0. Ordnung bzw. zero-order-hold 'zoh'. Die
Abtastzeit T0 ist bei allen drei Prozessen die gleiche.
%}

Gs1 = c2d(Gs1c,T0,'zoh');
Gs2 = c2d(Gs2c,T0,'zoh');
Gs3 = c2d(Gs3c,T0,'zoh');

4. PT2-Strecke

4.1 Deadbeat-Regler zur PT2-Strecke

% Zählerpolynom der diskreten Regelstrecke
Bd = Gs1.num{1};

% Nennerpolynom der diskreten Regelstrecke
Ad = Gs1.den{1};

% Koeffizient q0
q0 = 1/sum(Bd);

% Ordnung n des Prozesses
n = length(Ad)-1;

% Übertragungsfunktion des Deadbeat-Reglers
Gr = tf([q0*Ad],[1 zeros(1,n)]-q0*Bd,T0);

% Übertragungsfunktion des offenen Regelkreises
G0 = Gr*Gs1;

% Führungsübertragungsfunktion
Gw = G0/(1+G0);

% Störübertragungsfunktion für eine Störung am Streckenausgang
Gd = 1/(1+G0);

% Störübertragungsfunktion für eine Störung am Streckeneingang
Gdi = Gs1/(1+G0);

4.2 PT2-Prozesses mit Deadbeat-Regler: Antwort auf Sprung der Führungsgröße w

%{
Die Sprungantwort des geregelten Systems zeigt, dass mit Hilfe des
Deadbeat-Reglers eine Einschwingzeit von nur zwei Abtastschritten
erreicht wird. Dies entspricht der Ordnung n des Prozesses.
%}

% Sprung der Führungsgröße w
figure
step(Gw)
hold on
step(Gr/(1+G0))
legend('Regelgröße y','Stellgröße u')
title('Führungsgrößensprung PT2','fontsize',13)
xlabel('Zeit','fontsize',13)
ylabel('Amplitude','fontsize',13)
set(gca, 'fontsize',13, 'XColor','k', 'YColor','k')
axis([0 6 -0.1 1.5])

4.3 PT2-Prozesses mit Deadbeat-Regler: Antwort auf Sprung der Störgröße d

%{
Bei einem Sprung der Störgröße am Prozesseingang bemerkt man allerdings,
dass nun die Einschwingzeit auch mit Hilfe des Deadbeat-Reglers nicht mehr
in endlicher Zeit passiert.
%}

% Sprung der Störsgröße di
figure
step(Gdi)
hold on
step(-Gw)
legend('Regelgröße y','Stellgröße u')
xlabel('Zeit','fontsize',13)
ylabel('Amplitude','fontsize',13)
title('Störgrößensprung vor Prozesseingang PT2','fontsize',13)
set(gca, 'fontsize',13, 'XColor','k', 'YColor','k')
axis([0 6 -1.1 1.1])

5. PT1-Strecke

5.1 Deadbeat-Regler zur PT1-Strecke

% Zählerpolynom der diskreten Regelstrecke
Bd = Gs2.num{1};

% Nennerpolynom der diskreten Regelstrecke
Ad = Gs2.den{1};

% Koeffizient q0
q0 = 1/sum(Bd);

% Ordnung n des Prozesses
n = length(Ad)-1;

% Übertragungsfunktion des Deadbeat-Reglers
Gr = tf([q0*Ad],[1 zeros(1,n)]-q0*Bd,T0);

% Übertragungsfunktion des offenen Regelkreises
G0 = Gr*Gs2;

% Führungsübertragungsfunktion
Gw = G0/(1+G0);

% Störübertragungsfunktion für eine Störung am Streckenausgang
Gd = 1/(1+G0);

% Störübertragungsfunktion für eine Störung am Streckeneingang
Gdi = Gs2/(1+G0);

5.2 PT1-Prozess mit Deadbeat-Regler: Antwort auf Sprung der Führungsgröße w

%{
Da das PT1-System eine Ordnung weniger aufweist (n=1) als der PT2-Prozess
ist die Einschwingzeit nun schon nach einem Abtastschritt erreicht.
%}

% Sprung der Führungsgröße w
figure
step(Gw)
hold on
step(Gr/(1+G0))
legend('Regelgröße y','Stellgröße u')
title('Führungsgrößensprung PT1','fontsize',13)
xlabel('Zeit','fontsize',13)
ylabel('Amplitude','fontsize',13)
set(gca, 'fontsize',13, 'XColor','k', 'YColor','k')
axis([0 6 -0.1 2.5])

5.3 PT1-Prozess mit Deadbeat-Regler: Antwort auf Sprung der Störgröße d

%{
Auch hier stellt man fest, dass ein Störsprung am Prozesseingang eine
längere Einschwingzeit hervorruft.
%}

% Sprung der Störsgröße di
figure
step(Gdi)
hold on
step(-Gw)
legend('Regelgröße y','Stellgröße u')
xlabel('Zeit','fontsize',13)
ylabel('Amplitude','fontsize',13)
title('Störgrößensprung vor Prozesseingang PT1','fontsize',13)
set(gca, 'fontsize',13, 'XColor','k', 'YColor','k')
axis([0 6 -1.1 1.1])

6. PT3-Strecke

6.1 Deadbeat-Regler zur PT3-Strecke

% Zählerpolynom der diskreten Regelstrecke
Bd = Gs3.num{1};

% Nennerpolynom der diskreten Regelstrecke
Ad = Gs3.den{1};

% Koeffizient q0
q0 = 1/sum(Bd);

% Ordnung n des Prozesses
n = length(Ad)-1;

% Übertragungsfunktion des Deadbeat-Reglers
Gr = tf([q0*Ad],[1 zeros(1,n)]-q0*Bd,T0);

% Übertragungsfunktion des offenen Regelkreises
G0 = Gr*Gs3;

% Führungsübertragungsfunktion
Gw = G0/(1+G0);

% Störübertragungsfunktion für eine Störung am Streckenausgang
Gd = 1/(1+G0);

% Störübertragungsfunktion für eine Störung am Streckeneingang
Gdi = Gs3/(1+G0);

6.2 PT3-Prozess mit Deadbeat-Regler: Antwort auf Sprung der Führungsgröße w

%{
Die PT3-Strecke hat die Ordnung n=3. Deshalb ist die Einschwingzeit
mit einem Deadbeat-Regler drei Abtastschritte.
%}

% Sprung der Führungsgröße w
figure
step(Gw)
hold on
step(Gr/(1+G0))
legend('Regelgröße y','Stellgröße u')
title('Führungsgrößensprung PT3','fontsize',13)
xlabel('Zeit','fontsize',13)
ylabel('Amplitude','fontsize',13)
set(gca, 'fontsize',13, 'XColor','k', 'YColor','k')
axis([0 6 -3 5])

6.3 PT3-Prozess mit Deadbeat-Regler: Antwort auf Sprung der Störgröße d

% Sprung der Störsgröße di
figure
step(Gdi)
hold on
step(-Gw)
legend('Regelgröße y','Stellgröße u')
xlabel('Zeit','fontsize',13)
ylabel('Amplitude','fontsize',13)
title('Störgrößensprung vor Prozesseingang PT3','fontsize',13)
set(gca, 'fontsize',13, 'XColor','k', 'YColor','k')
axis([0 6 -1.1 1.1])

6.4 Verkleinerung der Abtastzeit

%{
Wie anfangs erwähnt hängt die vom Deadbeat-Regler vorgegebene Stellgröße
von der Abtastzeit ab. Das erklärt sich dadurch, dass der Deadbeat-Regler
eine Einschwingzeit hervorruft, die der Ordnung n des Prozesses entspricht.
D.h. in n Abtastschritten muss der Regelfehler verschwinden. Je kleiner
nun die Abtastzeit T0 gewählt wird, desto schneller muss das System
einschwingen und desto aggressiver wird die Stellgröße vom Regler
eingestellt. Zur Veranschaulichung dieses Effekts wird nun T0 um 1/3
kleiner eingestellt.
%}

T0 = 0.1;

6.5 Deadbeat-Regler zur PT3-Strecke mit kleinerer Abtastzeit

Gs3 = c2d(Gs3c,T0,'zoh');
Bd = Gs3.num{1};
Ad = Gs3.den{1};
q0 = 1/sum(Bd);
n = length(Ad)-1;
Gr = tf([q0*Ad],[1 zeros(1,n)]-q0*Bd,T0);
G0 = Gr*Gs3;
Gw = G0/(1+G0);
Gd = 1/(1+G0);
Gdi = Gs3/(1+G0);

6.6 PT3-Prozess mit Deadbeat-Regler: Antwort auf Sprung der Führungsgröße w (kleinere Abtastzeit)

%{
Man erkennt dass die Verringerung von T0 um den Faktor 3 in diesem PT3-
Beispiel eine Vergrößerung der Stellgröße ungefähr um den Faktor ...
bewirkt.
%}

% Sprung der Führungsgröße w
figure
step(Gw)
hold on
step(Gr/(1+G0))
legend('Regelgröße y','Stellgröße u')
title('Führungsgrößensprung PT3','fontsize',13)
xlabel('Zeit','fontsize',13)
ylabel('Amplitude','fontsize',13)
set(gca, 'fontsize',13, 'XColor','k', 'YColor','k')

6.7 PT3-Prozess mit Deadbeat-Regler: Antwort auf Sprung der Störgröße d (kleinere Abtastzeit)

% Sprung der Störsgröße di
figure
step(Gdi)
hold on
% step(-Gr/(1+G0))
step(-Gw)
legend('Regelgröße y','Stellgröße u')
xlabel('Zeit','fontsize',13)
ylabel('Amplitude','fontsize',13)
title('Störgrößensprung vor Prozesseingang PT3','fontsize',13)
set(gca, 'fontsize',13, 'XColor','k', 'YColor','k')
axis([0 6 -1.1 1.1])

7. Deadbeat-Regler mit Vorgabe des ersten Stellgrößenwerts

7.1 Vorgabe des ersten Stellgrößenwerts

%{
Um den Deadbeat-Regler etwas weniger aggressiv zu gestalten, kann man
den ersten Wert der Stellgröße vorgeben.
%}

u0 = 40;

7.2 Berechnung des Deadbeat-Reglers unter der Voraussetzung, dass u(t=0)=u0

Q = zeros(1,n+2);
P = zeros(1,n+2);

for k = 1:n+2
   if k==1
      Q(k) = u0;
   elseif k==n+2
      Q(k) = -u0*Ad(k-1)+Ad(k-1)/sum(Bd);
      P(k) = -u0*Bd(k-1)+Bd(k-1)/sum(Bd);
   else
      Q(k) = u0*(Ad(k)-Ad(k-1))+Ad(k-1)/sum(Bd);
      P(k) = u0*(Bd(k)-Bd(k-1))+Bd(k-1)/sum(Bd);
   end
end

Gr = tf(Q,[1 zeros(1,n+1)]-P,T0);
G0 = Gr*Gs3;
Gw = G0/(1+G0);
Gd = 1/(1+G0);
Gdi = Gs3/(1+G0);

7.3 PT3-Prozess mit Deadbeat-Regler: Antwort auf Sprung der Führungsgröße w (Vorgabe des ersten Stellgrößenwerts)

%{
Wie man erkennen kann, muss die Vorgabe des ersten Stellgrößenwerts mit
einer um einen Abtastschritt längeren Einschwingzeit erkauft werden.
%}

% Sprung der Führungsgröße w
figure
step(Gw)
hold on
step(Gr/(1+G0))
legend('Regelgröße y','Stellgröße u')
title('Führungsgrößensprung PT3','fontsize',13)
xlabel('Zeit','fontsize',13)
ylabel('Amplitude','fontsize',13)
set(gca, 'fontsize',13, 'XColor','k', 'YColor','k')
axis([0 2 -45 45])

7.4 PT3-Prozess mit Deadbeat-Regler: Antwort auf Sprung der Störgröße d (Vorgabe des ersten Stellgrößenwerts)

% Sprung der Störsgröße di
figure
step(Gdi)
hold on
step(-Gw)
legend('Regelgröße y','Stellgröße u')
xlabel('Zeit','fontsize',13)
ylabel('Amplitude','fontsize',13)
title('Störgrößensprung vor Prozesseingang PT3','fontsize',13)
set(gca, 'fontsize',13, 'XColor','k', 'YColor','k')

7.5 Vorgabe des eines kleineren ersten Stellgrößenwerts

%{
Die Vorgabe des ersten Stellgrößenwerts bedeutet allerdings nicht, dass die
Stellgröße dadurch beschränkt wäre! Geben wir nun also eine Stellgröße u0
von 20 statt 40 vor:
%}

u0 = 20;

7.6 Berechnung des Deadbeat-Reglers unter der Voraussetzung, dass u(t=0)=u0

Q = zeros(1,n+2);
P = zeros(1,n+2);

for k = 1:n+2
   if k==1
      Q(k) = u0;
   elseif k==n+2
      Q(k) = -u0*Ad(k-1)+Ad(k-1)/sum(Bd);
      P(k) = -u0*Bd(k-1)+Bd(k-1)/sum(Bd);
   else
      Q(k) = u0*(Ad(k)-Ad(k-1))+Ad(k-1)/sum(Bd);
      P(k) = u0*(Bd(k)-Bd(k-1))+Bd(k-1)/sum(Bd);
   end
end

Gr = tf(Q,[1 zeros(1,n+1)]-P,T0);
G0 = Gr*Gs3;
Gw = G0/(1+G0);
Gd = 1/(1+G0);
Gdi = Gs3/(1+G0);

7.7 PT3-Prozess mit Deadbeat-Regler: Antwort auf Sprung der Führungsgröße w (Vorgabe des ersten Stellgrößenwerts)

%{
Auch hier wird der Wert für die vorgegebene Stellgröße eingehalten. Aller-
dings sieht man, dass betragsmäßig größere Stellgrößen vorkommen können.
%}

% Sprung der Führungsgröße w
figure
step(Gw)
hold on
step(Gr/(1+G0))
legend('Regelgröße y','Stellgröße u')
title('Führungsgrößensprung PT3','fontsize',13)
xlabel('Zeit','fontsize',13)
ylabel('Amplitude','fontsize',13)
set(gca, 'fontsize',13, 'XColor','k', 'YColor','k')
axis([0 2 -70 45])

7.8 PT3-Prozess mit Deadbeat-Regler: Antwort auf Sprung der Störgröße d (Vorgabe des ersten Stellgrößenwerts)

% Sprung der Störsgröße di
figure
step(Gdi)
hold on
step(-Gw)
legend('Regelgröße y','Stellgröße u')
xlabel('Zeit','fontsize',13)
ylabel('Amplitude','fontsize',13)
title('Störgrößensprung vor Prozesseingang PT3','fontsize',13)
set(gca, 'fontsize',13, 'XColor','k', 'YColor','k')

close all

Published with MATLAB® 7.5