Die Leistung die die Spannungsquelle 3 abgibt berechnet sich zu:

P03 = U03*(-I3)

Damit folgt der Strom I3 zu

I3 = (-P03)/U03

Durch Einsetzen in die Gleichung aus d) erhalten wir wieder ein Gleichungssystem mit 2 Unbekannten I6 und I04 welches wir nach I04 lösen können. Es gilt somit zu lösen:

[R2            -R2-R5]*[I04] = [-U03-(R2+R3+R5)*I3]
[R1+R2    R1+R2+R5+R6] [ I6]   [-U06+(R2+R5)*I3   ]

Invertieren der Matrix liefert dann das Ergebnis ...

Seien a, b und c Vektoren mit Längen |a|, |b| und |c|. Sei

c = a - b

Damit folgt für die Länge von c zu

|c|^2 = |a - b|^2 = |a|^2 + |b|^2 - 2*<a, b>

wobei <a, b> das Skalarprodukt bezeichnet. Mit der bekannten Formel

<a, b> = |a|*|b|*cos(gamma)

(Gamma bezeichnet kleinsten Winkel zwischen a und b)

erhalten wir damit durch Einsetzen den gesuchten Zusammenhang

|c|^2 = |a - b|^2 = |a|^2 + |b|^2 - 2*|a|*|b|*cos(gamma)

Ich empfehle eventuell auch einen Blick in folgende Playlist:

https://www.youtube.com/watch?v=cO0eTzqBM-8&list=PLlXfTHzgMRUKG7lkye7DQAmNB0cfWNgWG&index=13

Video 13 der Playlist zum Thema "Dot Product" und "Pythagorean Theorem" sollte alle Fragen ausräumen.

Die Funktionsgleichung hat die Form:

f(x) = a*x^3 + b*x

Dem Graphen sind zwei gut ablesbare Punkte zu entnehmen:

(i) P1 = (0,6 | -0,1)

(ii) P2 = (0,8 | 0,2)

Einsetzen von (i) und (ii) in die Funktionsgleichung liefert damit folgendes Gleichungssystem:

(iii) f(0,6) = -0,1 = a*0,6^3 + b*0,6

(iv) f(0,8) = 0,2 = a*0,8^3 + b*0,8

Aus (iii)*8 - 6*(iv) folgt:

(v) -0,8 - 1,2 = a*(8*0,6^3 - 6*0,8^3)

Gleichung (v) können wir dann einfach nach a umstellen

--> a = 125/84

Einsetzen von a in (iii) und umstellen nach b liefert damit

--> b = (-0,1/0,6) - a*0,6^2 = - (59/84)

Damit lautet die gesuchte Funktionsgleichung:

f(x) = (125/84)*x^3 - (59/84)*x

https://www.wolframalpha.com/input?i=plot+%28125%2F84%29*x%5E3+-+%2859%2F84%29*x+for+-0.8+%3C+x+%3C+1

Jedem Punkt auf der Wurzelortskurve ist ein Gain zugeordnet, welcher die ausgewählte Polkonfiguration generiert. Allgemein besitzt ein Pol folgende Gestalt:

p = -a +jb

mit reellen Zahlen a und b. Im Falle eines Polpaares mit Eigenfrequenz w0 und Dämpfung D gilt

p = - Dw0 +/- jw0*sqrt(1 - D^2)

Alle Polpaare mit gleicher Dämpfung D liegen somit auf den beiden Geraden

p1(x) = - D*x + j*x*sqrt(1 - D^2)

p2(x) = - D*x - j*x*sqrt(1 - D^2)

Will man also ein charackteristisches Abklingverhalten erzeugen durch Vorgabe einer Dämpfung, so zeichnet man die zugeörige Gerade ein und bestimmt den oder die Schnittpunkte mit der WOK. Dies sind dann die Pole p mit gewünschtem Verhalten. Ohne zusätzliche Rechnung lässt sich der zugehörige Verstärkungsfaktor allerdings nicht aus dem Diagramm ablesen. Man verwendet folgende Bedingung

1 + G(p)*K = 0

für die Bestimmung des Gains K welcher dazu führt, dass p ein Pol des geschlossenen Regelkreises ist. Es folgt somit

K = (-1)/G(p)

