%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Uebung 3 - Regelungstechnik
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%% Aufgabe 3.6:
%Reset:
clear all
close all
clc

%Kopiert von Maple: (Parameter)
JGSM = 0.1240000000e-1;
JP = 0.3250000000e-1;
LGSM = 0.1400000000e-2;
RGSM = 0.46e0;
cGSMP = 0.6822e0;
dGSMP = 0.1e1 / 0.100000e6;
dcGSM = 0.152e0;
dcP = 0.169e0; 
dqP = 0.1e1 / 0.10000e5;
dvGSM = 0.1800000000e-2;
dvP = 0.2700000000e-2;
kGSM = 0.1e0;
%nur fuer Berechnung von xRuhe als Anfangszustand (siehe Angabe):
umRuhe = 5.6;
dmRuhe = 0;

%% Ruhelagen, Systemmatrizen
xMRuhe = [-(kGSM / RGSM / dqP * (-(RGSM * dvGSM) - (RGSM * dvP) - (kGSM ^ 2) + sqrt((-4 * RGSM ^ 2 * dcGSM * dqP - 4 * RGSM ^ 2 * dcP * dqP - 4 * RGSM ^ 2 * dmRuhe * dqP + RGSM ^ 2 * dvGSM ^ 2 + 2 * RGSM ^ 2 * dvGSM * dvP + RGSM ^ 2 * dvP ^ 2 + 4 * RGSM * dqP * kGSM * umRuhe + 2 * RGSM * dvGSM * kGSM ^ 2 + 2 * RGSM * dvP * kGSM ^ 2 + kGSM ^ 4))) / 0.2e1 - umRuhe) / RGSM -(dvGSM / RGSM / dqP * (-(RGSM * dvGSM) - (RGSM * dvP) - (kGSM ^ 2) + sqrt((-4 * RGSM ^ 2 * dcGSM * dqP - 4 * RGSM ^ 2 * dcP * dqP - 4 * RGSM ^ 2 * dmRuhe * dqP + RGSM ^ 2 * dvGSM ^ 2 + 2 * RGSM ^ 2 * dvGSM * dvP + RGSM ^ 2 * dvP ^ 2 + 4 * RGSM * dqP * kGSM * umRuhe + 2 * RGSM * dvGSM * kGSM ^ 2 + 2 * RGSM * dvP * kGSM ^ 2 + kGSM ^ 4))) / 0.2e1 + (kGSM / RGSM / dqP * (-(RGSM * dvGSM) - (RGSM * dvP) - (kGSM ^ 2) + sqrt((-4 * RGSM ^ 2 * dcGSM * dqP - 4 * RGSM ^ 2 * dcP * dqP - 4 * RGSM ^ 2 * dmRuhe * dqP + RGSM ^ 2 * dvGSM ^ 2 + 2 * RGSM ^ 2 * dvGSM * dvP + RGSM ^ 2 * dvP ^ 2 + 4 * RGSM * dqP * kGSM * umRuhe + 2 * RGSM * dvGSM * kGSM ^ 2 + 2 * RGSM * dvP * kGSM ^ 2 + kGSM ^ 4))) / 0.2e1 - umRuhe) / RGSM * kGSM + dcGSM) / cGSMP 0.1e1 / RGSM / dqP * (-(RGSM * dvGSM) - (RGSM * dvP) - (kGSM ^ 2) + sqrt((-4 * RGSM ^ 2 * dcGSM * dqP - 4 * RGSM ^ 2 * dcP * dqP - 4 * RGSM ^ 2 * dmRuhe * dqP + RGSM ^ 2 * dvGSM ^ 2 + 2 * RGSM ^ 2 * dvGSM * dvP + RGSM ^ 2 * dvP ^ 2 + 4 * RGSM * dqP * kGSM * umRuhe + 2 * RGSM * dvGSM * kGSM ^ 2 + 2 * RGSM * dvP * kGSM ^ 2 + kGSM ^ 4))) / 0.2e1 0.1e1 / RGSM / dqP * (-(RGSM * dvGSM) - (RGSM * dvP) - (kGSM ^ 2) + sqrt((-4 * RGSM ^ 2 * dcGSM * dqP - 4 * RGSM ^ 2 * dcP * dqP - 4 * RGSM ^ 2 * dmRuhe * dqP + RGSM ^ 2 * dvGSM ^ 2 + 2 * RGSM ^ 2 * dvGSM * dvP + RGSM ^ 2 * dvP ^ 2 + 4 * RGSM * dqP * kGSM * umRuhe + 2 * RGSM * dvGSM * kGSM ^ 2 + 2 * RGSM * dvP * kGSM ^ 2 + kGSM ^ 4))) / 0.2e1];
xM0=xMRuhe'

