Dynamo / Elektromotor - Simulation mittels LaplaceVolt-Modell

Das Grundprinzip aller Dynamo/Elektromotor-Typen läßt sich mit einer stromdurchflossenen Leiter-
schleife, die in einem Magnetfeld rotiert, beschreiben. Deswegen müssen wir erstmal ein mathematisches
Modell erschaffen, um das mechanische als auch das elektrische Verhalten eines solchen Grundelements
zu beschreiben.

Math. Modell einer sich drehenden Leiterschleife in einem konstanten Magnetfeld

Wir nehmen eine Leiterschleife (bzw. mehrere zusammengefasst zu einer Wicklung) , die über einem Rotor
mittig mit einer Welle verbunden ist. Für das Magnetfeld sorgt ein Dauermagnet. Der elektrische Kontakt
nach Außen wird mit Bürsten hergestellt.
An der Welle soll ein Lastdrehmoment angelegt werden. Die Masse des Rotors, der Wicklung und der
Welle wird mit einem Massenträgheitsmoment berücksichtigt.

Wir gehen absofort von einer Wicklung aus (mehrere Leiterschleifen, Anzahl N).
Die sogenannte Lorentzkraft Flo wird durch den Strom auf der Länge lw und dem Magnetfeld hervorgerufen:

Das Drehmoment, welches durch die Lorentzkraft erzeugt wird, errechnet sich zu:

Die Kraft wirkt mit dem Hebel rw*sin(alfa). Da die gleiche Kraft an der gegenüberliegenden Seite in die
entgegengesetzte Richtung (nach oben) wirkt, ist das Gesamt-Dreh-Moment doppelt so hoch.
Wir führen noch eine Maschinen-Konstante K ein und können dann die Formel kürzer schreiben:

Bei gleichbleibender Drehzahl (oder in Ruhe) müssen sich das Lastdrehmoment und das Lorentzdrehmoment
aufheben:

Da aber im allgemeinen eine Rotations-Beschleunigung (bzw. Abbremsung) stattfindet, muß noch das Drehmoment
berücksichtigt werden, welches durch das Massenträgheitsmoment J erzeugt wird:

Das Lorentzmoment muß nun gegen das Lastdrehmoment und das Trägheitsmoment gleichzeitig ankämpfen, für die
Bilanz der Drehmomente ergibt sich dann folgende Beziehung:

Wir haben nun die Differential-Gleichung um Alfa(t) zuberechnen. Der Strom i1 tritt hier noch als unbekannte 
Zeitfunktion auf, aber keine Angst, ToneCirc berechnet diesen Strom, da ja dieses Element Teil eines Netzwerkes
ist.
Wir wandeln die Differential-Gleichung in eine Differenzen-Gleichung um (Diskretisierung) und stellen nach
Alfa[k] um:

Für den Strom bietet sich die Verwendung des PinOldStroms (_i1) an. Dieser Strom wird von ToneCirc für einen
Zeitschritt früher berechnet. Die Alfa's werden als StateVars definiert.

Da an den Leiterschleifen nicht nur Kräfte wirken bzw. entstehen sondern auch eine Spannung durch die Drehung
im Magnetfeld erzeugt wird, entsteht eine Rückwirkung auf die Anschlußklemmen. Diese Induktionsspannung
entsteht durch die Änderung des effektiven Magnetflusses bei Drehung. Wir berechnen den effektiven Magnet-
Fluss aus der Magnetflussdichte und der effektiven Durchströmungsfläche folgendermaßen:

Mit Hilfe des Induktionsgesetzes können wir nun daraus die momentane Induktionsspannung ermitteln:

Wir führen wieder eine Diskretisierung durch:

Was jetzt nur noch fehlt ist die bei einer Induktivität (die Wicklung) übliche Selbstinduktions-Spannung sowie
der Spannungsabfall durch den ohmschen Wicklungswiderstand:

Die beiden Induktionsspannungen wirken zusammen auf die Anschluß-Klemmen. Deswegen muß die Gesamt-
Gleichung für die Klemmenspannung so aussehen:

Das ist unsere Hauptgleichung, sie beschreibt nichts Anderes als eine Induktivität mit irgendeiner von Außen
induzierten Spannung. Für den Script wandeln wir noch in die Laplacetransformierte um:

Für Eintragungen in #DefineDynCharts definieren wir noch die Drehzahl sowie die mechanische
Leistung:

Der Script sieht dann im Wesentlichen so aus:

#Parameter
Alfa0G = Startwinkel (°), 10
N = Windungen Anzahl, 1000
B = Flussdichte Magnet (T), 1
lw = Tiefe der Wicklung (m), 0.01
rw = Radius der Wicklung (m), 0.005
Mla= Last Drehmoment (Nm), 10
J = Trägheitsmoment (kgm^2), 0.001
Al = Induktivitätsbelag Wicklung (H), 1u
Rl = Wicklung-Widerstand (Ohm), 1
#End

#VarsAndConstants
K = B*lw*N*2*rw ; Maschinenkonstante
L = Al*N*N ; Wicklungs-Induktivität
dt = g_timestep
alfa0 = alfa0G*c_2pi/360 ; Startwinkel in Radiant umrechnen
#End

#Volts
uw = u1 - u2
End

#StateVars
alfa = Alfa0 ; alfa[k]
alfa1 = Alfa0 ; alfa[k-1]
alfa2 = Alfa0 ; alfa[k-2]
#End

#LaplaceVolts
alfa = {g_time > 0 ? dt*dt/J*(sin(alfa1)*K*_i1 - Mla) + 2*alfa1 - alfa2 : Alfa0}
alfaP = (alfa - alfa1)/dt
alfa2 = alfa1
alfa1 = alfa
Uq = K*alfaP*sin(alfa)
uw = (L*s + Rl)*i1 + Uq
<i2 = -i1>
#End

#DefineDynCharts
UL = Voltage, V, uw
IL = Current, A, i1
n = Rot Speed, 1/s, alfaP/c_2pi
alfa = Winkel, °, alfa*360/c_2pi
Pel = Power (elektr), W, uw*i1
Pme = Power (mech), W, Mla*alfaP
#End

Da alfa bei der statischen Analyse (g_time = 0) auf dem Winkel Alfa0 stehen bleiben soll, habe ich bei dessen
Berechnung noch eine Relationsanweisung hinzugefügt. Der vollständige Script Dynamo.selfdef ist hier zu sehen
und befindet sich im Verzeichniss Data/ElectroMechanics. Als MBitmap wird dynamo1.mbmp verwendet.


Simulation des Dynamos:

Bitte die Schaltungsdatei DocSamples\Dynamo_test.circ öffnen:

Nach Ausführen von Dyna öffnen unter anderem folgende Chartfenster:

Man sieht, dass die Drehzahl erstmal schnell ansteigt um dann gegen einen konstanten Wert (hier etwa 1.4 U/s) zu
konvergieren. Bei konstanter Drehzahl muß laut Energieerhaltungssatz die elektrische Leistung gleich der mechan.
Leistung sein. Das ist wie zu sehen der Fall, da der Effektivwert von Pel (die hälfte vom Maximum) gleich dem Wert
von Pme am Ende der Kurven ist. Am Anfang aber ist die mechanische Leistung größer als die Elektrische, da für
die Rotationsbeschleunigung des Massenträgheitsmomentes Leistung aufgewendet werden muß. Das Dynamo speichert
also mechanische Energie.

Interessant wird es wenn man den Parameter Lastdrehmoment auf 5mNm erhöht. Dann ergeben sich nach Dyna für die
Leistungen folgende Zeitverläufe:

Das Lorentzdrehmoment schaft es zu keinem Zeitpunkt gegen das Lastdrehmoment anzukommen. Der Rotor dreht sich
immer schneller, die mechan. Leistung wird immer größer, die mechan. Rotations-Energie wächst quadratisch mit der
Zeit. Die elektrische Leistung aber läuft gegen etwa 200mW eff. und erhöht sich dann nicht weiter.