Das wären die Schritte die man von Hand durchführen müsste. Matlab erledigt bereits schon einen Großteil der Arbeit. Beim Klicken auf einen der Zweige der WOK wird ein Punkt generiert für den bereits alle wichtigen Daten angegeben werden

- Größe des Gains, sodass ausgewählter Punkt ein Pol des geschlossenen Kreises ist

- Die Position des Pols selber

- Die Dämpfung D des Pol(paares)

- Die Größe des Überschwingens der Sprungantwort

- Die Größe der Eigenfrequenz w0

Den angezeigten Punkt kann man dann mithilfe der Maus entlang des jeweiligen Zweiges der WOK entlang bewegen, sodass man für alle Punkte obige Daten bestimmen kann. Dies erlaubt ein einfachen und übersichtlichen Entwurf auf Basis von Ansprüchen im Frequenz- und Zeitbereich.

z = x + i*y

|z+i| = |z+2|

|z+i|^2 = |z+2|^2

x^2 + (y+1)^2 = (x + 2)^2 + y^2

2y + 1 = 4x + 4

y = 2x + 3/2

Ja das geht. Hierzu musst du der Variable Iduration den Wert von Zelle Xyz zuweisen. Angenommen der Werte stehe in der Zelle A12:

Iduration = Range("A12").Value

Zusätzlich ließe sich das ganze noch so kombinieren, dass falls diese Zelle leer ist (=0) ein Standardwert für Iduration gesetzt wird.

If Range("A12").Value = 0 Then
  Iduration = 120 'Hier Standardwert definieren
Else
  Iduration = Range("A12").Value
End If

Siehe hierzu auch:

https://www.automateexcel.com/vba/cell-value-get-set/

https://learn.microsoft.com/de-de/office/vba/language/concepts/getting-started/using-ifthenelse-statements

Das ist eigentlich recht simpel, denn es gilt für beliebige komplexe Zahlen a und b:

arg(a/b) = arg(a) - arg(b) = atan2(Im(a)/Im(b)) - atan2(Im(b)/Im(a))

Warum dies gilt sieht man schnell ein, wenn man die Exponentialdarstellung für die komplexen Zahlen verwendet. Es gilt:

a = |a|*exp(i*arg(a))

b = |b|*exp(i*arg(b))

--> a/b = |a/b|*exp(i*(arg(a) - arg(b)))

Und damit dann der Anfangs erwähnte Zusammenhang:

arg(a/b) = arg(a) - arg(b)

Du hast 2 Forderungen zu erfüllen:

tr = 1.5s ---> wc (Durchtrittsfrequenz/Bandbreite)

ü = 7% ---> PM (Phasenreserve)

Der PI-Regler hat nun 2 Parameter:

1.) Lage der Nullstelle (w0) --> Anpassung der Phase

2.) Statisches Gain (K) --> Anpassen der Durchtrittsfrequenz

Das Vorgehen lautet somit:

1.) Bestimme w0 so, dass sich die für PM benötigte Phase bei wc einstellt. (Unter der Annahme K = 1)

arg(K(jw)*P(jw)) = arg(K(jw)) + arg(P(jw)) = -90° + arctan(w/w0) + arg(P(jw))

--> PM = 180° + -90° + arctan(wc/w0) + arg(P(jwc))

--> w0 = wc/ tan(PM - 90° + arg(P(jwc)))

2.) Anpassen des statischen Gains K des Reglers, sodass die Durchtrittsfrequenz mit dem geforderten Wert für wc übereinstimmt.

|K(jw)*P(jw)| = |K(jw)|*|P(jw)|

--> |K(jwc)*P(jwc)| = 1 = |K(jwc)|*|P(jwc)| = K* sqrt(1 + (wc/w0)^2)/wc * |P(jwc)|

--> K = wc/(sqrt(1 + (wc/w0)^2)* |P(jwc)|)

Das Ergebnis ist dann ein PI-Regler, welcher die gewünschten Anforderungen an das dynamische Verhalten realisiert.

Das Schaltzeichen sollte eine Art von Potentiometer sein (ein veränderlicher Widerstand). Man sieht in der Tabelle, dass der Wert für die verschiedenen Fälle angegeben ist. Es wird sofort klar:

Iamax = Ia(R = 0) = Uab/Ra

Damit folgt für die gesuchte Funktion für ein gegebenes Ra