xM0lin=[0;0;0;0]

xRedRuhe = [-(dvGSM / RGSM / dqP * (-(RGSM * dvGSM) - (RGSM * dvP) - (kGSM ^ 2) + sqrt((-4 * RGSM ^ 2 * dcGSM * dqP - 4 * RGSM ^ 2 * dcP * dqP - 4 * RGSM ^ 2 * dmRuhe * dqP + RGSM ^ 2 * dvGSM ^ 2 + 2 * RGSM ^ 2 * dvGSM * dvP + RGSM ^ 2 * dvP ^ 2 + 4 * RGSM * dqP * kGSM * umRuhe + 2 * RGSM * dvGSM * kGSM ^ 2 + 2 * RGSM * dvP * kGSM ^ 2 + kGSM ^ 4))) / 0.2e1 + (kGSM / RGSM / dqP * (-(RGSM * dvGSM) - (RGSM * dvP) - (kGSM ^ 2) + sqrt((-4 * RGSM ^ 2 * dcGSM * dqP - 4 * RGSM ^ 2 * dcP * dqP - 4 * RGSM ^ 2 * dmRuhe * dqP + RGSM ^ 2 * dvGSM ^ 2 + 2 * RGSM ^ 2 * dvGSM * dvP + RGSM ^ 2 * dvP ^ 2 + 4 * RGSM * dqP * kGSM * umRuhe + 2 * RGSM * dvGSM * kGSM ^ 2 + 2 * RGSM * dvP * kGSM ^ 2 + kGSM ^ 4))) / 0.2e1 - umRuhe) / RGSM * kGSM + dcGSM) / cGSMP 0.1e1 / RGSM / dqP * (-(RGSM * dvGSM) - (RGSM * dvP) - (kGSM ^ 2) + sqrt((-4 * RGSM ^ 2 * dcGSM * dqP - 4 * RGSM ^ 2 * dcP * dqP - 4 * RGSM ^ 2 * dmRuhe * dqP + RGSM ^ 2 * dvGSM ^ 2 + 2 * RGSM ^ 2 * dvGSM * dvP + RGSM ^ 2 * dvP ^ 2 + 4 * RGSM * dqP * kGSM * umRuhe + 2 * RGSM * dvGSM * kGSM ^ 2 + 2 * RGSM * dvP * kGSM ^ 2 + kGSM ^ 4))) / 0.2e1 0.1e1 / RGSM / dqP * (-(RGSM * dvGSM) - (RGSM * dvP) - (kGSM ^ 2) + sqrt((-4 * RGSM ^ 2 * dcGSM * dqP - 4 * RGSM ^ 2 * dcP * dqP - 4 * RGSM ^ 2 * dmRuhe * dqP + RGSM ^ 2 * dvGSM ^ 2 + 2 * RGSM ^ 2 * dvGSM * dvP + RGSM ^ 2 * dvP ^ 2 + 4 * RGSM * dqP * kGSM * umRuhe + 2 * RGSM * dvGSM * kGSM ^ 2 + 2 * RGSM * dvP * kGSM ^ 2 + kGSM ^ 4))) / 0.2e1];
xRed0=[0;0;0]