Um dem Parameter Lastdrehmoment ein zeitliches Verhalten zuzuweisen, definiert man einfach eine Circuit-Variable,
und weist dieser eine Zeitfunktion zu. Wie das gemacht wird, hatten wir ja hier schon besprochen.

Wenn man anstatt des Lastdrehmomentes die Lastdrehleistung (Pme) als Parameter definieren möchte, so muß man in
die Gleichung für alfa[k] die Beziehung Pme = (alfa[k] - alfa[k-1])/dt*Mla entsprechend einarbeiten.

Dem aufmerksamen Leser wird sicherlich aufgefallen sein, dass noch ein wichtiges Drehmoment in den Betrachtungen
fehlt. Es handelt sich um das sogenannte Widerstands-Drehmoment:

Dieses Drehmoment entsteht durch Reibung in den Wellenlagern und Bürsten sowie durch den Luftwiderstand des
Rotors. Durch Dieses wird bei Drehung Verlustleistung produziert, die sich letztendlich als Wärme bemerkbar macht.
Die elektrische Verlustleistung hatten wir ja schon mit dem Wicklungswiderstand R berücksichtigt. Die Vernachlässigung
von D führt natürlich bei hohen Drehzahlen zu größeren Fehlern in diesem Modell. Den kann man aber noch leicht
hinzufügen.

Dieses Dynamo-Element kann umgekehrt, wenn man elektrische Leistung einspeisst, auch als Wechselstrom-Motor
betrieben werden. Der wird sich aber nur gleichförmig drehen wenn man eine bestimmte Frequenz anlegt, ansonsten
wackelt das Ding wie ein Besoffener hin und her. Dieses Element wird uns aber noch sehr nützlich sein bei der Entwicklung
komplizierterer Motoren, wie im nächsten Kapitel beschrieben wird.


Entwicklung des Modells für einen einfachen Gleichstrom-Elektromotor:

Für die Entwicklung dieses Modells greifen wir auf das Oben erstellte Modell des Dynamos zurück, wobei wir dieses
Modell erweitern um die momentane Winkelstellung (alfa) der Wicklung nach Außen geben zu können. Das tun wir mit
einem Trick indem wir Sinus(alfa) als Spannung an einem zusätzlichen Anschluss (Pin 3) ausgeben.
Den obigen Script erweitern wir mit der zusätzlichen Spannungsquelle und nennen ihn emotorhelper1.selfdef:

#VarsAndConstants
....
ralfa = 0.1 ; Hilfswiderstand für Ualfa-Ausgabe
#End

#Volts
uw = u1 - u2
ualfa = u3 - u0
#End

#LaplaceVolts
....
Ualfa0 = sin(alfa)
....
ualfa = ralfa*i3 + Ualfa0
....
<i0 = -i3>
#End

Dieser Script befindet sich ebenfals im Verzeichniss Data/ElectroMechanics und verwendet das MBitmap 
emotorhelper1.mbmp, welches noch einen zusätzlichen Anschluß-Pin für Ualfa hat.
Wir können nun eine Schaltung bauen, die in Abhängigkeit vom Winkel Alfa Umschalt-Aktionen durchführt. Die
Spannung an der Wicklung muß nämlich bei Modulo 180° umgepolt werden, damit das Lorentzdrehmoment immer
in die gleiche Richtung wirken kann.

Bitte die Schaltung DocSamples/DCMotor1_Modul.circ öffnen:

Die Spannung Ualfa steuert 4 Schalter. Bei Ualfa = 0...1V (sin(alfa) > 0) werden die Schalter SW2 und SW4 durch-
geschaltet, somit liegt die Klemme Sig1+ an der Klemme Mo+ und Sig1- an Mo-. Bei Ualfa = -1...0V (sin(alfa) < 0) werden
die Schalter SW1 und SW3 durchgeschaltet, somit liegt die Klemme Sig1+ an der Klemme Mo- und Sig1- an Mo+.
Die Invertierer Def1/Def2 sorgen dafür, dass SW1 und SW3 bei negativer Steuerspannung durchschalten.
Die Speisespannung wird also bei jeder halben Umdrehung umgepolt. Die geteuerten Schalter sind sozusagen virtuell und
übernehmen ziemlich exakt die Simulation des Umpolens.
Damit ist das Modell für einen Ein-Wicklungs-Gleichstrom-Motor schon fertig. Schreiten wir als zur Simulation.