f(R) = Ia/Ia(R = 0) = (Uab/(Ra + R))/(Uab/Ra) = Ra/(Ra + R)

Der Wirkungsgrad berechnet sich somit zu

eta(R) = Pab/Pin = Ia^2*Ra/(Uab*Ia) = Ia/(Uab/Ra) = Ia/Ia(R = 0) = f(R)

Die restliche Darstellung in einem Koordinatensystem musst du dann übernehmen.

Also wenn ich das jetzt richtig verstehe, dann hast du den Regelkreis mit einem P-Regler (Kp = 1) geschlossen. Der Plot zeigt dann das Führungsverhalten des Regelkreises. Normalerweise (für stabile Strecken) erfolgt eine Identifikation der Strecke ohne einen Regelkreis. Als Stellgröße wird bspw. ein Sprung gewählt und dann der Ausgang des Systems beobachtet. Bei einem einfachen thermischen System sollte dann das Streckenverhalten durch G(s) = K/(1 + s*T) gegeben sein, kann sich jedoch auch komplexer gestalten (Pole mit unterschiedlicher Dynamik). Nach Bestimmung der Antwort nach obigen Ansatz können dann bspw. die Tuning-Regeln nach Ziegler und Nichols verwendet werden. Soll das ganze im Regelkreis betrieben werden, so haben Ziegler und Nichols ebenfalls ein Verfahren für die Auslegung angegeben. Hierzu wird der Gain des P-Reglers solange erhöht, bis das System eine Dauerschwingung ausführt (für viele Systeme ist dieser Ansatz jedoch nicht zu empfehlen). Auf Basis des Kp_krit und der Periodendauer kann dann der PID-Regler bestimmt werden. Für die praktische Anwendung ist schließlich noch zu beachten, dass deine Stellgröße begrenzt ist. Somit ist dann für den I-Anteil des Reglers ein Anti-Windup Glied einzuführen um das dynamische Verhalten wesentlich zu verbessern.

Eine kurze Google-Recherche liefert:

Seien die n Daten xk gegeben mit Mittelwert x_mean. Es folgt als Schätzung für die Standardabweichung:

STABW(xk)^2 = sum(k, 1, N){(xk - x_mean)^2}/(n - 1)

STABWN(xk)^2 = sum(k, 1, N){(xk - x_mean)^2}/(n)

Die beiden Funktionen unterscheiden sich also durch den Mittelungsfaktor. STABW bestimmt somit den Bias freien Schätzwert und STABWN den Bias behafteten. Siehe für weitere Fragen:

https://support.microsoft.com/de-de/office/stabw-funktion-51fecaaa-231e-4bbb-9230-33650a72c9b0

https://support.microsoft.com/de-de/office/stabwn-funktion-1f7c1c88-1bec-4422-8242-e9f7dc8bb195

Dort sind gerade unter Hinweise die notwendingen und weitere nützliche Informationen zu finden.

Prinzipiell sieht die erste Teilaufgabe a) soweit Ok aus. Hier evtl. noch eine alternative Version, welche ohne eine zweite for-Schleife auskommt. (Die schnellste und eleganteste Variante würde natürlich über die FFT laufen ... .)

function y = myConv(x,h)
%Signallängen
Nx = length(x);
Nh = length(h);

%Initialisieren des Ausgangssignals
y = zeros(1, Nx + Ny - 1);

%Berechnen der Koeffizienten des Ausgangssignals
for(ii = 1:Nx)
   y(ii:(ii + Nh - 1)) = x(ii) * h;
end
end

Für die Teilaufgabe b):

Mit Koeffizienten sind die einzelnen Werte der diskreten Signale gemeint. Für einen Lösungsvorschlag siehe unten. Die benötigten Signale werden schlichtweg wie in der Aufgabe gefordert innerhalb der Funktion MyTask2 definiert.

%Funktion für Teilaufgabe b)
function [] = MyTask2()
%Definieren des Rechtecksignals
x_rect = zeros(1,10);
x_rect(2:5) = 1;

%Definieren des Impulssignals
h_impuls = zeros(1,10);
h_impuls(1) = 1;

%Diskrete Faltung
y = myConv(x_rect, h_impuls);