Asys = [-0.1e1 / LGSM * RGSM 0 -0.1e1 / LGSM * kGSM 0; 0 0 1 -1; kGSM / JGSM -cGSMP / JGSM -(dvGSM + dGSMP) / JGSM dGSMP / JGSM; 0 cGSMP / JP dGSMP / JP -((dGSMP * RGSM) - (RGSM * dvGSM) - (kGSM ^ 2) + sqrt((-4 * RGSM ^ 2 * dcGSM * dqP - 4 * RGSM ^ 2 * dcP * dqP - 4 * RGSM ^ 2 * dmRuhe * dqP + RGSM ^ 2 * dvGSM ^ 2 + 2 * RGSM ^ 2 * dvGSM * dvP + RGSM ^ 2 * dvP ^ 2 + 4 * RGSM * dqP * kGSM * umRuhe + 2 * RGSM * dvGSM * kGSM ^ 2 + 2 * RGSM * dvP * kGSM ^ 2 + kGSM ^ 4))) / RGSM / JP;]
Bsys = [0.1e1 / LGSM 0; 0 0; 0 0; 0 -0.1e1 / JP;];
Csys = [0 0 0 1;];
Dsys = [0 0;];
linSys = ss(Asys, Bsys, Csys, Dsys);
GM=tf(linSys)

AredSys = [0 1 -1; -cGSMP / JGSM -((dGSMP * RGSM) + (RGSM * dvGSM) + (kGSM ^ 2)) / RGSM / JGSM dGSMP / JGSM; cGSMP / JP dGSMP / JP -((dGSMP * RGSM) - (RGSM * dvGSM) - (kGSM ^ 2) + sqrt((-4 * RGSM ^ 2 * dcGSM * dqP - 4 * RGSM ^ 2 * dcP * dqP - 4 * RGSM ^ 2 * dmRuhe * dqP + RGSM ^ 2 * dvGSM ^ 2 + 2 * RGSM ^ 2 * dvGSM * dvP + RGSM ^ 2 * dvP ^ 2 + 4 * RGSM * dqP * kGSM * umRuhe + 2 * RGSM * dvGSM * kGSM ^ 2 + 2 * RGSM * dvP * kGSM ^ 2 + kGSM ^ 4))) / RGSM / JP;];
BredSys = [0 0; kGSM / RGSM / JGSM 0; 0 -0.1e1 / JP;];
CredSys = [0 0 1;];
DredSys = [0 0;];
redSys = ss(AredSys, BredSys, CredSys, DredSys);
Gred=tf(redSys)

hhRuhe = [0.1e1 / RGSM / dqP * (-(RGSM * dvGSM) - (RGSM * dvP) - (kGSM ^ 2) + sqrt((-4 * RGSM ^ 2 * dcGSM * dqP - 4 * RGSM ^ 2 * dcP * dqP - 4 * RGSM ^ 2 * dmRuhe * dqP + RGSM ^ 2 * dvGSM ^ 2 + 2 * RGSM ^ 2 * dvGSM * dvP + RGSM ^ 2 * dvP ^ 2 + 4 * RGSM * dqP * kGSM * umRuhe + 2 * RGSM * dvGSM * kGSM ^ 2 + 2 * RGSM * dvP * kGSM ^ 2 + kGSM ^ 4))) / 0.2e1]
hhRedRuhe= [0.1e1 / RGSM / dqP * (-(RGSM * dvGSM) - (RGSM * dvP) - (kGSM ^ 2) + sqrt((-4 * RGSM ^ 2 * dcGSM * dqP - 4 * RGSM ^ 2 * dcP * dqP - 4 * RGSM ^ 2 * dmRuhe * dqP + RGSM ^ 2 * dvGSM ^ 2 + 2 * RGSM ^ 2 * dvGSM * dvP + RGSM ^ 2 * dvP ^ 2 + 4 * RGSM * dqP * kGSM * umRuhe + 2 * RGSM * dvGSM * kGSM ^ 2 + 2 * RGSM * dvP * kGSM ^ 2 + kGSM ^ 4))) / 0.2e1]

%%Ergebnisse:
%das lineariserten modell unterscheidet sich anfangs nicht sehr stark vom 
%nicht linearisierten Modell. Erst als sich das System weiter aus der
%Ruhelage entfernt hat, kommt es zu groesseren Abweichungen.

%% Aufgabe 3.7
%Entwursvorgaben:
einf = 0;       %bleibende Regelabweichung: e_{inf}=0
ueb = 0;        %Ueberschwingen: ue<=0%
tr = 1;         %Anstiegszeit: 1s
Ta = 50*10^(-3);%Abtastzeit

w0 = 2/Ta
wc = 1.2/tr %(Beziehung 6.118) (gilt nur, wenn wc<=0.2*w0)
wc<=0.2*w0
phi = degtorad(70-ueb)  %Beziehung lt. Skriptum 5.3

