Wir konstruieren eine LC-Kette und machen daraus ein Modul, dann
vergleichen wir die LC-Kette mit einer elektrischen Leitung.

LC-Kette als Leitungsmodell:

Wir öffnen die Schaltung DocSamples/LCLine20.circ:

Wir sehen hier eine Kette von LC-Gliedern, die eine Leitung nachbilden sollen. Da wir nicht jeden
L- und C-Parameter einzeln ändern wollen, legen wir sogenannte Circuit-Parameter an.
Mittels Menue: Settings/Edit Circuit Script öffnen wir einen Text-Editor, wo wir folgendes eintragen:

#Parameter
L = L(H), 10m
C = C(F), 1u
#End

#VarsAndConstants
C1.C = C/2
C2.C = C
C3.C = C
C4.C = C
C5.C = C
C6.C = C
C7.C = C
C8.C = C
C9.C = C
C10.C = C
C11.C = C
C12.C = C
C13.C = C
C14.C = C
C15.C = C
C16.C = C
C17.C = C
C18.C = C
C19.C = C
C20.C = C/2
C21.C = C
L1.L = L
L2.L = L
L3.L = L
L4.L = L
L5.L = L
L6.L = L
L7.L = L
L8.L = L
L9.L = L
L10.L = L
L11.L = L
L12.L = L
L13.L = L
L14.L = L
L15.L = L
L16.L = L
L17.L = L
L18.L = L
L19.L = L
L20.L = L
#End

#DefineDynCharts ; ab Version 1.26
#End

Mit dem #Parameter beginnt der Parameter-Block, mit #End wird er abgeschlossen. Vor dem '=' steht das
Parameter-Symbol, hinter dem '=' steht die Parameter-Beschreibung, nach dem ',' der Standardwert. In
diesem Falle definieren wir also die Parameter L und C.  Um nun die Parameter-Änderung für alle Elemente
gleichermaßen durchzuführen, müssen wir sozusagen einen Link vom Parameter zu den  Elementen herstellen.
Genau das findet im Block #VarsAndConstants statt. Auf der linken Seite steht das TokenRefParameter-Symbol
(hatten wir ja schon), auf der rechten Seite das Parameter-Symbol oder eine Formel, die Parameter-Symbole
enthält. Jeder Parameter wird also nach Änderung von Oben nach Unten, sowie von Rechts nach Links
zugewiesen. Für Formeln stehen diese Funktionen bereit. Ab Version 1.26 kann der #DefineDynCharts-Block
dazu verwendet werden, sogenannte DynCharts auch auf Circuit-Ebene zu definieren (selbes Vorgehen wie auf
Modul-Ebene, siehe hier).
Nach Abspeicherung des Circuit-Scripts können wir über Menue: Settings/Change CircuitParams L oder C
ändern, nach Schließen des Dialogs werden alle Kapazitäten und Induktivitäten entsprechend geändert.
Wir geben für L: 100uH und für C: 100pF ein, und lassen Dyna rechnen mit folgenden Ergebnissen:

Der Signal-Generator arbeitet mit einem Einschaltsprung bei 100us und hat einen Innenwiderstand von nur 10Ohm.
Das Scope-Element hat einen hochohmigen Messwiderstand. Am Eingang der Kette haben wir also quasi Kurzschluss,
am Ausgang Leerlauf. Das Ding verhält sich wegen der Reflexionen wie ein schwingendes System.
Der Wellenwiderstand und die Laufzeit ergibt sich nämlich zu:

Ich habe gleich mal noch die DynCharts L12.Il und L13.Il definiert:

Man erkennt, dass der Verlauf des Spulen-Strom's abhängig ist von der Position in der Kette (Leitung).

Da wir im Endeffekt eine Leitung nachbilden wollen, führen wir die Parameter: Len (Länge der Leitung),
ZW (Wellenwiderstand) und vkf (Verkürzungsfaktor) ein. Um daraus die einzelnen L und C zu berechnen, ist
ein wenig Mathematik notwendig:


Dieses diskrete Modell einer Leitung wird natürlich bei steigenden Frequenzen immer ungenauer. Deswegen
legen wir eine Grenzfrequenz fg fest, bei der die Leitungs-Länge einer vollen Sinus-Periode entspricht.

