RLC-Schaltungen mit „kompliziert“ aufzustellenden DGLn

R. Kessler, D:\579911612.doc, Seite 1 /13
Homepage: http://www.home.hs-karlsruhe.de/~kero0001/
RLC-Schaltungen mit „kompliziert“
aufzustellenden DGLn
In diesem Text werden für die auf dieser Seite zusammengestellten 12 RLC-Schaltungen die DifferentialGleichungen (abgekürt DGLn) aufgestellt. Zu jeder Schaltung wird ein Algorithmus zum numerischen Lösen
der DGLn formuliert. Die Algorithmen können mit dem Programm Tephys ausgeführt werden. Sowohl die
Dateien mit den Algorithmen als auch das Programm Tephys können runtergeladen werden.
Die Eingangspannung u0 kann beliebige Zeitfunktion u0(t) haben, für die Schaltelemente R, L, C kann man
beliebige Werte eingeben ( allerdings L > 0, C > 0).
Allen Schaltungen ist gemeinsam, dass das Aufstellen der Differentialgleichungen „kompliziert“ ist, weil
(zunächst) mehrere Ableitungen pro Gleichung auftreten.
Vgl. dagegen einfachere Schaltungen: http://www.home.hs-karlsruhe.de/~kero0001/aufst6/AufstDGL6hs.html
C1
R0
C1
R0
C2
u1
Lk
M1
u2
RA
u0
uA
RLk
M1
Nr 1 Hochpass CLC-T-Glied
R0
i2
u2
L1
RL1
L2
RL1
L2
RA
uA
u0
M2
iC1 C1
i1
i1
L3
RA
RL1
RL2
M2
M1
uA
RL1
M1
M2
RL2
Nr 5 Hochpass, 2 LCL-Pi-Glieder
C3 R3
C2 R2
i2
L2
u1
L1
u0
RL3
M3
iC1 C1 R1
R0
i3
u2
L2
L1
u0
R2
i2
u1
L2
uA
RL2
M2
Nr 4 Hochpass LCL-Pi
C2
R1
RA
R1
u
RL1
M1
Nr 3 Hochpass, CLC-Pi-Glied
R0
uA
i2
i1
L1
RL2
M1
C
iC
R0
u
RA
M3
Nr 2 Hochpasss 2 CLC-T-Glieder (erschwert infolge R2)
i2
i1
u3
RL2
M2
C
iC
L1
u0
u1
C3
K2
i1
ik
u0
C2
R2
K1
u2
i3
L3
i4
u3
i5
u4
L4
RL4
RL3
M3
C5 R5
C4 R4
L6
RA
uA
RA
uA
RL6
M6
RL5
M4
i6
u5
L5
M5
Nr 6 Hochpass, 5 LCL-Pi-Glieder
ik Lk
Ck1
K1
R0
Ck2
K2
R0
K3
Ck
u0
i2
i1
u1 L1
C1
uk1
i3
uk2
u2 L2
C2
RL1
u3 L3
C3
RL2
RA
uA
L1
u0
C1
L1
C2
i1
L2
uk
Ck
u0
R0
Rk
u2
RA
uA
L1
C1
RL1
M1
M2
u0
RLk
Nr 9 Bandpass T
i1
L1
u1
M1
u1
K2
R1
uk
R2
M2
i2
u2 L2
C2
RA
uA
RL2
M3
RL2 i2 L2
K
R1 C1
R2 C2
C2
ik
iC1
Lk
Ck
ik
iC2
R0
ik
u0
Lk
iC1
RL1 i1 L1
L2
K
C1
iC1
u2
C2
Nr 10 Bandpass Pi
i2
R0
Ck
K1
i1
Lk
u1
Nr 8 Bandsperre Pi
i2
ik
u1
L2
uk
C1
RL3
Nr 7 Bandpass 2 Pi-Glieder, kapazitiv gekoppelte Parallel-Schwingkreise
R0
i2
i1
u2
uk
Nr 11 Bandsperre T
RA
uA
u0
u1
Lk
iC2
u2
RLk
M1
Ck
uk
RA
M2
Nr 12 Bandsperre T (mit zusätzlichen Widerständen)
uA
R. Kessler, D:\579911612.doc, Seite 2 /13
Bekanntlich erhält man die Differential-Gleichungen einer aus Widerständen (R), Spulen (L) und
Kondensatoren (C) bestehenden elektrischen Schaltung dadurch, dass man für jeden (unabhängigen)
„Energiespeicher“ eine „Zustandsvariable“ einführt und durch Anwendung des
„Knotensatzes“ (= Ladungs-Erhaltungs-Satz: Summe aller zu einem Knoten fließenden Ströme = 0)
und des
„Maschensatzes“ (= Energie-Erhaltungs-Satz: Summe aller Spannungen in einer Masche = 0)
ein System von DGLn aufstellt, in dem für jede Zustandsvariable je eine DGL erster Ordnung enthalten ist. Dabei
dürfen diese DGLn nur je eine Zeitableitung enthalten.
Energiespeicher sind die Spulen und die Kondensatoren. Die Widerstände sind keine Energiespeicher, sondern
Energieverbraucher. Jeder Spule Lk wird ihr Spulenstrom ik, jedem Kondensator Cj wird die an ihm liegende
Spannung uj als Zustandvariable zugeordnet (vgl. die obigen Schaltungen: Dort sind die Zustandsvariablen in die
Schaltung eingetragen. Den Widerständen wird keine Zustandsvariable zugeordnet.
R
i
Ru= R * i
L
i
uL= L *di/dt
C
iC = C * duC/dt
Widerstand R : Spannung an R ist uR = R * i
Spule L :
Spannung an L ist uL = L * di/dt
Kondensator C: Strom durch C ist iC = C * duC/dt
uC
Damit die zu berechnende Schaltung für beliebige Zeitfunktionen der Signalquellen gilt, wird beim Aufstellen der
DGLn darauf geachtet, dass nicht nach der Quellspannung u0 differenziert wird, denn die Signalquelle könnte ja
eine unstetige Funktion sein, z.B. eine Funktion mit „Sprüngen“ (etwa Rechteckfunktion). Die Zeitableitung eines
solchen Sprunges würde an den Sprungstellen unendlich große Werte annehmen, was „physikalisch“ unzulässig
wäre.
Bei den in diesem Text behandelten Schaltungen ist das Aufstellen der DGLn dadurch erschwert, dass (zunächst)
mehrere zeitliche Ableitungen in einer Gleichung auftreten. Durch „physikalische“ Überlegungen, insbesondere
sofortige Anwendung des Knotensatzes und durch die „Masche über alles“ und gelegentlich durch Einführen von
Hilfsgrößen gelingt es aber, die erforderliche Struktur der DGLn zu erhalten, nämlich nur je eine Ableitung pro
Gleichung.
Diese Methode zum Aufstellen der DGLn ist viel anschaulicher und einfacher als etwa durch „formales
algebraisches“ Lösen eines linearen Gleichungs-Systems (etwa mit Hilfe des Gauß- Algorithmus) die gewünschte
Struktur zu erhalten, nämlich nur je eine Ableitung pro Gleichung.
Zur Schreibweise in diesem Text: Die zeitliche Ableitung der Größe x wird mit dx/dt bezeichnet, gelegentlich
auch abgekürzt als x’ = dx/dt.
Ein paar Bemerkungen zur LAPLACE- Transformation:
In vielen Texten, insbesondere in der Regelungstechnik und der Systemtheorie, wird die LAPLACETransformation als ein „unentbehrliches“ Mittel angepriesen, um dynamische Vorgänge zu berechnen. Leider ist
der zugehörige Aufwand selbst für vergleichsweise simple Schaltungen sehr beachtlich und sehr unanschaulich. Oft
wird empfohlen, einen geeigneten Taschenrechner (für einige 100 EURO) zu verwenden.
Eine Bitte des Verfassers: Wenn ein geneigter Leser eine der in diesem Text vorgestellten Schaltungen mit seiner
geliebten LAPLACE-Transformation zu berechnen in der Lage ist, dann möge er mir bitte per E-Mail seine
Ergebnisse mitteilen [email protected] Aber dabei sollten, wie im vorliegenden Text, die
Schaltungsparameter (R, L, C) und die Zeitabhängigkeit der Eingangs-Spannung u0(t) „beliebig vorgebbar“
sein. Z.B. u0 = gedämpfter Sinus + Dreieck + Rechteck + Rauschen +...
Jetzt einige Bemerkungen zum Simulations-Programm PSPICE. Im Gegensatz zur LAPLACE-Transformation ist
die Berechnung dieser Schaltungen mit PSPICE überhaupt kein Problem. Selbst mathematische Laien könnten mit
PSPICE diese Schaltungen berechnen und dabei die Parameter nach Herzenslust variieren.
Wenn PSPICE das alles so einfach kann: Wozu dann überhaupt die DGLn dieser Schaltungen aufstellen und
mit einem geeigneten Simulationsprogramm numerisch lösen? PSPICE hat den Vorteil, dass man die
mathematischen Hintergründe nicht zu wissen braucht. Das ist aber eigentlich auch ein Nachteil, denn man
versteht eigentlich nicht, wie PSPICE das macht. Ein Nachteil von PSPICE: Es kann (von Haus aus) nur
elektrische Schaltungen berechnen, nicht aber etwa mechanische oder etwa thermische. Will man auch solches
mit PSPICE berechnen, muss man die Mathematik dieser Vorgänge verstehen und dann PSPICE diese Mathematik
„unterjubeln“. Allerdings hat dann PSPICE gegenüber anderen Simulationsprogrammen keinen Vorteil mehr.
Auf jeden Fall muss man dann die DGLN aufstellen und numerisch lösen. Drum hier die Übung des
Aufstellens der DGLn und der Formulierung eines numerischen Algorithmus.
R. Kessler, D:\579911612.doc, Seite 3 /13
1 Hochpass, CLC-T-Glied
R0
C1
K
C2
ik
u0
u1
M1
Lk
u2
RA
uA
RLk
Masche über alles:
u0= R0*iR0 + u1 + u2 + RA*iRA mit den Strömen iR0 und iRA:
iR0 = C1*u1’, iRA= C1*u1’ – ik
(mit der Abkürzung u1’=du1/dt )
=> u0 = R0 *C1*u1’ +u1 +u2 + RA*( C1*u1’ –ik)
= ( R0+RA)*C1*u1’ +u1 + u2 – RA*ik =>
C1 * du1/dt = 1/(R0+RA) * (u0-u1 –u2 + RA* ik )
( DGL für u1 )
Masche M1: u0 = R0*C1*u1’ + u1 + Lk* dik/dt + RLk*ik => mit Verwendung der obigen Formel für C1*u1’
Lk*dik/dt = u0 – u1 – RLk * ik – R0*/(R0+RA) * (u0 – u1 – u2 + RA* ik )
Knoten K:
C2*du2/dt =
Strom durch C1
– Strom durch Lk : =>
C2*du2/dt = 1/(R0+RA) * (u0-u1 –u2 + RA* ik ) – ik
( DGL für ik )
( DGL für u2 )
Tephys-Algorithmus :
d=drei(fd*t)
u0 = aP*ja(t-t1)*ja(t2-t) + aD*d + aR*sign(d-sw))+aS*sin(fs*t+phis)
u1 = u1+ 1/(R0+RA) * (u0-u1-u2+RA*ik) *dt/C1
ik = ik + ( u0-u1-RLk*ik – R0/(R0+RA)*(u0-u1-u2+RA*ik) )*dt/Lk
u2 = u2 + (1/(R0+RA) * (u0-u1 –u2 + RA* ik ) -ik) *dt/C2
uA= RA*( C1/(R0+RA) * (u0-u1-u2+RA*ik) - ik)
uA richtig??
t = t+dt {Diese Gleichungen werden so oft wiederholt, bis t größer als die Maximalzeit tmax ist}
Bemerkungen zu einigen Tephys-Funktionen:
ja(x): if x > 0 then ja = 1 else ja = 0
sign(x): if x > 0 then sign = 1 else if x < 0 then sign = -1 else if x = 0 then sign = 0
drei(fd*t) = Dreieck mit Amplitude 1 und Frequenz f d
Im obigen Algorithmus ist also die Eingangs-Spannung u0(t) die Addition eines Rechteckimpulses (Höhe aP im
Zeitbereich t1 bis t2), einer Dreieckfunktion (Amplitude aD, Frequenz fd), einer Rechteckfunktion (Amplitude +/aR, Frequenz fr) und einer Sinusfunktion (Amplitude aS, Frequenz fs, Phase phis).
Der Algorithmus zum Lösen der DGLn erfolgt hier nach dem einfachen Schema: aus dx/dt = F ,=> dx=F*dt =>
Prinzip des Algorithmus x(neu) = x(alt) + F*dt oder als „Anweisung“ x = x + F*dt , d.h. ersetze den alten Wert
von x durch den neuen Wert x + F*dt.
R. Kessler, D:\579911612.doc, Seite 4 /13
2 Hochpass 2 CLC-T-Glieder
R0
C1 iC1 K1
R2
(Im Vergleich zu Nr 1 mit Erschwernis infolge R2 )
C2
K2
i1
u1
u0
M1
L1
RL1
C3
i2
u2
M2
L2
RL2
u3
RA
uA
M3
Einführen der Hilfsgröße iC1 ( = Strom durch Kondensator C1, s. Figur).
Mit iC1 –i1 = Strom durch R2 und iC1- i1 –i2 = Strom durch RA wird die
Masche über alles:
u0 = R0*iC1 + u1 + R2*(iC1 – i1) + u2 + u3 + RA * (iC1 – i1 – i2 ) =>
u0 = (R0 +R2 +RA)* iC1 + u1 –R2*i1 + u2 + u3 - RA*(i1+i2)
=> iC1 = 1/(R0+R2+RA) * ( u0 – u1 –u2 – u3 + R2*i1 + RA* ( i1+ i2 ) )
=> C1*du1/dt = iC1
Masche M1: u0 = R0 * iC1 + u1 + L1*di1/dt + RL1*i1
=> L1*di1/dt = u0 – R0*iC1 –u1 - RL1*i1
( Hilfsgröße iC1 )
( DGL für u1 )
( DGL für i1 )
Masche M1+M2: u0 = R0*iC1 +u1 + R2*(iC1 - i1) +u2 + L2*di2/dt +RL2*i2
=> L2*di2/dt = u0 - (R0 +R2)*iC1- u1 - u2 + R2*i1 –RL2*i2
( DGL für i2 )
Knoten K1: C2*du2/dt = iC1 – i1
( DGL für u2 )
Knoten K2: C3*du3/dt = iC1 – i1 - i2
( DGL für u3 )
Tephys-Algorithmus mit Runge-Kutta: Tephys-Datei 2_1.txt
DGL = 0
{Beginn der Runge-Kutta-Schleife }
d = drei(fd*t+del)
u0 = aP*ja(t - t1)*ja(t2 - t) + aD*d + aR*sign(d-sw) + aS*sin(2*pi*fS*t+phis)
iC1 = 1/(R0+R2+RA) * ( u0 – u1 –u2 – u3 + R2*i1 + RA* ( i1+ i2 ) )
u1 = rk ( iC1/C1 )
i1 = rk ( (u0 – R0*iC1 - u1 – RL1*i1) / L1 )
i2 = rk ( (u0 - (R0 +R2)*iC1- u1 - u2 + R2*i1 – RL2*i2 )/L2 )
u2 = rk ((iC1 –i1)/C2 )
u3 = rk ( (iC1 – i1 –i2)/C3 )
END =0
{Ende der Runge-Kutta-Schleife }
uA = RA*(iC1-i1-i2)
t = t+dt {Diese Gleichungen werden so oft wiederholt, bis t größer als die Maximalzeit tmax ist}
Bemerkungen zur Tephys-Formulierung des Runge-Kutta–Algorithmus:
Zwischen den Zeilen DGL=0 und END = 0 wird der Runge-Kutta-Algorithmus abgearbeitet. Es liege das DGLSystem dx/dt = A, dy/dt= B, dz/dt = C vor. Dabei können A, B, C irgendwelche Funktionen der Zeit und der
gesuchten Größen (hier x, y, z ) sein. Zur Lösung dieses DGL-Systems werden die Formeln x=rk(A), y=rk(B),
z=rk(C) zeilenweise zwischen den Zeilen DGL=0 und END=0 eingegeben.
R. Kessler, D:\579911612.doc, Seite 5 /13
3 Hochpass LCL-Pi -Glied
R0
C
iC
i1
L1
u
RL1
M1
M2
u0
i2
L2
RA
uA
RL2
Masche über alles: u0 = R0*(i1 + iC) + u + RA*(iC – i2)= (R0+RA)* iC +u + R0*i1- RA* i2 =>
iC= C* du/dt = 1/(R0+RA) * ( u0-u-R0*i1+RA*i2)
Masche M1: u0 = R0*(i1+iC) + L1*di1/dt + RL1* i1
L1*di1/dt = u0 - R0*(i1+iC) – RL1*i1
( DGL für u ) ( Hilfsgröße iC )
=>
( DGL für i1 )
Maschen M1+M2: u0 = R0*(i1+iC) +u +L2*di2/dt + RL2*i2 =>
L2*di2/dt = u0 – R0 *( i1+iC) – u – RL2 * i2
Ausgangsspannung
uA=RA*(iC-i2)
( DGL für i2 )
Tephys-Algorithmus mit Runge- Kutta:
DGL = 0
u0 = aP*ja(t-t1)*ja(t2-t) { hier könnten noch weitere Signalfunktionen stehen, vgl. Schaltung 2 }
iC = 1/(R0+RA) * ( u0-u-R0*i1+RA*i2)
u = rk ( iC/C )
i1 = rk ( (u0 - R0*(i1+iC) – RL1*i1 )/L1 )
i2 = rk ( (u0 – R0 *( i1+iC) – u – RL2 * i2 )/L2 )
END = 0
uA = RA * (iC - i2)
t = t+dt {Diese Gleichungen werden so oft wiederholt, bis t größer als die Maximalzeit tmax ist}
4 Hochpass LCL-Pi
(Im Vergleich zu Nr 3 mit Erschwernis infolge R1 )
iC C R1
R0
i1
u0
L1
RL1
M1
i2
u
M2
L2
RA
uA
RL2
Masche über alles: u0 = R0*(i1+iC) + u + R1*iC + RA*(iC-i2) = R0*i1 + (R0+R1+RA)*iC + u –RA*i2
=> iC = C*du/dt = 1/(R0+R1+RA) * ( u0 - R0*i1 – u + RA*i2 )
Masche M1: u0= R0*(i1+iC) +L1*di1/dt + RL1* i1 =>
L1*di1/dt = u0 – R0*(i1+iC) - RL1*i1
( DGL für u und Hilfsgröße iC )
( DGL für i1 )
Maschen M1+M2: u0 = R0*(i1+iC) + u + R1*iC + L2*di2/dt + RL2*i2 =>
L2*di2/dt = u0 – R0*(i1+iC) - u – R1*iC - RL2*i2
( DGL für i2 )
Tephys-Algorithmus mit Runge-Kutta: (Tephys-Dateien 4_1.txt, 4_2.txt)
DGL = 0
d = drei(fD*t+del)
u0 = aP* ja(t-t1)*ja(t2-t)+ aD*d + aR*sign(d-sw) + aS*sin(2*pi*fS+t)
iC = 1/(R0+R1+RA) * (u0-R0*i1-u+RA*i2)
u = rk(iC/C)
i1 = rk( (u0 – R0*(i1+iC) - RL1*i1 )/L1 )
i2 = rk( (u0 – R0*(i1+iC) - u – R1*iC - RL2*i2 )/L2 )
End = 0
uA = RA*(iC-i2)
t = t + dt {Diese Gleichungen werden so oft wiederholt, bis t größer als die Maximalzeit tmax ist}
R. Kessler, D:\579911612.doc, Seite 6 /13
5 Hochpass aus zwei LCL-Pi-Gliedern
R0
iC1
i1
u0
C1
C2
R1
R2
i2
u1
L1
L2
RL1
RL2
i3
u2
L3
RA
M1
M2
uA
RL3
M3
Nr 5 Hochpass, 2 LCL-Pi-Glieder
Man wird erkennen, dass nach der folgenden Methode auch für „beliebig viele“ solcher Pi-Glieder die DGLn
aufgestellt und gelöst werden können:
Masche über alles: u0 = R0*( i1+ iC1 ) + u1 + R1*iC1 + u2 + R2* (iC1 – i2) + RA*( iC1 – i2 - i3 ) =>
u0 = (R0+R1+R2+RA)*iC1 + R0*i1+ u1 + u2 - R2*i2 – RA*(i2+i3) =>
iC1 = 1/( R0+R1+R2+RA ) * ( u0 – R0 *i1 –u1 - u2+ R2*i2 + RA*(i2 + i3) )
=> C1*du1/dt = iC1
Masche M1: u0 = R0 * (i1 + iC1) + L1* di1/dt + RL1 * i1 =>
L1 * di1/dt = u0 – R0 * (i1+iC1) – RL1 * i1
( Hilfsgröße iC1 )
( DGL für u1 )
( DGL für i1 )
Maschen M1…M2: u0 = R0*(i1 + iC1) + u1 + R1 * iC1 + L2 * di2/dt + RL2*i2 =>
L2 * di2/dt = u0 – R0*(i1+iC1) –u1 –R1*iC1 –RL2*i2
( DGL für i2 )
Maschen M1…M3: u0 = R0*(i1+iC1) + u1 + R1*iC1 + u2 + R2 *( iC1-i2) + L3*di3/dt + RL3*i3 =>
L3*di3/dt = u0 – (R0 + R1 + R2 )*iC1 – R0*i1 –u1 – u2 + R2*i2 – RL3*i3
( DGL für i3 )
C2* du2/dt = iC1 – i2
Ausgangsspannung
( DGL für u2 )
uA = RA * ( iC1 - i2 - i3 )
Tephys-Algorithmus mit Runge-Kutta: Tephys-Dateien
5_1.txt,
HP2LCL1.txt
DGL = 0
d = drei(fD*t+del)
u0 = aP * ja(t-t1)*ja(t2-t) +aD*d + aR*sign(d-sw) +aS*sin(2*pi*fS*t)
iC1 = 1/( R0+R1+R2+RA ) * ( u0 – R0 *i1 - u1 – u2 + R2*i2 + RA*(i2 + i3) )
u1 = rk (iC1/C1)
i1 = rk( ( u0 – R0 * (i1+ iC1) – RL1 * i1 ) / L1)
i2 = rk ( (u0 – R0*(i1+iC1) –u1 –R1*iC1 –RL2*i2 )/L2)
i3 = rk( (u0 – (R0 + R1 + R2 )*iC1 – R0*i1– u1– u2 + R2*i2– RL3*i3 )/L3)
u2 = rk (( iC1 – i2 – i3 )/C2 )
END = 0
uA = RA * (iC1 – i2 – i3 )
t = t + dt {Diese Gleichungen werden so oft wiederholt, bis t größer als die Maximalzeit tmax ist}
R. Kessler, D:\579911612.doc, Seite 7 /13
6 Hochpass aus 5 LCL-Pi-Gliedern
R0
iC1
i1
C1
u1
L1
u0
M1
R1
C2
i2
L2
u2
RL2
RL1
M2
R2
i3
L3
C3
u3
i4
L4
C4
u4
RL4
RL3
M3
R3
M4
R4
i5
L5
C5
R5
i6
u5
L6
uA
RL6
RL5
M5
RA
M6
An diesem Beispiel aus 5 LCL-Pi-Gliedern soll demonstriert werden, dass die an 2 LCL-Pi-Gliedern benutzte
Methode auch für beliebig viele LCL-Pi-Glieder zum Ziele führt, nämlich zum Aufstellen des DGL-Systems
Masche über alles:
u0 = R0*( i1+ iC1 )+u1+R1*iC1+u2+R2*(iC1–i2) +u3+R3*(iC1-i2-i3)
+ u4+R4*(iC1-i2-i3-i4)+u5+R5*(iC1-i2-i3-i4-i5)+ RA*( iC1–i2-i3-i4-i5-i6)
iC1 ausklammern:
u0 = (R0+R1+R2+R3+R4+R5+RA)*iC1+u1+u2+u3+u4+u5 + R0*i1
- (R2+R3+R4+R5+RA)*i2 - (R3+R4+R5+RA)*i3 - (R4+R5+RA)*i4 - (R5+RA)*i5 - RA*i6
=>
iC1 = 1/( R0+R1+R2+R3+R4+R5+RA ) *( u0 – u1-u2-u3-u4-u5-R0 *i1
+ (R2+R3+R4+R5+RA)*i2 + (R3+R4+R5+RA)*i3 +(R4+R5+RA)*i4 +(R5+RA)*i5 +RA*i6 ) { Hilfsgröße iC1 }
Mit Hilfe von iC1 können alle DGL des Systems leicht formuliert werden:
Zunächst Einführen der „Kondensatorströme“ für die übrigen Kondensatoren:
iC2= iC1 - i2; iC3= iC2 - i3; iC4= iC3 - i4; iC5= iC4 - i5;
{ zusätzliche Hilfsgrößen iC2, iC3, iC4, iC5 }
Damit hat man die DGLn für die Kondensatorspannungen u1...u5 :
C1*du1/dt = iC1 ; C2*du2/dt = iC2; C3*du3/dt = iC3; C4*du4/dt = iC4; C5*du5/dt = iC5
( DGLn für u1, u2, u3, u4, u5 )
Aus den Maschen bekommt man die DGLn für die Ströme i1...i6 :
M1:
M1..M2:
M1..M3:
M1..M4:
M1..M5:
M1..M6:
u0=R0*(iC1+i1)+L1*di1/dt+RL1*i1
u0=R0*(iC1+i1)+u1+R1*iC1+L2*di2/dt+RL2*i2
u0=R0*(iC1+i1)+u1+R1*iC1+u2+R2*iC2+L3*di3/dt+RL3*i3
u0=R0*(iC1+i1)+u1+R1*iC1+u2+R2*iC2+u3+R3*iC3+L4*di4/dt+RL4*i4
u0=R0*(iC1+i1)+u1+R1*iC1+u2+R2*iC2+u3+R3*iC3+u4+R4*iC4+L5*di5/dt+RL5*i5
u0=R0*(iC1+i1)+u1+R1*iC1+u2+R2*iC2+u3+R3*iC3+u4+R4*iC4+u5+R5*iC5+L6*di6/dt+RL6*i6
Tephys-Algorithmus mit Runge-Kutta: Tephys-Dateien 6_1.txt, 6_2.txt
DGL=0
d= drei(fD*t)
u0 =aP*ja(t-t1)*ja(t2-t)+aD*d+aR*sign(d-sw)+aS*sin(2*pi*fS*t)
Teil1= u0 – u1-u2-u3-u4-u5-R0 *i1 + (R2+R3+R4+R5+RA)*i2
Teil2= (R3+R4+R5+RA)*i3 +(R4+R5+RA)*i4 +(R5+RA)*i5 +RA*i6
iC1= (Teil1+Teil2)/( R0+R1+R2+R3+R4+R5+RA )
iC2= iC1-i1
iC3= iC2-i3
iC4= iC3-i4
iC5= iC4-i5
u1= rk(iC1/C1)
u2= rk(iC2/C2)
u3= rk(iC3/C3)
u4= rk(iC4/C4)
u5= rk(iC5/C5)
i1= rk((u0-R0*(iC1+i1)-RL1*i1 )/L1)
i2= rk((u0-R0*(iC1-i1) - u1-R1*iC1- RL2*i2 )/L2)
i3= rk((u0-R0*(iC1+i1) - u1-R1*iC1-u2-R2*iC2 - RL3*i3 )/L3)
i4= rk((u0-R0*(iC1+i1) - u1-R1*iC1-u2-R2*iC2 –u3-R3*iC3– RL4*i4 )/L4)
i5= rk((u0-R0*(iC1+i1) - u1-R1*iC1-u2-R2*iC2 –u3-R3*iC3-u4-R4*iC4– RL5*i5 )/L5)
i6= rk((u0-R0*(iC1+i1) - u1-R1*iC1-u2-R2*iC2 –u3-R3*iC3-u4-R4*iC4-u5-R5*iC5– RL6*i6 )/L6)
END=0
uA= RA*(iC5-i6)
t = t+dt {Diese Gleichungen werden so oft wiederholt, bis t größer als die Maximalzeit tmax ist}
( DGL für i1 )
( DGL für i2 )
( DGL für i3 )
( DGL für i4 )
( DGL für i5 )
( DGL für i6 )
R. Kessler, D:\579911612.doc, Seite 8 /13
7 Bandpass: 2 Pi-Glieder aus kapazitiv gekoppelten Parallel-Schwingkreisen
K1
R0
Ck1
i1
C1
u1
L1
u0
RL1
Ck2
K2
K3
i2
uk1
C2
u2
L2
RL2
i3
uk2
C3
L3
u3
RL3
RA
uA
Nr. 7
Bandpass
Eigenschaften der Schaltungs-Struktur: 8 Energiespeicher. Aber die Kondensatoren Ck1 und Ck2 sind keine
„unabhängigen“ Energiespeicher, denn uk1 = u1 - u2 und uk2 = u2-u3. Es liegen also nur 6 unabhängige
Energiespeicher vor, nämlich C1, L1, C2, L2, C3 und L3. Also ist für die entsprechenden Zustandsvariabeln u1,
i1, u2, i2, u3 und i3 je eine DGL 1. Ordnung aufzustellen. Einfach sind nur die DGL für i1, i2 i3 zu finden:
L1*di1/dt + i1*RL1 = u1, L2*di2/dt + RL2*i2 = u2, L3*di3/dt + RL3*i3 = u3.
( DGLn für i1, i2, i4 )
Es müssen also noch die DGLN für u1, u2, u3 gefunden werden. ( Wieder die Schreibweise x’ = dx/dt )
Knoten K1:
(u0 - u1)/R0 = C1*u1’ + i1 + Ck1*(u1’ – u2’) = i1 + (C1+Ck1)*u1’ – Ck1*u2’
=> (1) (u0-u1)/R0 = i1 + (C1+Ck1)*u1’ – Ck1*u2’
Knoten K2:
Ck1*(u1’-u2’) = C2*u2’ + i2 + Ck2*(u2’-u3’) =>
=> (2) Ck1*u1’ = (Ck1+C2+Ck2)*u2’ – Ck2*u3’ + i2
Knoten K3:
Ck2*(u2’-u3’) = C3*u3’ + i3 + u3/RA =>
=> (3) Ck2*u2’ = (Ck2+C3)*u3’ + i3 + u3/RA
Aus den 3 Gleichungen (1), (2), (3) erkennt man das Lösungsprinzip, um u1’, u2’, u3’ zu gewinnen:
Aus (1) setzt man u1’ und aus (3) setzt man u3’ ein in die Gl. (2). Damit ist aus (2) eine Gl. für u2’ allein geworden,
dies u2’ setzt man dann in die Gl. für u1’ und für u3’ ein und hat damit auch u1’ und u3’. Ausführung:
Aus (1) folgt Gleichung für u1’: u1’ = 1/(C1+Ck1) * ( (u0-u1)/R0 –i1 +Ck1*u2’ )
Aus (3) folgt Gleichung für u3’: u3’ = 1/(Ck2+C3) * ( Ck2*u2’ – i3- u3/RA)
Jetzt diese Ausdrücke u1’ und u3’ einsetzen in (2):
Ck1/(C1+Ck1) * ( (u0-u1)/R0 –i1 +Ck1*u2’ ) =
(Ck1+C2+Ck2)*u2’ + i2 – Ck2/(Ck2+C3) * ( Ck2*u2’ – i3- u3/RA)
u2’ ausgeklammert:
u2’*( Ck1+C2+Ck2 –Ck1*Ck1/(C1+Ck1) – Ck2*Ck2/(Ck2+C3) ) =
Ck1/(C1+Ck1)*( (u0-u1)/R0-i1) - i2 - Ck2/(Ck2+C3) * (i3+u3/RA)
Mit der Ablürzung K2= ( Ck1+C2+Ck2 –Ck1*Ck1/(C1+Ck1) –Ck2*Ck2/(Ck2+C3) )
hat man also die DGL für u2:
u2’ = 1/K2*( Ck1/(C1+Ck1)*( (u0-u1)/R0-i1) - i2 - Ck2/(Ck2+C3) * (i3+u3/RA) )
( DGL für u2 )
und diesen Ausdruck u2’ eingesetzt in die beiden oben schon berechneten Formeln für u1’ und u3’:
u1’ = 1/(C1+Ck1) * ( (u0-u1)/R0 –i1 +Ck1*u2’ )
( DGL für u1 )
u3’ = 1/(Ck2+C3) * ( Ck2*u2’ – i3- u3/RA)
( DGL für u3 )
Tephys-Algorithmus mit Runge-Kutta: Datei 7_1.txt Problem: Division durch Null
DGL=0
u0 =aP*ja(t-t1)*ja(t2-t)+aD*d+aR*sign(d-sw)+aS*sin(2*pi*fS*t)
K2= ( Ck1+C2+Ck2 –Ck1*Ck1/(C1+Ck1) – Ck2*Ck2/(Ck2+C3) )
u2’ = 1/K2*(Ck1/(C1+Ck1)*((u0-u1)/R0-i1)- i2-Ck2/(Ck2+C3)*(i3+u3/RA))
u1= rk (1/(C1+Ck1) * ( (u0-u1)/R0 –i1 +Ck1*u2’ ) )
u2 = rk ( u2’)
u3 = rk ( 1/(Ck2+C3) * ( Ck2*u2’ – i3- u3/RA))
i1 = rk ( (u1- RL1*i1 )/L1 )
i2 = rk ( (u2- RL2*i2 )/L2 )
i3 = rk ( ( u3-RL3*i3 )/L3 )
END=0
uA=u3
t=t+dt
R. Kessler, D:\579911612.doc, Seite 9 /13
8 Bandsperre Pi
( Reihenschwingkreise als Querglieder, Parallel-Schwingkreis als Längsglied)
ik
Lk
R0
Ck
i1
i2
iCk
L1
u0
C1
M1
L2
uk
u1
C2
M2
RA
uA
u2
Nr 8 Bandsperre Pi
Einfach sind die DGLn für u1, u2, ik aufzustellen:
C1 * du1/dt = i1
C2 * du2/dt = i2
Lk * dik/dt = uk
( DGL für u1 )
( DGL für u2 )
( DGL für ik )
Hilfsgröße einführen: iCk = Strom durch Kondensator Ck (s. Figur)
Mit i1+ik+iCK = Strom durch R0 und mit ik+iCk-i2 = Strom durch RA wird die
Masche über alles: u0 = R0 * (i1 + ik + iCk) + uk + RA* ( ik + iCk – i2)
= (R0 + RA)* iCk + R0*(i1+ik) +RA*(ik –i2)
=> iCk = 1/(R0+RA) * (u0 –R0*(i1+ik) - RA*(ik – i2) )
(Hilfsgröße iCk)
Damit hat man die DGL für uk erhalten: Ck*duk/dt = iCk.
( DGL für uk )
Masche M1:
u0 = R0*(i1+ik+iCk) + L1*di1/dt + u1
Masche M1…M2: u0 = R0*(i1+ik+iCk) + uk + L2*di2/dt + u2
Tephys-Algorithmus mit Runge-Kutta:
DGL = 0
d=drei(fD*t)
u0 =aP*ja(t-t1)*ja(t2-t)+aD*d+ aR*sign(d-sw)+aS*sin(2*pi*fS*t)
iCk = 1/(R0+RA) * (u0 –R0*(i1+ik)-RA*(ik – i2) )
u1 = rk ( i1/C1 )
u2 = rk ( i2/C2 )
ik = rk ( uk/Lk )
uk = rk ( iCk/Ck )
i1 = rk ( ( u0 – R0*(i1+ik+iCk – u1 ) )/L1 )
i2 = rk ( ( u0 – R0*(i1+ik+iCk) – uk –u2 )/L2 )
END = 0
uA = RA*( ik + iCk – i2)
t = t+dt
( DGL für i1 )
( DGL für i2 )
R. Kessler, D:\579911612.doc, Seite 10 /13
9 Bandpass T
R0
C1
(Reihen-Schwingkreise als Längsglieder, Parallel-Schwingkreis als Querglied)
L1
i1
K
iCk
u1
Ck
u0
M1
Rk
uk
M2
C2
L2
i2
ik
Lk
u2
RA
uA
RLk
M3
Nr. 9 Bandpass T
Einfach sind die DGLn für u1 und für u2 aufzustellen:
C1*du1/dt = Strom durch C1 = Strom i1, also C1*du1/dt = i1
C2*du2/dt = Strom durch C2 = Strom i2, also C2*du2/dt = i2
( DGL für u1 )
( DGL für u2 )
Hilfsgröße: Strom durch Kondensator Ck ist iCk = i1 - ik - i2 (s. Figur)
=> Ck*duk/dt = iCk
Masche M1: u0 = R0*i1+ u1 + L1*di1/dt + uk + Rk*iCk
=> L1*di1/dt = u0 –R0*i1 –u1- uk – Rk*iCk
Masche M2:
uk + Rk*iCk = Lk * dik/dt + RLk * ik
Maschen M2...M3: uk + Rk*iCk = u2 + L2*di2/dt + RA*i2
( Hilfsgröße iCk )
( DGL für uk )
Tephys-Algorithmus mit Runge-Kutta:
DGL = 0
d=drei(fD*t)
u0 =aP*ja(t-t1)*ja(t2-t)+aD*d+aR*sign(d-sw)+aS*sin(2*pi*fS*t)
iCk = i1 – ik – i2
u1 = rk ( i1/C1 )
u2 = rk ( i2/C2)
uk = rk ( iCk/Ck)
i1 = rk ( (u0 – R0*i1 – u1 – uk – Rk*iCk ) /L1)
ik = rk ( (uk + Rk*iCk – RLk * ik ) /L1)
i2 = rk ( (uk + Rk*iCk – u2 – RA * i2 ) /L2)
END = 0
uA = RA * i2
t = t + dt
( DGL für i1 )
( DGL für ik )
( DGL für i2 )
R. Kessler, D:\579911612.doc, Seite 11 /13
10 Bandpass Pi
R0
(Parallel-Schwingkreise als Querglieder, Reihen-Schwingkreis als Längsglied)
Ck
K1
i1
Lk
K2
ik
iC1
iC2
i2
uk
L1
C1
u1
C2
u0
R1
RL1
M1
M2
R2
M3
u2
L2
RA
uA
RL2
M4
Nr 10 Bandpass Pi
Infolge R1 und R2 ist das Aufstellen der DGLn schwieriger als bei R1= R2= 0. Durch Einführen der
Kondensatorströme iC1 und iC2 gelingt es, die DGLn aufzustellen.
Knoten K1: Strom durch R0 = i1 + iC1 + ik =>
Maschen M1...M2: u0 = R0 * (i1 + iC1 + ik) + u1 + R1 * iC1 = R0*(i1+ik) + (R0 + R1)*iC1 + u1 =>
iC1 = C1*du1/dt = 1/(R0+R1) * (u0 – u1 – R0 * (i1+ ik) )
( DGL für u1 u. Hilfsgröße iC1)
Masche M1 : u0 = R0*(i1+iC1+ik) + L1*di1/dt + RL1*i1 =>
L1*di1/dt = u0 – R0*(i1+ iC1+ik) - RL1*i1
( DGL für i1 )
Knoten K2: ik = C2* u2’ + i2 + ( u2 + R2*C2*u2’ ) /RA = (1 + R2/RA)*C2 * u2’ + i2 + u2/RA =>
iC2 = C2 * du2/dt = 1/(1+R2/RA) * ( ik – i2 - u2/RA )
( DGL für u2 u. Hilfsgröße iC2 )
Masche M3: u1+R1*iC1 = uk + Lk*ik’ + u2 + R2*iC2 =>
Lk* dik/dt = u1 + R1*iC1 – uk – u2 – R2* iC2
Ck * duk/dt = ik
Masche M4: u2 + R2*iC2 = L2*di2/dt + RL2*i2 =>
L2*di2/dt = u2 + R2*iC2 – RL2*i2
Ausgangsspannung
uA = RA* (ik – iC2 – i2)
Algorithmus mit Runge-Kutta:
DGL = 0
d=drei(fD*t)
u0 =aP*ja(t-t1)*ja(t2-t)+aD*d+aR*sign(d-sw)+aS*sin(2*pi*fS*t)
iC1 = 1/(R0+R1) * (u0 – u1 – R0 * (i1+ ik))
iC2 = 1/(1+R2/RA) * ( ik – i2 - u2/RA )
u1 = rk ( iC1/C1 )
u2 = rk ( iC2/C2 )
i1 = rk ( ( u0 – R0*(i1+ iC1+ik) - RL1*i1 )/L1 )
ik = rk ( (u1 + R1*iC1 – uk– u2 – R2* iC2 )/Lk )
uk = rk ( ik/Ck )
i2 = rk ( ( u2 + R2*iC2 – RL2*i2 )/L2 )
END= 0
uA = RA* (ik – iC2 – i2)
t = t + dt
( DGL für ik )
( DGL für uk )
( DGL für i2 )
R. Kessler, D:\579911612.doc, Seite 12 /13
11 Bandsperre T
i1
L1
i2
L2
K
R0
C1
C2
ik
iC1
u1
u0
M1
Lk
Ck
u2
RA
uA
uk
Nr 11 Bandsperre T
Einfach sind die DGLn für i1, i2, uk aufzustellen:
L1*di1/dt = u1
L2*di2/dt = u2
Ck*duk/dt = ik
( DGL für i1 )
( DGL für i2 )
( DGL für uk )
Einführen der Hilfsgröße iC1 = Strom durch Kondensator C1 ( s. Figur).
Mit i1 + iC1 = Strom durch R0 und mit i1+ iC1 - ik = Strom durch RA folgt für die
Masche über alles: u0 = R0*(i1+ iC1) + u1 + u2 + RA*(i1 + iC1 - ik)
=> u0 = (R0+RA)*iC1 + R0*i1 + u1 + u2 + RA *(i1-ik)
=> iC1 = 1/(R0+RA) * (u0 - R0*i1 + u1 + u2 - RA*(i1-ik )
( Hilfsgröße iC1 )
=>
C1 *du1/dt = iC1
( DGL für u1 )
Masche M1:
Knoten K:
u0 = R0*(i1+iC1) + Lk*dik/dt + uk
i1+iC1 = ik + i2 + C2*du2/dt
Tephys-Algorithmus mit Runge-Kutta:
DGL = 0
d=drei(fD*t)
u0 =aP*ja(t-t1)*ja(t2-t)+aD*d+aR*sign(d-sw)+aS*sin(2*pi*fS*t)
iC1 = 1/(R0+RA) * (u0 - R0*i1 + u1 + u2 - RA*ik )
i1 = rk ( u1/L1 )
i2 = rk ( u2/L2 )
uk = rk ( ik/Ck )
u1 = rk ( iC1/C1 )
ik = rk ( ( u0 – R0*(i1+iC1) – uk ) )/Lk )
u2 = rk ( ( i1 + iC1 –ik – i2 )/C2 )
END = 0
uA = RA+( ik + iC1 – ik)
t = t+dt
( DGL für ik )
( DGL für u2 )
R. Kessler, D:\579911612.doc, Seite 13 /13
12 Bandsperre T (mit Erschwernis infolge Reihenwiderständen R1, R2)
RL1
i1
L1
RL2
R0
i2
L2
K
R1
C1
R2
C2
ik
iC1
u1
iC2
Lk
u2
RA
u0
RLk
M1
Ck
uk
uA
M2
Nr 12 Bandsperre T (mit zusätzlichen Widerständen R1, R2 und RLk)
Infolge der zusätzlichen Widerstände R1, R2 zbd RLk ist das Aufstellen der DGLn etwas schwierger als bei
Schaltung Nr 11.
Einfach ist nur, die DGL für uk aufzustellen: Ck * duk/dt = ik
( DGL für u1 )
Für die anderen DGLn werden die Hilfsgrößen iC1 und iC2 eingeführt (s. Figur)
Knoten K: i1 + iC1 = ik + i2 + iC2 => iC2 = i1 + iC1 –ik – i2
Masche über alles: u0 = R0 *(i1 + iC1) + iC1 * R1 + u1 + iC2 * R2 + u2 + RA* (i1 + iC1- ik )
oder nach Einsetzen von iC2
u0 = R0*(i1+iC1)+iC1*R1+u1+R2*(i1+iC1-ik-i2) +u2 + RA* ( i1 + iC1 – ik )
=> u0 = (R0+R1+R2+RA)*iC1 + R0*i1 + u1 + R2*(i1-ik-i2) + u2 + RA*(i1-ik)
=> iC1 = 1/(R0+R1+R2+RA) * ( u0 – u1 –u2 – (R0+R2+RA)*i1 +R2*i2 + (R2+RA)*ik ) ( Hilfsgröße iC1 )
Mit iC1 ist das Aufstellen für die restlichen DGLn kein Problem mehr:
u1: C1*du1/dt = iC1
u2: C2*du2/dt = i1+iC1-ik-i2 (= iC2)
i1: RL1*i1 + L1*di1/dt = R1*iC1 + u1
i2: RL2 * i2 + L2 * di2/dt = R2*(i1+iC1-ik-i2)
Masche M1:
u0=R0*(i1+iC1) +R1*iC1 + u1 + Lk*dik/dt + RLk*ik + uk
Tephys-Algorithmus mit Runge-Kutta:
DGL = 0
d=drei(fD*t)
u0 =aP*ja(t-t1)*ja(t2-t)+aD*d+aR*sign(d-sw)+aS*sin(2*pi*fS*t)
iC1 = 1/(R0+R1+R2+RA) * ( u0 – u1 –u2 – (R0+R2+RA)*i1 +R2*i2 + (R2+RA)*ik )
uk = rk (ik/Ck)
u1 = rk ( iC1/C1)
u2 = rk ( (i1+iC1-ik-i2 )/C2)
i1 = rk ( (R1*iC1+u1- RL1*i1)/L1)
i2 = rk ( ( R2*(i1+iC1-ik-i2) – RL2*i2 )/L2)
ik = rk ( (u0-R0*(i1+iC1)-R1*iC1-u1-RLk*ik-uk )/Lk)
END = 0
t = t +dt
( DGL für u1 )
( DGL für u2 )
( DGL für i1 )
( DGL für i2 )
( DGL für ik )