%Transformation vom kont. s-Bereich in den diskreten Z-Bereich
Gz=c2d(Gred(1), Ta, 'zoh'); %System ohne Stoerung
Gzd=c2d(Gred(2), Ta, 'zoh'); %System mit Stoerung
%Transformation vom disk. z-Bereich in den kont. q-Bereich
Gq=d2c(Gz, 'tustin');
Gqd=d2c(Gzd, 'tustin');

%% XI und T bestimmen: ((q*T)^2+2*xi*q*T+1)
[z,p] = zpkdata(Gq);
%die beiden ersten Pole sind das gesuchte konj. komplexe polpaar.
p1 = p{1}(1);
p2 = p{1}(2);
%Aus dem konj. kompl. Polpaar werden 2 Nennerpolynome generiert.
% -> (q-p1)(q-p2)  (achtung, in matlab sind polynome vektoren)
pl1 = [1 -p1];
pl2 = [1 -p2];
%Zwei Polynome gefaltet ergeben das produkt von (q-p1)(q-p2)
resPoly = conv(pl1, pl2)
%Das nun gefundene Produkt in die Form (q*T)^2+2*xi*q*T+1 bringen:
%d.h. durch den term ohne q durchdividieren, um dort +1 zu erhalten
resPoly = resPoly/resPoly(length(resPoly))

%Aus resPoly kann nun das T bestimmt werden:
T = sqrt(resPoly(1))  % -> denn T^2=resPoly(1) -> T=sqrt(resPoly(1))
%Aus T und resPoly kann nun xi bestimmt werden: xi=resPoly/
xi = resPoly(2)/(2*T) % -> denn 2*xi*T=resPoly(2) -> xi=resPoly(2)/(2*xi)

%% Reglerentwurf, einzelnen Steps, siehe Kapitel 5.1 im Skriptum

%Im folgenden werden 2 Regler: RqPI und Rq bestimmt:
%Fuer den Regler RqPI gilt es ein RqPI=VI(1+s*TI)/s zu bestimmen.
%und fuer Rq in der Form 
%       Rq = VI(1+q*TI)/q*(1+2*xi(q*T)+q*T^2)/(q-qr1)(q-qr2):
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Step 1: zuerst Integrator hinzufuegen:
q = tf('s');
Rq1 = (1+2*xi*(q*T)+(q*T)^2)/q;
Lq1 = Rq1*Gq;
%zpk findet Pol- und Nullstellen und stellt das System vereinfacht dar.
zpk(Lq1)

%zum Vergleich der PI-Regler:
RqPI1 = 1/q;
LqPI1 = RqPI1*Gq;
zpk(LqPI1)

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Step 2: qr1, qr2 bestimmen
%%% atan(-wc/qr)=10grad, 
%%%-> bei durchtrittsfrequenz phi+/-10grad (anstatt phi)

%Möglichkeit 1: qr1 und 2 gleichsetzen. Annähernd richtig.
qr1 = -wc/tan(10*pi/180);
qr2 = qr1;

%Möglichkeit 2: qr1 und qr2 sind konjugiert komplex. Dabei wird an der
%reelen Achse der Wert -wc ausgesucht, und hierzu den Imaginärteil mit
%Phase 10grad errechnet. qr1,2 sind komplexe Zahlen.
%ACHTUNG: Dies bewirkt ~10% Überschwingen TODO: wieso?
%qr1 = -wc+j*(wc/tan(10*pi/180))
%Konjugiert-komplexe von qr1 berechnen
%qr2 = conj(qr1)
%diese zusammenmultipliziert ergeben eine rein-reele Zahl. MATLAB warnt
%trotzdem vor einer Übertragungsfunktion (q) mit komplexen Koeffizenten.
%Das Ersetzen mit qrProdukt verhindert mehrere Meldungen.


%qrProdukt = (q-qr1)*(q-qr2)
qrProdukt = (1-q/qr1)*(1-q/qr2)%nur minus, weil qr1,2 negativ sind