Simulation des Gleichstrom-Motors:

Nach der Dyna öffnen die folgenden DynCharts:

Diese Spannungen und Ströme werden direkt an der Wicklung von Mo1 gemessen. Man sieht, dass sie sehr peekförmig
verlaufen, was durch das ständige harte Umschalten der Spannungsquelle zu begründen wäre. Es liegt auf der Hand,
dass solch ein Motor starke elektromagnetische Störungen verursacht.

Die Drehzahl und damit die elektrische Eingangs-Leistung konvergieren gegen einen Wert, der durch Speisespannung,
Innenwiderstand, Lastdrehmoment und aller Motor-Parameter betimmt ist.

Wenn wir nicht nur forschen und entwickeln wollen, sondern auch anwenden, müssen wir dieses Motor-Modell in ein
kompaktes Modul umwandeln, um es dann in anderen Schaltungen einsetzen zu können.


Erzeugung eines Modul-Scripts für den DC-Motor:

Wie man ein Modul-Script erstellt wurde ja hier schon ausgiebig erläutert.
Wir nehmen die Schaltung DocSamples/DCMotor1_Modul.circ, fügen IO-Pins hinzu (Pin 1 für In+, Pin 2 für In-) und
schieben Sig1 sowie die Masse heraus. 

Bei Menü:Settings/Edit Circuit Script tragen wir die gewünschten Parameter folgendermaßen ein:

#Parameter
Alfa0G = Startwinkel (°), 10
N = Windungen Anzahl, 1000
B = Flussdichte Magnet (T), 1
lw = Tiefe der Wicklung (m), 0.01
rw = Radius der Wicklung (m), 0.005
Mla= Last Drehmoment (Nm), 1m
J = Trägheitsmoment (kgm^2), 1m
Al = Induktivitätsbelag Wicklung (H), 1u
Rl = Wicklung-Widerstand (Ohm), 1
#End

#VarsAndConstants
Mo1.Alfa0G = Alfa0G
Mo1.N = N
Mo1.B = B
Mo1.lw = lw
Mo1.rw = rw
Mo1.Mla = Mla
Mo1.J = J
Mo1.Al = Al
Mo1.Rl = Rl
#End

#DefineDynCharts ; ab Version 1.26
#End

Diese Circuit-Parameter werden beim Generieren des Modul-Scripts automatisch in Dieses übertragen, sie werden
also zu Modul-Parametern.

Wir öffnen nun über Menü:Project/Save ModulScript den SaveModulScript-Dialog:

Wir wählen als MBitmap dynamo1.mbmp aus und setzen noch den InnerText DC Motor ein. Dann speichern wir
das Script unter dem Verzeichnis ElectroMechanics als DC_Motor1.mscr ab.
Dann öffnen wir diese Datei mit einem Text-Editor und vervollständigen Diese noch mit einigen Eintragungen:

#Token = Mo
#AutoComment = 

#Description
Gleichstrom-Motor mit 1 Wicklung
#End

#PinDescriptions
Pin1 = In+
Pin2 = In-
#End

#DefineStaticInfoText
#End

#DefineDynCharts
Uin = Input Voltage, V, u1-u2
Iin = Input(+) Current, A, SW3.Is + SW2.Is
UL = Coil Voltage, V, Mo1.UL
IL = Coil Current, A, Mo1.IL
n = Rot Speed, 1/s, Mo1.n
alfa = Winkel, °, Mo1.alfa
Pel = Power (elektr), W, Mo1.Pel
Pme = Power (mech), W, Mo1.Pme
#End

Hier der vollständige Script von DC_Motor1.mscr, der sich dann im Verzeichnis Data/ElectroMechanics befindet.