%Plotten der beiden Signale
figure(1);
subplot(2,1,1);
stem(0:(length(y) - 1), [x_rect, zeros(1, length(y) - length(x_rect))]);
grid on;
legend('Eingangssignal');

subplot(2,1,2);
stem(0:(length(y) - 1), y, 'r');
grid on;
legend('Ausgangssignal');

end

Es sei die Impulsantwort gegeben zu:

h(t) = s(t) - s(t - 1)

also ein Rechteck der Länge 1 mit Zentrum bei t = 0.5. Für die Sprungantwort g(t) folgt dann:

g(t) = conv(h(t), s(t))

wobei conv(a, b) die Faltung der Signale a und b beschreibt. Benutzte die Linearität der Faltung, so dass

g(t) = conv(s(t) - s(t - 1), s(t)) = conv(s(t), s(t)) - conv(s(t - 1), s(t))

Schreibe f(t) = conv(s(t), s(t)) und benutze die Zeitinvarianz der Faltung, so dass:

f(t - 1) = conv(s(t - 1), s(t)) = conv(s(t), s(t - 1))

Man erhält somit:

g(t) = f(t) - f(t - 1)

Final gilt es also f(t) zu bestimmen. Es gilt mittels der Definition der Faltung:

f(t) = int[-inf, inf]{ s(t - x)*s(x) dx } = int[-inf, t]{ s(x) dx } = int[0, t]{ s(x) dx }

Und somit:

f(t) = 0 für t < 0

f(t) = t für t > 0

--> f(t) = t*s(t)

Entsprechend folgt durch Einsetzen:

g(t) = f(t) - f(t - 1) = t*s(t) - (t - 1)*s(t - 1)

Der Funktionsverlauf lässt sich nun einfach graphisch bestimmen und entspricht dem dargestellten Verlauf. Rechnerisch würde folgen:

g(t) = 0 für t < 0

g(t) = t für 0 < t < 1

g(t) = t - (t - 1) = 1 für t > 1

Abschließend noch eine alternative Bestimmung der Sprungantwort. Es gilt:

h(t) = rect(t - 0.5) = conv(rect(t), delta(t - 0.5))

s(t) = sum(k, 0, inf){ rect(t - 0.5 - k) } [Summe verschobener Rechtecke]

--> g(t) = conv(h(t), s(t)) = sum(k, 0, inf){ conv(rect(t - 0.5 - k), rect(t - 0.5)) }

Mit conv(rect(t), rect(t)) = tri(t), der Dreiecksfunktion mit Länge 2, Höhe 1 und Zentrum bei t = 0, folgt dann

--> g(t) = sum(k, 0, inf){ conv(tri(t - 1), delta(t - k)) }

Aufzeichnen und Addieren liefert dann das selbe Ergebnis ... .

Man kann hier einen einfachen Produktansatz machen. Heißt nehme an, dass die Lösung die Gestalt:

u(x, t) = f(x)*h(t)

besitzt. Einsetzen liefert dann:

f(x)*h''(t) = 4*f''(x)*h(t)

Ein Vergleich der beiden Seiten liefert einem:

(i) h''(t) = c*h(t)

(ii) f''(x) = k*f(x)

mit Konstanten c und k. Für diese Konstanten muss gelten: c = 4*k; entsprechend lässt sich dann (i) umschreiben zu

(iii) h''(t) = 4k*h(t)

Bei (ii) und (iii) handelt es sich nun um einfache homogene DGL´s zweiter Ordnung deren Lösung direkt angegeben werden kann zu:

f(x) = A*cos(sqrt(k)*x) + B*sin(sqrt(k)*x)

h(t) = C*cos(2*sqrt(k)*t) + D*sin(2*sqrt(k)*t)

Aus den Nebenbedingungen folgt nun:

u(0, t) = 0 = f(0)*h(t) ---> A = 0

u(5, t) = 0 = f(5)*h(t) ---> sqrt(k)*5 = pi*n mit n aus IN\{0}

Wir erhalten damit also:

sqrt(k) = pi*n/5

Und damit schonmal für f(x):

f(x) = B*sin(pi*n/5 * x)

Somit nimmt u(x, t) die Gestalt:

u(x,t) = f(x)*h(t) = sin(pi*n/5 * x)*(E*cos(2*pi*n/5 *t) + F*sin(2*pi*n/5 *t))