Rq2 =(1+2*xi*(q*T)+(q*T)^2)/(q*qrProdukt);
Lq2 = Rq2*Gq

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Step 3: Ti berechnen, aus (arctan(wc*Ti)=adjustphase. (Skr. 5.40)
%Ti soll die Phase anpassen. Dabei soll an die Phase an der
%Durchtrittsfrequenz -180+phi betragen. "adjustphase" gibt an, um wie viel
%hierfür die Phase angehoben werden soll.
adjustphase = degtorad(-180) - angle(evalfr(Lq2, j*wc)) + phi
Ti  =tan(adjustphase)/wc
Rq3=(1+q*Ti)*(1+2*xi*(q*T)+(q*T)^2)/(q*qrProdukt);
Lq3 = Rq3*Gq;

%zum Vergleich der PI-Regler:
adjustphasePI = degtorad(-180) - angle(evalfr(LqPI1, j*wc)) + phi
TPIi=tan(adjustphasePI)/wc
RqPI3 = (1+q*TPIi)/q;
LqPI3 = RqPI3*Gq;

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Step 4: V berechnen (Phase bleibt nach diesem Schritt gleich)
V = 1/abs(evalfr(Lq3, j*wc))
Rq4=V*(1+q*Ti)*(1+2*xi*(q*T)+(q*T)^2)/(q*qrProdukt);
Lq4 = Rq4*Gq;

%zum Vergleich der PI-Regler:
VPI=1/abs(evalfr(LqPI3, j*wc))
RqPI4 = VPI*(1+q*TPIi)/q;
LqPI4 = RqPI4*Gq;

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%Step 5: geschlossenen Kreis gemaess L(s)/(1+L(s)) Skr 5.1
%Tqry = minreal(Lq4/(1+Lq4)) %minreal: Kuerzen von Pol- und Nullstellen
%Fuehrungsuebertragungsfunktion:
Tqry = feedback(Lq4,1)      %Alternative zu L4/(1+L4)
%Stoerungsuebertragungsfunktion:
Tqdy = Gqd/(1+Lq4)

%zum Vergleich der PI-Regler:
TqPIry = feedback(LqPI4,1)  %Alternative zu LqPI4/(1+LqPI4)
TqPIdy = Gqd/(1+LqPI4)

%%Die Uebertragungsfunktion des Reglers anhand von  (siehe 5.43)
%Sprungantworten vergleichen -> daurch wird sichergestellt, dass die 
%Stellgroessenbeschraenkung eingehalten wird.
Gr=Rq4/(1+Rq4*Gq)
figure
step(Gr)
hold on
grid on
step(Gr,stepDataOptions('StepAmplitude',20))
title('Stellgroessenbeschraenkung anhand von Step')
legend('Step*1', 'Step*20')
%Hier kann man sehen, dass die Amplitude die geforderte
%Stellgroessenbeschraenkung von 0-12V einhaelt.
%Daher ist es nicht notwendig, diese mit einem Vorfilter Anzupassen.
%% Plots
%Reguliert vs Nicht Reguliert
figure
step(Gq) %System ohne Regelkreis
hold on
step(Gqd) %System ohne Regelkreis bezüglich Störung
step(Tqry)%geschlossenes System (mit Regler)
step(Tqdy)%geschlossenes System (mit Regler) bezüglich Störung
title('Reguliert vs Nicht Reguliert')
legend('Gq', 'Gqd', 'Tqry', 'Tqdy')

%PI- vs Kompensationsregler
%Wie man an der folgenden Sprungantwort sieht, ist es viel besser, einen
%Kompensationsregler anstatt eines PI-Reglers zu implementieren: ein
%einfacher PI-Regler bewirkt starkes Über- und Einschwingen und sichert
%nur, dass die Regelabweichung bei 0 bleibt.
figure
step(Tqry)
hold on
grid on
step(Tqdy)
step(TqPIry)
step(TqPIdy)
title('PI- vs Kompensationsregler')
legend('Kompensationsregler - Tqry', 'Kompensationsregler - Tqdy', 'PI-Regler - TqPIry', 'PI-Regler - TqPIdy')

%Regelkreis: Schritt für Schritt
figure
bode(Gq)
grid on
hold on
bode(Lq1) %mit Kompensation und Integrator
bode(Lq2) %mit Realisierungspolen
bode(Lq3) %mit Ti
bode(Lq4) %mit Vi
bode(Tqry)
plot(wc,0,'*')
title('Regelkreis: Schritt für Schritt')
legend('Gsys', 'offen L1', 'offen L2', 'offen L3', 'offen L4', 'geschlossen Tqry','wc')
%Im Bode-Diagramm ist die Pahsenreserve phi bei L4 mit 70Grad ueber 180Grad
%gut sichtbar.
%Ausserdem sieht man, dass die Betragskennlinie von L4 bei wc um mind.
%20dB/dek. abfaellt.
%% Transformation
Rz = c2d(Rq4,Ta,'tustin')
[RzNum, RzDenom, Ta] = tfdata(Rz);
[res, pol, dir] = residue(RzNum{1}, RzDenom{1})
[NumNormiert, DenomNormiert] = residue(res, pol, dir);
zpk(Rz)

%TODO: aufspalten von Rz: (was ist integral, proportional und
%kompensationsteil?)
%% Stabilitaetsbetrachtung:
%Wenn die folgenden Bedingungen (Satz 4.6 (Nyquist-Kriterium)) erfuellt
%sind (und die Phasenreserve phi pos. ist, das wurde bereits richtig 
%gewaehlt):
%Ausgehend von folgender Gleichung: 
% L(s) = V/s^rho*zL(s)/nL(s)*exp(-s*Tt)  mit xl(0)=zl(0)=1

%Bed. 1: Verstaerkungsfaktor V ist pos: 
%       -> V = 15.3..., erfuellt!
V

%Bed. 2: grad(nL(s)) + rho > grad(zL(s)): 
%       -> 7+1 > 6, erfuellt!
Lq4
[num,den]=tfdata(Lq4)
den = cell2mat(den)
num = cell2mat(num)
syms s
gradn = length(coeffs(poly2sym(num,s)))
gradd = length(coeffs(poly2sym(den,s)))

%Bed. 3: Das Polynom nL(s) ist ein Hurwitzpolynom und für rho gilt:
%   rho ist Elem. {0, 1, 2}
%Hurwitz: Ein reelles Polynom, dessen Nullstellen einen echt neg. Realteil
%besitzen.
%       -> rho=1, roots sind neg, erfuellt!
hurwitz=poly2sym(den(1:end-1),s)
hurroots=roots(den(1:end-1))

%Bed. 4: die Betragskennlinie von L(Iw) weist genau einen Schnittpunkt mit
%der 0-dB-Linie (eine Durchtrittsfrequenz wC ) auf
%       -> erfuellt!
figure
bodemag(Lq4)
hold on
grid on
plot(wc,0,'*')

%Bed. 5: im Bereich |L(Iw)| >= 0 gilt: -540° < arg(L(Iw)) < 180°
%(d. h. die Ortskurve des offenen Kreises L(s) kann vor ihrem Eintauchen 
%in den Einheitskreis den Nullpunkt höchstens einmal vollständig umkreisen)
%       -> erfuellt! (Betrachten der Nyquist Ortskurve)
figure
bode(Lq4)
grid on
figure
nyquist(Lq4)
hold on
%Einheitskreis
theta = 0:0.1:2*pi;
x=cos(theta);
y=sin(theta);
plot(x, y)

%Da alle Bedingungen erfuellt sind, ist der Regelkreis stabil!

%% Reglerentwurf durch Polvorgabe im Zustandsraum
%Abtastmodell erstellen:
sysD = c2d(ss(AredSys,BredSys(:,1), eye(size(AredSys)), DredSys(:,1)), Ta, 'zoh');
Ad = sysD.a;
bd = sysD.b;

%Gewünschte Pole des geschlossenen Kreises im Zeitkontinuierlichen
pc = [-1,-1,-1];

%Gewünschte Pole des geschlossenen Kreises für das Abtastsystem
pd = exp(pc*Ta);

%Polvorgabe mit der Ackermannformel (ACHTUNG Ackermannformel in Matlab liefert ein anderes 
%Vorzeichen als im Skriptum!!!)
k = -acker(Ad,bd,pd);
eig(AredSys)
eig(Ad+bd*k)

%Vorfaktor
g = 1/((CredSys(:,1)+DredSys(:,1)*k)*inv(eye(size(AredSys))-Ad-bd*k)*bd+DredSys(:,1))