Die rechnerischen Grundlagen haben wir gelöst. Den Circuit-Script ändern wir nun folgendermaßen:

#Parameter
len = Length(m), 10
ZW = WaveImpedance(Ohm), 60
vkf = Verkürzungsfaktor, 0.7
Rs = Resist (Ohm/m), 0.1
#End

#VarsAndConstants
C0 = 300e6
v = vkf*C0
Cs = 1/(Zw*v)
Ls = Zw/v
dl = len/20
C = Cs*dl
L = Ls*dl
R = fmax(Rs*dl, 1e-6)
tv = len/v
fg = 1/tv
.
.
#End

So, unser Modell ist nun fertig und wir können uns aufmachen ein Modul-Script zu erzeugen.

Ein Modul ist nichts Anderes als eine Schaltung in Textform, deren AußenPins definiert wurden, und welches mit Hilfe
eines Symbols (ModulBitmap) wie ein Element in andere Schaltungen eingefügt werden kann.

Erstellung eines ModulBitmaps:

Bevor wir das Modul-Script erzeugen können, brauchen wir ein Schaltsymbol für das Modul-Element. Dieses wird
als M(odul)Bitmap bezeichnet. Ein MBitmap beinhaltet ein gewöhnliches Bitmap zuzüglich der Koordinaten für die
Anschluß-Pins. Daher müssen wir erst ein Bitmap erstellen (Paint.Net eignet sich hervorragend dafür).

Keine Angst, ich habe natürlich schon mal ein Bitmap erstellt. Stark vergrößert sieht es so aus:

Die roten Beschriftungen und der Teil außerhalb des grauen Rahmens sind nicht Teil des Bitmaps.
Alle Koordinaten beziehen sich auf die obere linke Ecke des Bitmaps (Position 0,0). Man muß sich vorher
klar machen welche Pin-Nummer an welche Position gehört. Pin-Positionen müssen Vielfache von 16 (8 bei Raster=8)
sein. Höhe und Breite des Bitmaps müssen Vielfache von 16 sein, um 1 erhöht (z.Bsp. 33, 65, 129).
Es sind 16 sowie 256-Farben-Bitmaps möglich.
Das Bitmap speichert man am besten mit in den Ordner des MBitmaps.

Nachdem unser Bitmap gespeichert wurde, öffnen wir über Menue: Tools/CreateEdit ModulBitmap den
MBitmap-Dialog:

Mittels des Buttons Load Bitmap öfnen wir den OpenBitmap-Dialog und wählen aus:

Nach Drücken von Open wird das ausgewählte Bitmap in den MBitmap-Dialog geladen:

Nun tragen wir die Pin-Positionen bei Connections Points ein und legen einen MBitmap-Namen fest. Die roten
Ziffern zeigen aktuell den Erfolg an. Mit dem Button Save ModulBitmap wird das MBitmap im MBitmap-Folder
abgespeichert. Dieser Folder kann oben bei MBitmap Folder vorher (wenn vorhanden) ausgewählt werden.
Möchte man ein MBitmap ändern, dann lädt man es über Load ModulBitmap ein, der Open-Dialog ist der
Selbe wie beim Bitmap. Man kann dann über Load Bitmap ein neues oder geändertes Bitmap zuweisen als auch
die Connection Points abändern.

MBitmaps sind autark, es existiert keine Referenz auf das Bitmap.
Bitmaps sowie MBitmaps können nur unterhalb des Data-Verzeichnisses abgelegt werden. Die internen Bitmaps
können natürlich auch verwendet werden.

Generierung des Moduls aus der Schaltung:

Wir ändern jetzt die Schaltung folgendermaßen ab:

Da wir nur die Kette im Modul haben möchten, ziehen wir den Signal-Generator und die Masse heraus. Diese Elemente
werden somit deaktiviert und beim Erzeugen des Scripts ignoriert. Um das Scope-Element muß man sich nicht kümmern,
da alle ausgebenden Elemente automatisch bei der Script-Erzeugung ignoriert werden.
Nun müssen nur noch die Pins gesetzt werden. Dazu fügt man sogenannte Modul-IO-Elemente (rotes Kästchen mit
Pin-Nummer) ein. Die Pin-Nummer kann mittels Klick der rechten Maustaste auf dieses Element geändert werden.
Die jeweilige Modul-Pin-Nummer muß natürlich mit der entsprechenden MBitmap-Pin-Nummer übereinstimmen.
Den Button für ein Modul-IO-Element findet man oben in der 1. ToolBar.