wobei E = B*C und F = B*D gelte. Es folgt weiter:

u(x, 0) = 0 ---> E = 0

du(x,0)/dt = 5*sin(pi*x) = sin(pi*n/5 * x)*F*2*pi*n/5

Es folgt hieraus somit:

pi*n/5 = pi ---> n = 5

Und damit final

F*2*pi*n/5 = 2*F*pi = 5

Umstellen liefert:

F = 5/(2*pi)

Die Lösung lautet also:

u(x,t) = (5/(2*pi))*sin(pi* x)*sin(2*pi *t)

Es gilt:

P = u * i

Mit der Induzierten Spannung:

u = uind = -dPhi/dt

folgt dann durch Einsetzen und dem Zusammenhang U = R * i (Ohmsches Gesetz) hier

p = (dPhi/dt)^2 / R

Also nur noch Einsetzen und Ableiten (ggf. Kettenregel beachten !!!).

Es gibt im Endeffekt zwei Möglichkeiten der Bestimmung einer Ersatzschaltung. Einmal die reale Stromquelle oder die reale Spannungsquelle. Die Ausgangsklemmen sind hier die Anschlüsse von R4.

Variante 1: (Reale Stromquelle)

Setze R4 = 0 um den Kurzschluss-Strom Ik zu berechnen.

In diesem Falle folgt:

(i) Uq1 + Uq2 = Ur1 + Ur2 (Masche 1)

(ii) Uq3 = Ur3 + Ur2 (Masche 2)

(iii) Ur2 = Ik * R2 (Bauteilgleichung)

(iv) Ur1 = R1*Ir1 (Bauteilgleichung)

(v) Ur3 = R3*Ir3 (Bauteilgleichung)

(vi) Ik = Ir2 = Ir1 + Ir3 (Knotengleichung)

Aus R3*(i) + R1*(ii) folgt:

(vii) R3*(Uq1 + Uq2) + R1*Uq3 = R3*Ur1 + R1*Ur3 + (R1 + R3)*Ur2

Anwenden der Knotengleichung (vi) und den Bauteilgleichungen liefert schließlich

(viii) R3*(Uq1 + Uq2) + R1*Uq3 = (R1*R3 + (R1 + R3)*R2)*Ik

Und damit durch Umstellen nach Ik dann aus (viii)

(ix) Ik = {R3*(Uq1 + Uq2) + R1*Uq3}/{R1*R3 + (R1 + R3)*R2}

Man bestimme nun im letzen Schritt dann noch den Innenwiderstand Ri. Ersetze hierzu alle Spannungsquellen durch Kurzschlüsse und Stromquellen durch offene Klemmen. Ri entspricht dann dem Widerstand zwischen den Anschlussklemmen von R4. Hier folgt:

Ri = (R2 + (R1 II R3)) II (R5 + (R6 II R7))

wobei Rx || Ry = (Rx*Ry)/(Rx + Ry), dem Widerstand der Parallelschaltung von Rx und Ry entspricht.

Die Maximale Leistung wird abgegeben wenn R4 = Ri. Im Falle der realen Ersatzstromquelle folgt dann mit Ri parallel zu R4 damit also

Ir4 = Ik/2 , Ur4 = R4*Ik/2 = (Ri*Ik)/2 = Uleer/2

und

Pr4 = R4*(Ir4)² = Ri*Ik²/4 = Ik*Uleer/2

Beide Lösungen sind identisch ... . Wähle einfach k_lösung = k_deins + 1 , so folgt die selbe Lösung. Beachte, dass k aus Z beliebig gewählt werden kann.

Vereinfacht kann man annehmen, dass das Seil in mehreren geschlossenen "Ringen" übereinander liegt. Die Anzahl der "Ringe" folgt dann schließlich über:

N = h/d

N - Anzahl der "Ringe"

h - Höhe der zu umwickelnden Stange

d - Durchmesser des Seils

Die Länge eines einzelnen Ringes L entspricht nun:

L = pi*d + U

pi - Kreiszahl mit ungefährem Wert 3.14

U - Umfang der zu umwickelnden Stange

Die gesamte Länge der Schnur Lges, lässt sich nun abschätzen zu:

Lges = N*L = (h/d)*(pi*d + U) = h*(pi + U/d)

In deinem Beispiel folgt:

h = 55 cm