Ab Version 1.26 können im Block #DefineDynCharts eines Moduls neben Pin-Potentialen (u1, u2..) auch sogenannte TokenRefDynChart-Symbole (z.Bsp. Mo1.Pel, SW3.Is) als auch TokenRefParameter-Symbole (z.Bsp. Mo1.B) in den
Formeln verwendet werden. Über die TokenReferenz (links vom Punkt) wird ein Element im Modul angesprochen, über
das DynChart-Symbol (rechts vom Punkt) der entsprechende DynChart-Wert des angesprochenen Elements. Das DynChart-Symbol eines Elements steht ja immer in #DefineDynCharts ganz vorne vor dem Gleichheitszeichen. Das
gilt natürlich analog auch für die TokenRefParameter-Symbole.
Auf diese Weise lassen sich Dyn-Charts von Unterelementen eines Moduls auch für DynCharts des Moduls selber
verwenden. Hier z.Bsp. werden die Ströme von SW3 und SW2 (DynCharts Is) zusammen addiert um den Gesamt-
Eingangsstrom für das Modul (DynChart Iin) zu ermitteln.
Den #DefineDynCharts-Block hätten wir (ab Version 1.26) schon wie die Parameter auf der Circuit-Ebene definieren
können (siehe Edit Circuit Script), und auch auf dieser Ebene testen können.


Simulation des DC-Motors in einer Transistorschaltung:

Bitte die Schaltung DocSamples/Test_DCMotor1_Transistor.circ öffnen:

Nach Durchführung der Dyna öffnen wieder folgende DynCharts:

Sig1 schaltet erst nach 2s auf 1V. Bis dahin wird die Drehzahl negativ (läuft mit dem Lastmoment). Bei 2s schaltet der
Transistor durch und die Drehzahl bewegt sich ins positive (gegen das Lastdrehmoment)  bis etwa 10 U/s. Das Last-
drehmoment liegt ja immer an, es sei denn man definiert Mo1.Mla mit Zeitfunktion als Circuit-Variable.
Der Motor-Strom bewegt sich sägezahnförmig von -180mA bis 180mA, das führt zu hoher Strombelastung der Spannungs-
quelle und des Transistors.

Man sieht, dass die elektrische Momentan-Leistung wegen der induktiven Effekte sägezahnförmig verläuft. Bei positiven
Wert fließt elektr. Energie in den Motor hinein, bei negativen Wert aus Diesem heraus. Am Ende muß Der Effektivwert
natürlich dem der mechanischen Leistung entsprechen.


Wie könnte ein Modell für einen 3-Phasen-Drehstrom-Motor aussehen:

Ein solcher Motor besteht aus 3 Wicklungen, die jeweils um 60° zueinander versetzt sind. Wir brauchen also für jede
Wicklung eine Pinspannung (Um1,Um2,Um3) und einen Pinstrom (i1,i2,i3). Für den Minus-Anschluß der Wicklungen benutzen
wir gemeinsam die interne Masse. Für die Pinspannungen gilt dann:

 Um1 = U1 - U0,   Um2 = U2 - U0,   Um3 = U3 - U0

Die Lorentzmomente der 3 Wicklungen addieren sich einfach:

Für die 3 Lorentzmomente kann nun folgendes geschrieben werden:

Für die Bilanz der Drehmomente ergibt sich:

und ausgeschrieben entsteht die Differential-Gleichung für den Winkel:

Nach Diskretisierung und Umstellung nach Alfa[k] ergibt sich:

Für die 3 Induktionsspannungen können wir schreiben:

Auch die Pinspannungen können nun aufgeschrieben werden:

und die Hauptgleichungen lauten dann schließlich:

Ich habe dieses Modell noch nicht gescriptet, aber wer möchte kann das ja mal übernehmen. Es ist, wie man sieht,
analog zum oben entwickelten Ein-Wicklungs-Wechselstrom-Motor, nur bei #LaplaceVolts müssen ein paar Formeln
geändert bzw. hinzugefügt werden. Außerdem muß ein MBitmap mit den 3 Anschlüssen erstellt werden, und bitte Änderungen
im DynChart-Block nicht vergessen.

Zurück zur Hauptseite