Nach Abschluß dieser Arbeiten öffnen wir über Menue:Project/Save ModulScript diesen Dialog:

Hier wählen wir nun unser MBitmap LCLine.mbmp aus und legen den Namen für unser Modul-Script fest.
Das Verzeichniss (bei Modul Script Folder) ist ebenfalls änderbar.
Nach Druck auf OK wird der Script unter  Data\Miscellaneous\LCLine.mscr abgespeichert. Abschließend
sollte man die Schaltung speichern, da die hier gemachten Einstellungen mit in der Circ-Datei gespeichert
werden.

Schauen wir uns einen Teil der MSCR-Datei mal genauer an:

#Token = LC
#AutoComment = <tv>s, <fg>Hz

#Description
LC SerialLine with 20 LC-Parts
#End

#PinDescriptions
Pin1 = In
Pin2 = Out
Pin3 = Earth
#End

#DefineStaticInfoText
Uin = <u1-u3>V, Uout = <u2-u3>V, Iser = <(u1-u2)/(Rs*len)>A
#End

;-----------------------------------------------------
$$$ Beginning of auto generated Setting

#Parameter
len = Length(m), 10
ZW = WaveImpetance(Ohm), 60
vkf = Verkürzungsfaktor, 0.7
Rs = Resist (Ohm/m), 0.1
#End

#VarsAndConstants
C0 = 300e6
v = vkf*C0
Cs = 1/(Zw*v)
Ls = Zw/v
dl = len/20
C = Cs*dl
L = Ls*dl
R = fmax(Rs*dl, 1e-6)
tv = len/v
fg = 1/tv
.
die Zuweisungen für die TokenRefParameter weggelassen
.
#End

#DefineDynCharts
Uin = Voltage In, V, u1-u3
Uout = Voltage Out, V, u2-u3
#End

#MBitmap = LCLine.mbmp

#Connections
Pin1 = 2
Pin2 = 3
Pin3 = 1
#End

#SetCapacitor
Token = C7
Pin1 = 1 ;Pin1
Pin2 = 4 ;Pin2
C = 3.96825n ;C(F)
Riso = 100M ;Riso(Ohm)
#End

#SetCoil
Token = L6
Pin1 = 5 ;Pin1
Pin2 = 4 ;Pin2
L = 14.2857µ ;L(H)
R = 1m ;Rl(Ohm)
#End

weitere Elemente .....

Hier der komplette Script

Über der $$$-Zeile müssen noch nachträglich Eintragungen mit der Hand gemacht werden.
Das sind:

#Token =
Kürzel, welches als TokenReferenz benötigt wird und dem AutoToken in der Schaltung entspricht.

#AutoComment =
Der Text hinter dem '=' wird nach Ausführung von Add AutoComments am Element erzeugt.
Die Brackets (<>) dienen als Platzhalter für Parameter und Variable, die im Script definiert wurden.
Einen Zeilensprung erreicht man durch Einfügen von  '\n'.
In diesem Beispiel wird so im Dokument die Verzögerungszeit Tv und die Grenzfrequenz fg angezeigt.

#Description
#End
In diesem Block kann ein Bezeichnungstext vorgegeben werden, der an einigen Stellen im Programm
angezeigt werden kann.

#PinDescriptions
#End
In diesem Block kann ein Bezeichnungstext für die einzelnen Pins vorgegeben werden, der an einigen Stellen
im Programm angezeigt werden kann.

#DataBase=
Hier kann der Name einer textbasierten Datenbank angegeben werden. (Dazu später)

#DefineStaticInfoText
#End
Dieser Block erlaubt das Definieren des Ausgabe-Textes bei der Funktion Analysis/Get Static Infos
Die Brackets (<>) dienen als Platzhalter für Formeln, die Pin-Potentiale (U1,U2,U3), Parameter
sowie Variable enthalten können. 