U = 29 cm

d = 0.6 cm

--> Lges = 55cm * (pi + 29/0.6) = 28.311 m

Nun gibt es noch einige Dinge zu beachten, so ist dies lediglich als Richtwert zu verstehen, da es sich nur um eine Näherung handelt. Es ist anzunehmen, dass in der Realität gilt:

Lges ≈ h*(pi + U/d)

wobei die Abschätzung empfindlich von dem gemessenen Durchmesser des Seiles abhängt. Angenommen du hättest dich um 1mm bei der Bestimmung des Durchmesser vermessen, so wäre 33.628 m > Lges > 24.514 m, eine Variation von bis zu 5.32 m (diese wird zusätzlich umso größer je größer die Dimensionen der Stange werden ... )! Die Auswirkungen von Abweichungen in den übrigen Parameter wie h und U sind dagegen wesentlich geringer (< 2m für abweichende Messungen < 1cm für den gegebenen Fall).

Zusammenfassend:

Lges ≈ h*(pi + U/d) mit den Größen

h - Höhe der zu umwickelnden Stange

d - Durchmesser des Seils

U - Umfang der zu umwickelnden Stange

pi - Kreiszahl mit ungefährem Wert 3.14

liefert einen guten Richtwert für die zu erwartende Länge des Seiles. Die Schätzung ist dabei umso besser je kleiner h und U und je genauer d bekannt sind. Von allen Parametern muss d (zumindest für kleine Durchmesser ... ) am genauesten bekannt sein. Zusätzliche Faktoren wie Wicklungsart, Homogenität des Seils, etc. können dazu führen, dass die Schätzung sehr ungenau wird und stark von der tatsächlichen Seillänge abweichen kann.

Es geht eigentlich recht schnell wenn du folgendes machst:

x = (-10):1e-3:10 ; %Vektor der interessierenden "x-Werte"

y = 2*x + x.^3 %y = 2x + x^3 (Durchführung der Abbildung)

Und wenn du das dann auch noch plotten willst, dann schreibe:

figure; %Öffne neues Grafik-Fenster

plot(x, y); %Einzeichnen des Graphen in zuletzt aufgerufenes Grafik-Fenster

Eigentlich gilt es hier nur zu wissen:

1.) x:a:y = [x, x+a, ... , y] (vorrausgesetzt y = x + a*n ) -> Erzeugt Vektor

2.) " .^ " ist die elementenweise Potenzierung. Bspw.:

[2, 1, 3, 4].^2 = [4, 1, 9, 16]

1.)

G(s) = s/((s + 2)*(s - 2))

W(s) = L{ sin(2t) } = 2/(s² + 4)

Entsprechend folgt die Ausgangsfunktion Y(s) zu:

Y(s) = G(s)*W(s) = s/((s + 2)*(s - 2)) * 2/(s² + 4)

Eine entsprechende Partialbruchzerlegung liefert:

Y(s) = A/(s + 2) + B/(s - 2) + (Cs + D)/(s² + 4)

mit A = lim(s->-2){ Y(s)*(s + 2) } = (-2)/(-4) * 2/(4 + 4) = 1/8

und B = lim(s-> 2){ Y(s)*(s - 2) } = 2/4 * 2/(4 + 4) = 1/8

Für s = 0 folgt:

Y(s = 0) = 0 = (1/8)/2 + (1/8)/(-2) + D/4 ---> D = 0

Und für s = 1 folgt schließlich:

Y(s = 1) = 1/(3*(-1)) * 2/(1 + 4) = (1/8)/3 + (1/8)/(-1) + C/5

--> C = -0.25

Wir erhalten damit final als Antwort:

Y(s) = (1/8)/(s + 2) + (1/8)/(s - 2) + (-0.25)/(s² + 4)

Und damit durch Rücktransformation in den Zeitbereich:

y(t) = (1/8)*e^(-2t) + (1/8)*e^(2t) - 0.5 * sin(2t)

2.)

G(s)=[(s+j)(s-j)]/(s+1) = (s² + 1)/(s + 1)

W(s) = L{ sin(t) } = 1/(s² + 1)

Das Ausgangssignal folgt zu

Y(s) = G(s)*W(s) = 1/(s + 1)

Und durch Rücktransformation in den Zeitbereich zu

y(t) = e^(-t)