#DefineDynCharts
#End
Dieser Block erlaubt das Definieren von mehreren DynCharts. Pro Zeile wird ein DynChart definiert.
Vor dem '=' steht das Kurz-Symbol (DynChart-Symbol), hinter dem '=' der Beschreibungstext, hinter dem 1. ',' das
Einheitenkürzel und hinter dem 2.',' eine Formel. Für die Formel gilt das Selbe wie bei DefineStaticInfoText.
Ab Version 1.26 ist es möglich (nur in Modulscripts/Circuitscripts) sogenannte TokenRefDynChart-Symbole als auch TokenRefParameter-Symbole in den Formeln zu verwenden. Die Verwendung dieser Symbole wird hier genau beschrieben.

Die Zeilen über der $$$-Zeile bleiben beim Überschreiben der Datei mittels Save ModulScript unverändert.
Die Zeilen darunter werden immer automatisch aus den Daten der Circ-Datei neu erzeugt.

Die Blöcke #Parameter und #VarsAndConstants kennen wir ja schon. Diese werden einfach aus dem
Circuit-Script der Circ-Datei übernommen. Aus den Circuit-Parametern werden somit die Modul-Parameter
Ab Version 1.26 wird auch der #DynChart-Block aus dem Circuit-Script übertragen. Aus den Circuit-DynCharts werden
dann die Modul-DynCharts.
Bei #MBitmap wird der Name der MBitmap-Datei eingetragen, die das Schaltsymbol für das Modul-Element
repräsentiert.
Dann folgen noch die Zuordnung der inneren Knoten zu den Anschluß-Pins (#Connections) sowie die Elemente-Blöcke
mit den Pin- und Parameterangaben. (Netzwerk-Liste)

Wenn man es drauf hat, kann diese Script-Datei auch vollständig händig erstellt werden.
Nach dem erstmaligen Einfügen des neuerstellten Modul-Elements wird eine sogenannte GUID ganz am Anfang
der Script-Datei generiert. Das ist eine weltweit eindeutige Kennzeichnung (ID) um es unabhängig vom Speicher-Ort
unterhalb des Data-Verzeichnisses zu finden. Es könnte ja vorkommen, daß der selbe Datei-Name schon für ein
anderes Element benutzt wird.

Vergleich LC-Kette mit dem Modell der elektrischen Leitung:

Nun schauen wir uns noch an wie sich die diskrete LC-Kette im Vergleich zum ELine-Element schlägt.
Bitte die Schaltung DocSamples/LCLine_ELine_Compare.circ öffnen:


In der oberen Schaltung  habe ich unser frisch erstelltes Modul LCLine.mscr eingefügt, in der Unteren
das externe Leitungs-Modell ElectricLine.selfdef. Das ist ein kontinuierliches Modell, welches als
Laplace-Transformierte niedergechrieben ist. Bei hohem Verlustwiderstand Rs neigt dieses Modell zu
Ungenauigkeiten, je tiefer die Frequenzen werden. Line1 ist also bei hohen Frequenzen, LC1 bei tiefen
Frequenzen genau. Die Grenze liegt etwa bei 2Mhz, was der AutoComment von LC1 auch anzeigt.

Schauen wir uns nun den Ausgangs-Spannungs-Verlauf bei Abschaltsprung am Eingang für beide Modelle an:

Man sieht, dass die Ergebnisse recht ähnlich sind. Bei LC1 fällt aber das Überschwingen bei Sprung-Änderungen auf.
Die zunehmenden Frequenz-Anteile werden nämlich immer mehr verschluckt. Das Fehlen dieser hohen Frequenzen
führt zum sogenannten Gibbschen Phänomen. Je steiler die Abschalt-Flanke des Eingangssignals, desto größer werden
die Überschwinger, da die hohen Frequenz-Anteile anwachsen.
Wenn man sich die Sprungschwingungen wegdenkt, dann erkennt man, dass die LCLine bei groben Analysen sehrwohl
auch für hohe Frequenzen (Schalt-Signale) geeignet ist.

Sehr interessant wäre noch die Durchführung einer Kleinsignal-Analyse (LSA), wo man das Frequenz-Verhalten
besser erkennen kann. Also als Übung: 2 LSA-Analyser reinschieben und los gehts.

Zurück zur Hauptseite