MATLAB Und Simulink in Der Ingenieurpraxis

Wolf Dieter Pietruszka
MATLAB® und Simulink® in der Ingenieurpraxis

Aus dem Programm Grundlagen Maschinenbau
Handbuch Maschinenbau
herausgegeben von A. Böge
Elektrotechnik für Maschinenbauer

von R. Fischer und H. Linse
BWL für Ingenieure und Ingenieurinnen

von A. Daum, W. Greife u. R. Przywara
Einführung in die DIN-Normen

von M. Klein
herausgegeben von DIN Deutsches Institut für Normung e.V.
Handbuch Qualität
von W. Geiger und W. Kotte
Technische Berichte
von H. Hering und L. Hering
Englisch für Maschinenbauer

von A. Jayendran
Messtechnik
von R. Parthier
www.viewegteubner.de
Wolf Dieter Pietruszka
® ®
MATLAB und Simulink
in der Ingenieurpraxis
Modellbildung, Berechnung und Simulation
3., bearbeitete und erweiterte Auflage
Mit 219 Abbildungen und zahlreichen Beispielen
STUDIUM
Bibliografische Information der Deutschen Nationalbibliothek
Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der
Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über
<http://dnb.d-nb.de> abrufbar.
Dr.-Ing. Wolf Dieter Pietruszka, geb. 1938; Ingenieurstudium an der FH Kiel; Industrietätigkeit: Hamburg
Flugzeugbau, Entwicklung; Diplomstudium Maschinenbau; Promotion zu Nichtlinearen Drehschwingungen
1977 TU Brauschweig; ab 1975 Akad. Rat/ORat Universität Duisburg-Essen/Mechanik; Fachgebiete und
Forschungsschwerpunkte: Nichtlineare Schwingungen, Rotordynamik, Schwingungslehre, Schwingungs-
analyse mit MATLAB®, Simulation Dynamischer Systeme mit MATLAB®.
1. Auflage 2005
2. Auflage 2006
3., bearbeitete und erweiterte Auflage 2012
Alle Rechte vorbehalten

© Vieweg+Teubner Verlag |Springer Fachmedien Wiesbaden GmbH 2012
Lektorat: Thomas Zipsner | Ellen Klabunde
Vieweg+Teubner Verlag ist eine Marke von Springer Fachmedien.
Springer Fachmedien ist Teil der Fachverlagsgruppe Springer Science+Business Media.
www.viewegteubner.de
Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Jede
Verwertung außerhalb der engen Grenzen des Urheberrechtsgesetzes ist ohne
Zustimmung des Verlags unzulässig und strafbar. Das gilt insbesondere für
Vervielfältigungen, Übersetzungen, Mikroverfilmungen und die Einspeicherung
und Verarbeitung in elektronischen Systemen.
Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk
berechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im
Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher
von jedermann benutzt werden dürften.
Umschlaggestaltung: KünkelLopka Medienentwicklung, Heidelberg

Gedruckt auf säurefreiem und chlorfrei gebleichtem Papier
Printed in Germany
ISBN 978-3-8348-1764-8
Vorwort
Das Programmsystem MATLAB 1 , Simulink und Tools ist ein Werkzeug zur numerischen
Bearbeitung von einfachen bis hin zu komplexen technischen Systemen. Es ist zur schnellen
Analyse und Synthese dynamischer Vorgänge insbesondere in der Forschung und Entwicklung
geeignet und wird heute zunehmend in der Industrie eingesetzt. Sein Platz in der Ausbildung
an Universitäten, Hochschulen und Fachhochschulen ist seit langem unumstritten und gewinnt
weiter an Bedeutung. Mit MATLAB gelingt es, die Studierenden fächerübergreifend mit nur einer
Plattform während des gesamten Studiums an die rechnergestützte Bearbeitung von Problemen
u. a. der Mathematik, der Physik und speziell der Regelungstechnik, der Mechanik, der Mechatro-
nik und der Elektrotechnik heranzuführen. In Lehrveranstaltungen können praxisrelevante Bei-
spiele anschaulich bearbeitetet und dargestellt werden. The MathWorks, Inc., der Herausgeber
von MATLAB Softwareprodukten, unterstützt diese Aktivitäten zunehmend.
In diesem Buch soll ein problemorientierter Weg beschritten werden. Dazu musste zunächst
ein Kompromiss zwischen Grundlagen und Anwendungen gefunden werden. Die Grundlagen
beziehen sich auf die mathematische Modellbildung sowie auf die numerischen Methoden. Die
Anwendungen beziehen sich auf die Umsetzung in einen MATLAB Code bzw. Signalflussgra-
fen, auf phänomenologische Fragestellungen und die Visualisierung. Es sollten zunächst ein-
mal fundamentale Begriffe, Zusammenhänge und Methoden verstanden worden sein. Verstehen
bedeutet für den Ingenieur nicht nur gedankliches Nachvollziehen einer mathematischen oder
numerischen Methode, sondern vor allem die Fähigkeit, die entsprechenden Überlegungen auf
praktische Fragestellungen anzuwenden. Dem folgend ist das Ziel dieses Buches, den Entwurf
von technischen Systemen durch den Einsatz von Berechnung, Simulation und Visualisierung zu
unterstützen. Zwar unterliegen die Grundlagen in den einzelnen Disziplinen unterschiedlichen
Beschreibungsformen, die Modellierung, die Simulation, die eingesetzten Methoden und die pro-
grammtechnische Umsetzung sind jedoch dieselben.
Großer Wert wird auf die unmittelbare Umsetzung in ein entsprechendes MATLAB- bzw.
Simulink-Modell gelegt. Deshalb ziehen sich textbegleitende Beispiele mit zugehörigen Program-
men und Signalflussgrafen durch das gesamte Buch. Die vollständigen und ergänzenden gut do-
kumentierten Programme sowie eine zugehörige Auflistung mit kurzen Erläuterungen stehen auf
der Homepage zum Buch, erreichbar über die des Verlages www.viewegteubner.de, zur
Verfügung.
Die 3. Auflage enthält Ergänzungen u. a. zur Animation, zur Simulink-Modellierung sowie
einen neuen Abschnitt zur Lösung von Randwertproblemen unter MATLAB und das Projekt Ba-
lancierender Roboter.
Der Inhalt des vorliegenden Buches ist nach einzelnen Schwerpunkten in acht Kapiteln so
abgefasst, dass auch ein direkter Einstieg in die einzelnen Kapitel möglich ist. Vorausgesetzt
werden Kenntnisse in der Matrizenrechnung.
Eine Einführung in die Arbeitsweise und den Sprachumfang von MATLAB und der Compu-
teralgebra mit der Symbolic Math Toolbox vermittelt das erste Kapitel. Darüber hinaus wird auf
1 MATLAB , Simulink sind eingetragene Warenzeichen von "The MathWorks, Inc."
VI
die grafischen 2D- und 3D-Darstellungsmöglichkeiten sowie auf Ansätze zur Erstellung von Ani-
mationsmodellen und deren Visualisierung eingegangen. Dieses Kapitel ist für den Einstieg in
MATLAB unumgänglich.
Im zweiten Kapitel zeigen wir die rechnergestützte mathematische Modellbildung anhand
nichtlinearer mechanischer Modelle und deren Linearisierung. Die Grundlagen werden so aufbe-
reitet, dass eine symbolische Auswertung mit der Computeralgebra erfolgen kann. Anhand eines
Beispiels werden alle vorgestellten Methoden algorithmisch aufbereitet und programmiert.
Das dritte Kapitel befasst sich mit linearen, mechanischen Schwingungsmodellen. Ausgehend
von einer üblichen Klassifizierung der mathematischen Modelle werden diese so formuliert und
aufbereitet, dass damit unmittelbar ein vektorisierter Code erzeugt werden kann. Er ist universell
einsetzbar. Eigenschwingungen sowie freie und erzwungene Schwingungen werden berechnet
und grafisch ausgewertet.
Kapitel vier behandelt die weitverbreitete blockorientierte Simulation unter Simulink . Voran-
gestellt werden Grundlagen zu den Integrationsverfahren, deren Klassifizierung und Eigenschaf-
ten. Die Einführung erfolgt schrittweise mit der Bearbeitung eines kleinen Projektes.
Neben der blockorientierten Simulation spielt die skriptorientierte Modellierung mit dem Ba-
sismodul MATLAB des Kapitels fünf eine wesentliche Rolle. Die Anwendung erfolgt an kleinen
Beispielen. Diese beinhalten neben den Standardformulierungen als explizite bzw. implizite Dif-
ferenzialgleichungen die Beschreibung als differenzial-algebraische Gleichungen, die Formulie-
rung von Systemen mit Ereignissen wie Stoß und Reibung sowie die Bearbeitung von Randwert-
problemen und deren Stabilität.
Die Kapitel sechs und sieben behandeln zwei nützliche Tools für die Simulink-Umgebung.
Zunächst wird das Stateflow Tool vorgestellt und auf eventgesteuerte Systeme angewendet. Als
Vertreter für eine physikalische Modellierung wird das blockorientierte SimMechanics Tool ein-
gesetzt.
Das achte Kapitel enthält acht für sich abgeschlossene Projekte, die die bisherigen Grundlagen
vertiefen und ergänzen. Unterschiedliche Lösungswege werden gegenübergestellt. Anregungen
für eigene Projekte sollen vermittelt werden.
Das Buch ist nicht ausschließlich einer Lehrveranstaltung zuzuordnen, es ist vielmehr studien-
begleitend bezüglich der Grundlagen, der Anwendungen und der numerischen Ausführungen
einzusetzen. Es ist gleichermaßen für Studierende an Universitäten, Hoch- und Fachhochschulen
sowie für Ingenieure der Praxis gedacht. Aus diesem Grund sind neben einführenden Beispielen
komplexere Probleme mit praxisrelevanten Komponenten enthalten. Zur Vertiefung der Program-
mierung existieren Übungsvorschläge, die eigenständig bzw. mit angegebenen Hilfen bearbeitet
werden können.
Neben dem Basismodul MATLAB werden die Tools Simulink , Symbolic Math, Stateflow ,
SimMechanics und eingeschränkt die Control System Toolbox vorausgesetzt. Eine Studentenver-
sion, siehe: www.mathworks.de/academia/student_version/, ist erhältlich.
Mein Dank gilt dem Vieweg+Teubner Verlag für die Herausgabe sowie Herrn Thomas Zipsner
und Frau Ellen Klabunde für die Unterstützung und gute Zusammenarbeit bei der Erstellung der
Druckvorlage.
Für die großzügige Bereitstellung der Software bedanke ich mich bei der Firma The
MathWorks, Inc., 3 Apple Hill Drive, Natick, MA 01760-2098 USA.
Moers, im September 2011 Wolf Dieter Pietruszka

wd@pietruszka.de
Inhaltsverzeichnis
1 Einführung in MATLAB 1
1.1 Desktop und Fenster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Online-Hilfe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Einige Bemerkungen zur Arbeitsweise von MATLAB . . . . . . . . . . . . . . . . 5
1.4 Basis-Elemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4.1 Skalare Operationen und Variablenverwaltung . . . . . . . . . . . . . . . . . . 6
1.4.2 Mathematische Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4.3 Vektoren und Matrizen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4.4 Lineare Gleichungssysteme . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.4.5 Spezielle Datenstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.4.6 Vergleichsoperatoren und logische Operatoren . . . . . . . . . . . . . . . . . 26
1.4.7 Verzweigungen und Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.5 Programmerstellung, MATLAB Script und Function . . . . . . . . . . . . . . . . 30
1.5.1 MATLAB Editor und Verzeichnispriorität . . . . . . . . . . . . . . . . . . . . 30
1.5.2 Datenein- und Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.5.3 MATLAB Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
1.5.4 MATLAB Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1.5.5 Code-Beschleunigung, der Profiler . . . . . . . . . . . . . . . . . . . . . . . . 42
1.6 Grafik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
1.6.1 Grafikfenster (Figure), Erstellung und Verwaltung . . . . . . . . . . . . . . . 45
1.6.2 2D-Grafik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
1.6.3 3D-Grafik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
1.7 Animation von 2D- und 3D-Modellen . . . . . . . . . . . . . . . . . . . . . . . . 66
1.7.1 Modellerstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
1.7.2 Animations-Grafik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
1.7.3 2D-Animation einfacher Linien-Modelle . . . . . . . . . . . . . . . . . . . . 69
1.7.4 Animation mit geometrischen 3D-Modellen . . . . . . . . . . . . . . . . . . . 73
1.8 Computeralgebra unter MATLAB, die Symbolic Math Toolbox . . . . . . . . . . . 81
1.8.1 Online-Hilfe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
1.8.2 Symbolische Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
1.8.3 Vereinbarung symbolischer Variablen und Ausdrücke (Objekte) . . . . . . . . 83
1.8.4 Substitution symbolischer und numerischer Größen, der subs Befehl . . . . . . 85
1.8.5 Beispiele aus der Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
1.8.6 Algebraische Gleichungssysteme, der solve Befehl . . . . . . . . . . . . . . . 87
1.8.7 Gewöhnliche Differenzialgleichungen, der dsolve Befehl . . . . . . . . . . . . 88
1.8.8 Beispiel aus der linearen Algebra . . . . . . . . . . . . . . . . . . . . . . . . 91
1.8.9 Übergang zur Numerik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
VIII Inhaltsverzeichnis
2 Modellbildung 95
2.1 Bemerkungen zur Schreibweise . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
2.2 Strukturen der Bewegungsgleichungen . . . . . . . . . . . . . . . . . . . . . . . . 97
2.3 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
2.3.1 Kinematik starrer Körper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
2.3.2 Kinetik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
2.4 Newton-Euler-Methode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
2.4.1 Rechnerorientierte Vorgehensweise . . . . . . . . . . . . . . . . . . . . . . . 116
2.5 Lagrange’sche Gleichung 2. Art . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
2.6 Linearisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
2.7 Anwendung der Modellerstellung . . . . . . . . . . . . . . . . . . . . . . . . . . 125
3 Lineare Schwingungsmodelle 131

3.1 Bewegungsgleichungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
3.2 Eigenschwingungen und freie Schwingungen . . . . . . . . . . . . . . . . . . . . 134
3.2.1 Das Eigenwertproblem in MATLAB, allgemeine Betrachtung . . . . . . . . . 134
3.2.2 Numerische Behandlung der Eigenwertprobleme . . . . . . . . . . . . . . . . 136
3.3 Erzwungene Schwingungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
3.3.1 Konstante Erregung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
3.3.2 Harmonisch angeregte mechanische Systeme . . . . . . . . . . . . . . . . . . 150
4 Simulation unter Simulink 161

4.1 Zur Funktionsweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
4.1.1 Block-Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
4.1.2 Simulationsablauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
4.2 Die Integrationsverfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
4.2.1 Methoden und Bezeichnungen . . . . . . . . . . . . . . . . . . . . . . . . . . 164
4.2.2 Steifigkeit der Differenzialgleichung . . . . . . . . . . . . . . . . . . . . . . . 169
4.2.3 Bemerkungen zur Wahl der Verfahren . . . . . . . . . . . . . . . . . . . . . . 170
4.3 Simulink-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
4.3.1 Die Modell-Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
4.3.2 Einstellung des Integrators und des Datentransfers . . . . . . . . . . . . . . . 173
4.3.3 Datentransfer über den Workspace . . . . . . . . . . . . . . . . . . . . . . . . 174
4.3.4 Simulationsaufruf aus der MATLAB Umgebung . . . . . . . . . . . . . . . . 174
4.3.5 Hilfsmittel zur Modellerstellung und Datenauswertung . . . . . . . . . . . . . 175
4.4 Simulink-Modellierung eines einfachen Projekts . . . . . . . . . . . . . . . . . . . 186
4.4.1 1/4-Fahrzeugmodell und die Bewegungsgleichungen . . . . . . . . . . . . . . 186
4.4.2 Aufbereitung der Bewegungsgleichungen . . . . . . . . . . . . . . . . . . . . 188
4.4.3 Das Fahrbahnprofil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
4.4.4 Parametrisierung des Zustandsmodells im State Space Block . . . . . . . . . . 194
4.4.5 Modellierung der Reibelemente . . . . . . . . . . . . . . . . . . . . . . . . . 195
4.4.6 Die Startroutine für die MATLAB-Umgebung . . . . . . . . . . . . . . . . . . 198
4.4.7 Simulink-Modelle und Simulationsergebnisse . . . . . . . . . . . . . . . . . . 199
4.5 Algebraische Schleifen in dynamischen Modellen . . . . . . . . . . . . . . . . . . 205
4.5.1 Algebraische Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
Inhaltsverzeichnis IX
4.5.2 System mit algebraischer Schleife . . . . . . . . . . . . . . . . . . . . . . . . 205

4.6 Vektorielle Betrachtungsweise und Modellierung . . . . . . . . . . . . . . . . . . 209
4.6.1 Simulationsergebnisse, selbsterregte Schwingungen und Mitnahme-Effekte . . 210
4.6.2 Nichtlineare Gleichungen höherer Ordnung . . . . . . . . . . . . . . . . . . . 211
4.7 Modellierung mit Hilfe einer S-Function . . . . . . . . . . . . . . . . . . . . . . . 214
4.7.1 M-File S-Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
4.7.2 C Mex-File S-Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
5 Simulation unter MATLAB 225

5.1 Struktur der Differenzialgleichungen . . . . . . . . . . . . . . . . . . . . . . . . . 225
5.1.1 Beispiele für eine explizite Formulierung . . . . . . . . . . . . . . . . . . . . 228
5.2 Der grundsätzliche Aufbau eines Simulationsprogramms . . . . . . . . . . . . . . 237
5.2.1 Möglichkeiten zum Integratoraufruf unter MATLAB . . . . . . . . . . . . . . . 237
5.3 Integration von Systemen in Standardform . . . . . . . . . . . . . . . . . . . . . . 241
5.3.1 Unwuchtiger Motor auf elastischem Fundamentblock . . . . . . . . . . . . . . 242
5.4 Differenzial-algebraische Gleichungen . . . . . . . . . . . . . . . . . . . . . . . . 249
5.4.1 Mathematische Hintergründe . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
5.4.2 Möglichkeiten unter MATLAB und Simulink . . . . . . . . . . . . . . . . . . 251
5.4.3 Mechanische Bewegungsgleichungen mit algebraischen Bindungsgleichungen 252
5.4.4 Überführung in gewöhnliche Differenzialgleichungen . . . . . . . . . . . . . . 260
5.4.5 Übergang auf Minimalkoordinaten . . . . . . . . . . . . . . . . . . . . . . . . 266
5.5 Implizite Differenzialgleichungen . . . . . . . . . . . . . . . . . . . . . . . . . . 272
5.6 Integration gewöhnlicher Differenzialgleichungen mit Unstetigkeiten . . . . . . . . 275
5.6.1 Beispiele für Unstetigkeiten in den Bewegungsgleichungen . . . . . . . . . . . 275
5.6.2 Formulierung von Schaltfunktionen . . . . . . . . . . . . . . . . . . . . . . . 277
5.6.3 Lokalisierung der Schaltpunkte . . . . . . . . . . . . . . . . . . . . . . . . . 278
5.6.4 Beispiele zur Zwei-Punkt-Schaltlogik . . . . . . . . . . . . . . . . . . . . . . 279
5.6.5 Dreipunkt-Schaltlogik am Beispiel eines Zwei-Massen-Schwingers mit Reibung289
5.7 Randwertprobleme gewöhnlicher Differenzialgleichungen . . . . . . . . . . . . . 303
5.7.1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
5.7.2 Standardproblem am Beispiel der Kettenlinie . . . . . . . . . . . . . . . . . . 304
5.7.3 Mehrpunkt-Randwertprobleme . . . . . . . . . . . . . . . . . . . . . . . . . . 308
5.7.4 Periodische Schwingungen nichtlinearer Systeme . . . . . . . . . . . . . . . . 310
6 Modellierung und Simulation mit dem Stateflow Tool 317

6.1 Stateflow-Elemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
6.1.1 Das Chart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
6.1.2 Zustand und Zustand-Label . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
6.1.3 Transitionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
6.1.4 Default Transition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
6.1.5 Verbindungspunkte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
6.1.6 Der Modell-Explorer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
6.1.7 Erweiterte Strukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
6.2 Beispiel: Schwinger mit Coulomb-Reibung . . . . . . . . . . . . . . . . . . . . . 324
6.2.1 Bewegungsgleichungen und Schaltbedingungen . . . . . . . . . . . . . . . . . 324
X Inhaltsverzeichnis
6.2.2 Simulink-Modell mit Chart . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325

6.3 Beispiel: Springender Ball . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
7 Physikalische Modelle unter Simulink 335

7.1 SimMechanics Tool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
7.1.1 Funktionsweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
7.1.2 Untersuchungsmethoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
7.1.3 Erstes SimMechanics-Modell . . . . . . . . . . . . . . . . . . . . . . . . . . 337
7.1.4 Arbeitsweise des Joint Stiction Actuators . . . . . . . . . . . . . . . . . . . . 344
7.1.5 Visualisierung und Animation der Maschine . . . . . . . . . . . . . . . . . . . 349
7.1.6 Einige mathematische Aspekte . . . . . . . . . . . . . . . . . . . . . . . . . . 350
7.2 Anwendungen und Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
8 Projekte 355
8.1 Permanentmagnet gelagerter Rotor . . . . . . . . . . . . . . . . . . . . . . . . . . 355
8.1.1 Systembeschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
8.1.2 Rotor- und Magnetmodellierung . . . . . . . . . . . . . . . . . . . . . . . . . 357
8.1.3 Die aktive Stabilisierung, Reglerstrukturen . . . . . . . . . . . . . . . . . . . 358
8.1.4 Das kontinuierliche Modell . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
8.1.5 Reglerentwürfe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
8.1.6 Parametrierung und Reglerkoeffizienten . . . . . . . . . . . . . . . . . . . . . 363
8.1.7 Simulink-Modelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
8.1.8 Simulationsergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
8.2 Störgrößenkompensation harmonischer und konstanter Störungen . . . . . . . . . 364
8.2.1 Grundlagen zur Strecke und zum Beobachterentwurf . . . . . . . . . . . . . . 367
8.2.2 Parameterfile und Simulink-Modell . . . . . . . . . . . . . . . . . . . . . . . 369
8.2.3 Beobachter über S-Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
8.2.4 Analytische Ermittlung der Lösungen . . . . . . . . . . . . . . . . . . . . . . 370
8.2.5 Ergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
8.3 Schwingungstilger mit viskoelastischem Anschlag . . . . . . . . . . . . . . . . . 376
8.3.1 Das stationäre System ohne Anschlag . . . . . . . . . . . . . . . . . . . . . . 377
8.3.2 Entwurf des Simulink-Modells . . . . . . . . . . . . . . . . . . . . . . . . . . 379
8.3.3 Schwingungsantwort mit einem Sinus-Sweep des Systems ohne/mit Anschlag . 384
8.4 Axialkolbenverdichter einer Pkw-Klimaanlage . . . . . . . . . . . . . . . . . . . . 386
8.4.1 Das Modell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386
8.4.2 Der Hebelmechanismus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
8.4.3 Bewegungsgleichungen nach Lagrange . . . . . . . . . . . . . . . . . . . . . 388
8.4.4 Das M-File, erste Ergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
8.4.5 Modellbasierter Entwurf mit SimMechanics . . . . . . . . . . . . . . . . . . . 391
8.4.6 Vergleich der Ergebnisse bezüglich der Gelenkkräfte . . . . . . . . . . . . . . 393
8.4.7 Stationäre Lage, die Trimming-Methode . . . . . . . . . . . . . . . . . . . . . 394
8.4.8 Der Verdichter als SimMechanics-Modell . . . . . . . . . . . . . . . . . . . . 395
8.5 Dreifachpendel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
8.5.1 Lagrange’sche Gleichung 2. Art . . . . . . . . . . . . . . . . . . . . . . . . . 398
8.5.2 Newton-Euler-Formalismus . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
Inhaltsverzeichnis XI
8.5.3 Übergang zur Numerik und Integration . . . . . . . . . . . . . . . . . . . . . 402

8.5.4 Animationsmodell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
8.5.5 Schwingungsverhalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
8.5.6 Vorwärtsdynamik mit SimMechanics . . . . . . . . . . . . . . . . . . . . . . 407
8.5.7 Inverse Dynamik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
8.6 Hubschwingungen eines Viertelfahrzeugs mit nichtlinearem Stoßdämpfer . . . . . 411
8.7 Dynamik des Levitron-Kreisels . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
8.8 Balancierender Roboter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
8.8.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
8.8.2 Modellvoraussetzungen und Annahmen . . . . . . . . . . . . . . . . . . . . . 415
8.8.3 Herleitung der Bewegungsgleichungen . . . . . . . . . . . . . . . . . . . . . 416
Literaturverzeichnis 417
Stichwortverzeichnis 421

1 Einführung in MATLAB
Ursprünglich war MATLAB 1 ein Benutzerinterface für Standardroutinen der numerischen Alge-
bra (Eispack, Linpack, Lapack) basierend auf Vektor- und Matrizenoperationen, worauf bereits
der Name MATrix LABoratory hinweist.
Kommerziell wurde das erste Programmpaket 1984 ausgeliefert. Heute ist die MATLAB Pro-
duktfamilie in erster Linie ein Softwarepaket zur numerischen Berechnung und Visualisierung
u. a. in den Mathematik- und Ingenieurwissenschaften. Es verfügt über eine eigene Hochsprache
mit interaktiver Umgebung. Der Kern besteht aus einer Vielzahl von Built-In Functions u. a. der
linearen Algebra, der Datenanalysis sowie der Lösung von Differenzialgleichungen.
Die Built-In Functions sind für Vektoroperationen bezüglich der Rechenzeit optimiert. Benut-
zereigene Functions (Unterprogramme) können das Programmpaket erweitern. Diese Functions
sollten – wenn möglich – ebenfalls in vektorisierter Form abgefasst werden; dies dient auch einer
guten Übersichtlichkeit.
Eine weitere Säule der MATLAB-Umgebung ist die grafische Entwicklungsumgebung Simu-
link 2 u. a. mit den Tools Stateflow , SimScape, SimMechanics, SimPowerSystems, SimDrive-
line, SimHydraulics , Real-Time Workshop usw. Viele optionale Toolboxen, z. B. Control Sys-
TM
tem, Signal Processing, Symbolic Mathematics ergänzen die Entwicklungsplattform.

Alternativen3 stellen u. a. die kommerziell vertriebenen Programmpakete MATRIXx und O-
Matrix sowie die frei erhältlichen Programmpakete Octave, ein MATLAB-Clone, und Scilab mit
einer benutzerfreundlichen Umgebung und einer zu MATLAB ähnlichen Syntax dar.
MATLAB 7.12, Release 2011a – kurz: (R2011a) – ist die z. Z. aktuelle Version. Die im Folgen-
den abgedruckten Fenster-Layouts (Screenshots), im Zusammenhang mit dem Betriebssystem
Windows 7, basieren auf dieser Versionen.
Wir wollen in diesem Kapitel grundlegende MATLAB-Elemente und -Befehle zusammenstel-
len und sie anhand kleiner Beispiele erläutern. Befehle enthalten Variable, die wir in allgemei-
nen Erläuterungen kursiv schreiben, optionale Parameter werden in -Klammern gefasst und
MATLAB-Funktionen und -Variable weitgehend durch Fettdruck hervorgehoben. Standardwerte
(Default) werden, wie in den MATLAB-Dokumentationen, in geschweifte Klammern { } gesetzt.
Darüber hinaus unterscheiden wir in den abgedruckten Programmsegmenten zwei Darstellungen:
1. Programmsegmente mit fett hervorgehobenen MATLAB-Befehlen,

2. Programmsegmente und Befehlsfolgen als Kopie des Command Windows bzw. des Editors.
Die erste Form wird immer im Zusammenhang mit unmittelbar zuvor vorgestellten Befehlen,
die zweite Form insbesondere bei parallel verfügbaren Programm-Codes – um Schreibfehler
auszuschließen – benutzt. Sie heben sich durch die Schrift-Art und -Größe vom Fließtext ab.
1 MATLAB ist ein eingetragenes Warenzeichen der Firma "The MathWorks, Inc."
www.mathworks.com, bzw. www.mathworks.de
2 Simulink , Stateflow , Real-Time Workshop , SimHydraulicsTM sind eingetragene Warenzeichen der Firma "The
MathWorks, Inc."
3 O-Matrix: www.omatrix.com, Octave: http://www.octave.org/, Scilab: http://www.scilab.org/
W. D. Pietruszka, MATLAB® und Simulink® in der Ingenieurpraxis,

DOI 10.1007/978-3-8348-8630-9_1,
2 1 Einführung in MATLAB
Darüber hinaus werden Möglichkeiten zur grafischen Ausgabe von Daten sowie deren Ani-
mation aufgezeigt. Im letzten Abschnitt dieses Kapitels wird dann auf die Computeralgebra mit
der Symbolic Math Toolbox eingegangen. Die Einführung ist weitgehend auf die Belange dieses
Buches mit den zugehörigen Projekten / Übungen u. a. in Kapitel 8 zugeschnitten und somit nicht
vollständig.
Ergänzende Grundlagen findet man u. a. in [2], [24], [41], [53] [57]. Insbesondere wird in der
Einführung von [53] auf ein weites Spektrum der Möglichkeiten unter MATLAB systematisch
eingegangen und mit vielen Beispielen anschaulich dargestellt. Neben den Grafik-Grundlagen
sind viele Ideen unterschiedlichster Darstellungsmöglichkeiten zusammengetragen. In [41] sind
neben einer mehr mathematisch orientierten Einführung in MATLAB viele Built-In Function, z. B.
zur Eigenwertberechnung, Lösung linearer Gleichungssysteme, gewöhnliche und partielle Diffe-
renzialgleichungen, F OURIER-Analysis usw., mit wichtigen mathematischen Hintergründen zu
finden. Beispiele, Übungen und Programmcodes dienen der Erläuterung und geben wertvolle
Tipps auch zu Grafikelementen für den fortgeschrittenen MATLAB-Anwender. [41] ist insbeson-
dere dem mathematisch Interessierten sehr zu empfehlen. Aus der Sicht eines Mathematikers ist
in [24] eine umfassende Einführung bezüglich MATLAB und Simulink zu finden. In [57] existie-
ren Dokumentationen von ca. 1.000 MATLAB-Befehlen. Die Funktionen der einzelnen Befehle
werden verständlich erläutert und anhand zahlreicher Beispiele und Abbildungen verdeutlicht.
1.1 Desktop und Fenster

Der Desktop, der nach dem Start von MATLAB geöffnet wird, ist das Kernelement der MATLAB-
Umgebung. Weitere Fenster, die sich auch separat öffnen lassen, können eingebunden werden,
vgl. Bild 1.1. Der Help-Button in der Menüleiste öffnet ein Shortcut-Menü u. a. mit Hilfe-Pfaden
zum Desktop Using the Desktop sowie dem jeweiligen aktiven Fenster, mit dem sich ebenfalls
der Menü-Leistenaufbau und -Inhalt anpasst.
Unter Desktop/Desktop Layout sind einige Konfigurationen auswählbar, z. B. wird
mit All Tabbed die Menüleiste
eingefügt, womit ein schneller Fensterwechsel ermöglicht wird. Die Registerkarten können an al-
len Rändern positioniert werden. Speichern kann man das erstellte Layout unter Desktop/Save
Layout... . In Bild 1.1 ist eine eigene Konfiguration aus Command, Current Directory,
Workspace und Command History Window dargestellt, wobei die letzten drei zunächst
eigenständigen Fenster durch Andocken in die Desktop-Umgebung eingebunden wurden. Die
interaktive Arbeitsweise erfolgt, wie in Bild 1.1 angedeutet, im Command Window, vgl. Help
Button/Using the Command Window bei aktiven Command Window. Hinter dem Prompt oder
unter Help kann der Function Browser angewählt werden. Nach Kategorien unterteilt sind die
Functions des installierten Programmsystems mit kurzen Erklärungen und einer Suchleiste für
bekannte Functions auswählbar.
Für die Programmerstellung steht ein Text-Editor, siehe Abschn. 1.5.1, zur Verfügung. Durch
An- und Ausdocken (Dock, Undock) weiterer Fenster, z. B. des Editor- und Grafik-Fensters, mit
Hilfe der Button: , im jeweiligen Fenster-Kopf, kann mit dem Desktop ab MATLAB 7 eine
kompakte Arbeits-Umgebung mit eigens gestalteter Anordnung geschaffen werden. Die Fenster
lassen sich durch Ziehen der Kopfleiste mit der Maus beliebig anordnen.
1.1 Desktop und Fenster 3
Bild 1.1: MATLAB Desktop, MATLAB 7.12
Das Fenster Workspace (Info: doc workspace / Link workspace browser) zeigt den
Workspace Browser mit dem Namen (Name), dem Wert (Value), und dem zugehörigen Minimal-,
Maximalwert (Min, Max), der im aktuellen Workspace gespeicherten Größen. Mit einem Doppel-
Klick der linken Maustaste auf das Symbol öffnet sich der zugehörige Variable Editor, Daten
werden angezeigt und können manipuliert werden. Wählt man im Workspace Browser, wie in
Bild 1.1, den Vektor x aus, dann wird der Button angezeigt, worüber eine grafische
Auswertung in auszuwählender Darstellung erfolgt. Das Current Directory Fenster ent-
hält den Inhalt des aktuellen Pfads. Durch einen Doppel-Klick der linken Maustaste auf einen
Filenamen wird das M-File im Editor angezeigt. Schließlich werden im Command History
Fenster Eingabezeilen, wie in Bild 1.1 angedeutet, aufgezeichnet; sie sind mit einem Doppel-
Klick der linken Maustaste wieder aktivierbar, einzelne / mehrere Befehle lassen sich ausschnei-
den oder Kopieren. Darüber hinaus können Einträge dieses Fensters mit den Pfeiltasten ↑ ↓ in
die Command-Zeile kopiert und ausgeführt werden. Wird ein bestimmter Eintrag gesucht, dann
gibt man die Anfangsbuchstaben in die Command-Zeile ein und durch die Pfeiltasten werden nur
noch die Einträge mit diesen Anfangsbuchstaben übertragen.
In jedem Falle öffnet sich mit einem Mausklick der rechten Taste das zur Mauszeigerposition
gehörige Shortcut-Menü, womit weitere Ausführungen eingeleitet werden können. Einen Um-
gang mit dem Desktop, dem Command Window usw. vermitteln die Video Tutorials u. a. unter:
Button Help / Demos → MATLAB.
1.2 Online-Hilfe
Eine gut strukturierte und weitgehend selbsterklärende Online-Hilfe unterstützt das gesamte An-
gebot und sollte deshalb für den Benutzer zu einem wichtigen und sehr hilfreichen Werkzeug
werden. Einen detaillierten Überblick bezüglich aller Hilfe-Kommandos erhält man durch Einga-
be von
⇒ help helptools
Wir wollen, aufbauend auf den Schlüsselwörtern help, helpwin, doc, sie sollten stets parallel ge-
nutzt werden, einen Einstieg in die Online-Hilfe vermitteln. Beispiel-Aufruf: help (liefert einen
Überblick im Command Window) oder spezieller help toolbox spezifikation, z. B. help gene-
ral für allgemeine Befehle und help ops bzw. help/ für arithmetische Operationen +, −, ∗,
/,. . . einschließlich Querverweise. Die gleiche Information erhält man mit helpwin und in erwei-
terter Form mit doc dargestellt im Help Browser, vgl. helpwin ops, doc ops. Querverweise sind
bequem über Links zu erreichen. Darüber hinaus sind mit doc thema – z. B. doc function, doc
eig – gezielt die Referenzseiten der HTML-Dokumentation im Help Browser abrufbar. Da eig
eine (Built-In) Function ist, liefert help eig bzw. helpwin eig – im Gegensatz zum doc Auf-
ruf – den ersten Kommentar-Block in der Function. Enthält die Dokumentation, z. B. für eigene
M-Files, keine Referenzseite zum ausgewählten thema, dann wird auch mit doc der Kommentar-
block angezeigt. Dies ist auf die Kommentare eigener M-Files übertragbar, so dass sich eine eige-
ne Programm-Hilfe schaffen lässt. Weitere Hinweise finden wir mit: doc help, doc helpwin,
doc doc. Eine schnelle Hilfe bezüglich dem Namen nach bekannter Functions, z. B. eig, erhält
man nach Eingabe des Namens ins Command Window oder in den Editor mit der Funktionstaste
F1. Die Beispielprogramme u. a. der Browser oder eigener Anweisungen können nach Selektion
bei gedrückter linken Maustaste (Einfärbung) durch F9 ausgeführt werden. Wie schon erwähnt
liefert der Function Browser einen schnellen Befehls-Überblick direkt in der Arbeitsumge-
bung, d. h. im Command Window bzw. im Editor. Ist die gesuchte Function gefunden, dann kann
mit einem Doppelt-Klick oder mit der Enter-Taste die Function in die Arbeitsumgebung über-
nommen werden.
Schlüsselworte zum gleichen Themenkreis werden stets am Ende des Hilfe-Dokuments, z. B.
nach help help, ausgegeben. U. a. lookfor für die Begriffsuche in der ersten Kommentar-Zeile
bzw. Block aller M-Files im MATLAB-Path, vgl. help lookfor.
Darüber hinaus wird über das ?-Icon in der Menü-Leiste des Desktops bzw. durch Eingabe von
helpbrowser die erste / eine Seite des HTML-Documents im Help Browser geöffnet, womit
eine erweiterte Online-Hilfe zur Verfügung steht. Eine gezielte Suche u. a. über Search in der
Navigator Spalte des Browser’s erleichtert das Auffinden spezieller Informationen. Insbesondere
die in den Dokumenten integrierten Programm- und Grafik-Beispiele sind sehr hilfreich für den
eigenen Umgang mit MATLAB. Zu erwähnen sind auch die lehrreichen Demos sowie die bereits
erwähnten Video Tutorials sowie weiterführende Webinare und neuerdings die E-Learning Kurse
am Arbeitsplatz. Letztendlich stehen alle Handbücher im HTML- und PDF-Format (http://
www.mathworks.de/help/pdf_doc/ zur Verfügung.
1.3 Einige Bemerkungen zur Arbeitsweise von MATLAB 5
1.3 Einige Bemerkungen zur Arbeitsweise von MATLAB
MATLAB ist eine Sprache der vierten Generation (4GL)4 im Gegensatz zu den (Hoch-) Sprachen
u. a. wie C, C++ , Fortran, Basic der dritten Generation (3GL). Sprachen der vierten Generation
sind weniger prozedural als 3GLs und bestehen aus Ausdrücken, die der menschlichen Sprache
entlehnt sind. 4GLs lassen sich daher einfacher benutzen als 3GLs. Die Ausführungszeiten sind
aufgrund der Interpretation oft langsamer als von 3GL, da diese zur Beschleunigung der Ausfüh-
rung in Assembler- oder Maschinencode übersetzt werden.
MATLAB ist eine 4GL, die spezifisch für Ingenieure und Wissenschaftler entwickelt wurde.
Diese intuitive Sprache, die interaktive Umgebung und die eingebauten mathematischen und gra-
fischen Funktionen machen MATLAB zu einer Plattform insbesondere für technische Berechnun-
gen. Ein wesentlicher Vorteil von MATLAB ist, dass die Variablen eines bestimmten Datentyps,
wie in 3GLs, nicht zu deklarieren sind. In MATLAB kann jeder Variablen ein Wert von beliebigem
Typ zugewiesen werden; er kann auch jederzeit wieder geändert werden.
Vor MATLAB 6.5 wurde die MATLAB-Sprache in zwei Schritten ausgeführt. Zuerst wurde
der Code in einen P-Code übersetzt. Diesen Befehlssatz führt danach der MATLAB-Interpreter
aus. Einige P-Code-Anweisungen sind hochsprachliche Anweisungen, so dass ihre Ausführung
viel Zeit in Anspruch nimmt. Hierzu gehören Programmteile, die mit Skalaren und mit for-
Schleifen arbeiten. Nur bezüglich vektorisierter Ausführungen wird der zugehörige P-Code sehr
schnell ausgeführt.
Ab MATLAB 6.5 existiert ein Just-In-Time- Accelerator, mit dem Programmteile, die insbe-
sondere Schleifen und skalare Mathematik enthalten, automatisch beschleunigt werden. Der JIT-
Accelerator konvertiert die bisher langsam ausgeführten Anweisungen vom P-Code in native
Maschinenbefehle, wodurch sie sehr schnell ausgeführt werden. Der JIT-Accelerator lässt auch
einen vorher nicht vektorisierten Code schneller ablaufen, womit die bisher angestrebte Vektori-
sierung scheinbar an Bedeutung verliert. Die Vektorisierung hat aber weiterhin den Vorteil einer
prägnanten Formulierung der Algorithmen und liefert einen übersichtlichen Programm-Code,
vgl. insbesondere Kapitel 3 und Abschn. 8.2.4.
Unter MATLAB 6.5 / 6.5.1 werden nicht alle Datentypen, Array-Formen, Ausdrücke usw. von
JIT-Accelerator unterstützt. Ab MATLAB 7 sind diese Einschränkungen aufgehoben, der Pro-
grammcode wird durchgehend beschleunigt.
1.4 Basis-Elemente
Zunächst werden wir uns mit wesentlichen Elementen des MATLAB-Sprachumfangs vertraut ma-
chen. Diese ausgewählten Elemente stellen wir stets am Anfang eines jeden Abschnittes tabella-
risch zusammen, es folgen diesbezüglich kurze Erläuterungen und einfache Beispiele. Die Bei-
spiele können interaktiv, d. h. über die Tastatur hinter dem Prompt (>>) im Command Window

eingegeben, mit Return ( ) abgeschlossen und sofort ausgeführt werden. Die unten aufgeliste-
ten Befehlsfolgen und Daten sind derartige Kopien aus dem Command Window; Kommentare
folgen nach dem %-Zeichen. Darüber hinaus existiert in [52] das M-File Basis_Elemente.m,
4 Kundenmagazin von The MathWorks: MATLAB Select 2/02, Hintergrundinformationen zur Technologie, Noch
schnelleres MATLAB
mit dem sich aus dem Editor zellenweise – vgl. Abschn. 1.5.1 – die folgenden Beispiele am Rech-
ner abarbeiten lassen.
Hinweis: Ausführbare Anweisungen u. a. im Command Window, den Help-Fenstern, dem Editor
können nach Selektion (Einfärbung) mit der Taste F9 ausgeführt werden!
1.4.1 Skalare Operationen und Variablenverwaltung

Operationszeichen, Built-In Variable, Online-Hilfe
= Variablenzuweisung
+ − * / \ ˆ Rechenoperatoren
, ; Abschluss einer Befehlskette mit (,) und ohne (;) Ausgabe
... Zeilenumbruch innerhalb einer Anweisung
√
i, j Imaginäre Einheit −1, Function: i.m, j.m
pi Kreiszahl π = 3.14... pi.m
inf Unendlich ∞ (infinity), z. B. 1.0 e309 inf.m
NaN Not a Number, z. B. 0/0, inf-inf nan.m
eps(var) Maß für relative Genauigkeit (Floating-Point) eps.m
kleinster pos. Abstand: |var| + eps(var) > |var|
realmax, -min(class) größte/kleinste pos. Gleitkommazahl realmax.m
format ausgabeformat Formate: short, long, short e, long e,
rat, loose, compact
help befehl MATLAB Online-Hilfe; vgl. auch helpwin / doc
z. B. help ops, helpwin arith, doc slash
type function .m Kopfzeile oder komplette Function, Programm z. B. type i.m
1.4.1.1 Skalare Operationen

Variablen müssen nicht deklariert werden. In MATLAB sind alle Variablen Matrizen mit mögli-
cherweise komplexen Elementen. Ein Vektor ist eine Matrix mit nur einer Zeile oder Spalte und
ein Skalar eine 1x1 Matrix. Standardmäßig wird jeder numerische Wert als doppelt genaue Fließ-
kommazahl – 8 Bytes – gespeichert. Eine Zeichenkette (Character) wird ebenfalls als Vektor
behandelt, dessen Elemente entsprechend der ASCII5 -Zeichensatz-Tabelle in Hochkomma ’....’
gefasst und abgespeichert werden, vgl. Abschn. 1.4.5.2.
Online-Hilfe zu den folgenden Beispielen unter:
⇒ help ops, help format, help class, help double, help single
Es wird zwischen Groß- und Kleinschreibung unterschieden, d. h. a und A sind unterschied-

liche Variablennamen (case sensitive). Das erste Zeichen einer Variablen und Konstanten muss
ein Buchstabe sein, folgen können Buchstaben, Zahlen, Unterstriche ( _ ) . Die Länge umfasst ab
MATLAB 6.5 63 Zeichen (Abfrage mit: namelengthmax).
Ohne Zuweisung wird das Ergebnis eines Ausdrucks der Standard-Variablen ans (steht für
answer) zugewiesen, das Ausgabeformat ist mit format wählbar, vgl. auch Preferences unter
dem File-Button in der Desktop-Menüleiste, Bild 1.1:
5 American Standard Code for Information Interchange
1.4 Basis-Elemente 7
>> format compact, format long e % Ausgabe ohne Leerzeilen, Format

>> (47+1e+02*1.5+4^2)/4 % Abschluss mit Return-Taste
ans =
5.325000000000000e+001 % je nach Ausgabeformat, hier long e
D. h. ans ist stets die Variable der letzten Eingabe ohne direkte Zuweisung. Mit
>> a=(47+1e+02*1.5+4^2)/4 % Rechtsdivision
a =
5.325000000000000e+001
wird das Ergebnis der Variablen a zugewiesen. Mehrere Zuweisungen können in eine Zeile ge-
schrieben werden, wenn sie durch Komma (,) oder Semikolon (;) getrennt werden
>> a=4\(47+1e+02*1.5+4^2), A=(1.2+78.09)^2 % Linksdivision
a =
5.325000000000000e+001
A =
6.286904100000001e+003
>> a=(47+1e+02*1.5+4^2)/4; A=(1.2+78.09)^2;
Die Ausgabe wird durch ein Semikolon (;) unterdrückt.

Mehrere Zeilen in Form eines kurzen Programmsegments werden zeilenweise eingegeben

und jeweils mit Shift + (Return) abgeschlossen. Mit Return nach der letzten Eingabe erfolgt
die Abarbeitung.
Bisherige Variablen sind Fließkomma-Zahlen vom Typ double – 8 Bytes –, sie können u. a. in eine
vom Typ single – 4 Bytes – konvertiert werden, dies spart Speicherplatz und bei umfangreichen
Rechnungen ab R14 Rechenzeit mit Einbußen bezüglich der Genauigkeit:
>> as = single(a); % as class single, MATLAB 7
>> bs = as+a; % a class double, bs single, Achtung!
Zusätzlich zu den Datentypen (classname) double, single können vorzeichenbehaftete int8, int16,
int32, int64 und vorzeichenlose (positive) uint8,...,uint64 Integergrößen, Festkommazahlen gebil-
det werden. Komplexe Größen benötigen doppelten Speicherplatz, Real- und Imaginärteil wer-
den getrennt verwaltet.
⇒ help datatypes, help class
Die Wertebereiche erhält man z. B. mit
>> realmax(’double’); realmax(’single’);
>> realmin(’double’); realmin(’single’);
>> intmax(’int32’); intmin(’int16’);
>> intmax(’uint32’); intmin(’uint16’);
Komplexe Variablen sind mit der komplexen Standard-Einheit i oder j zu bilden:

>> format short e % Ausgabeformat geändert
>> z1=0.5+7i % 7i komplexe Einheit, berechnet in i.m
z1 =
5.0000e-001 +7.0000e+000i % class double(complex)
>> z2=2-4*i; % Achtung! falls i eigene Variable

>> z1*z2
ans =
2.9000e+001 +1.2000e+001i
1.4.1.2 Variablenverwaltung
Variablenverwaltung
clear, clear y z Löscht alle oder ausgewählte (y z) Variablen des Workspace

who/whos Workspace: Variablen-Liste /+Dimension, Datentyp (class)
save verz\file variablen speichert Workspace in file.mat, optional auch ASCII
load verz\file variablen lädt Daten aus file.mat in den Workspace, optional ASCII
diary(’verz\file’) speichert nachfolgende (ASCII-) Text/Daten einer Sitzung
diary on ... diary off Protokolldatei: speichert Sitzung zwischen on und off
Alle Variablen einer Sitzung werden im sog. Workspace gespeichert und sind jederzeit durch
Eingabe des Namens einer vorhandenen Variablen abrufbar, z. B. liefert in der bisherigen Sitzung
>> a
a =
5.3250e+001 % class double
Die Namen der Built-In Variablen pi, i, j, inf, eps,... sollten nicht als eigene Variablen eingeführt
werden. Ist dies nicht zu umgehen, so müssen diese vor Gebrauch mit dem Befehl clear variable
gelöscht werden, so dass die Built-In Variablen ihren Wert darstellt. Dies gilt z. B. für: 7*i; 7i ist
in jedem Fall die imaginäre Zahl. Ohne Variablen-Angabe wird mit clear der gesamte Workspace
gelöscht.
Mit who kann die Liste der aktuellen Variablen im Workspace angezeigt werden, mit whos
erhält man zusätzlich noch die Dimension (z. B. 1×1 für eine Variable, 5×1 für einen Spalten-
vektor mit 5 Elementen) und das Datenformat sowie den Speicherbedarf. Beispiel:
>> clear, a=5; b=-single(74); s=’Beispiel: who, whos, save, load’; a+b;
>> who
Your variables are:
a ans b s
>> % Verzeichnis C:\BMATL muss existieren
>> save C:\BMATL\Ueb_1 % Speichert Workspace-Daten in ueb_1.mat
>> clear % löscht den Workspace
>> load C:\BMATL\Ueb_1 a ans s % lädt ausgew. Daten, ohne Auswahl alle
>> whos
Name Size Bytes Class Attributes
a 1x1 8 double
ans 1x1 4 single
s 1x31 62 char
Ähnlich ist diese Information im Workspace Browser dargestellt. Daten können hinzugefügt
und im Variable Editor manipuliert werden. Speichern bzw. Laden der Daten ist auch über den
Bild 1.2: Workspace Browser, MATLAB 7.12
Menüpunkt File/Save Workspace As.. bzw. File/Import Data.. im Command

Window Bild 1.1 oder bei aktivem Workspace Fenster mit dem Save Button nach Bild 1.2
durchzuführen.
1.4.2 Mathematische Funktionen

MATLAB verfügt über eine Vielzahl mathematischer Funktionen, die u. a. mit
⇒ help elfun, help datafun
angezeigt werden können. Einige Funktionen für eine elementweise Ausführung der Variablen x
sind im Folgenden zusammengestellt. Das Argument ( x ) kann also ein Skalar (1×1-Matrix), ein
Vektor oder eine Matrix sein.
Mathematische Funktionen, elementweise Ausführung
sqrt ( x ), nthroot( x,n ) Quadratwurzel, n-te Wurzel

exp ( x ) Exponentialfunktion ex
log ( x ), log10 ( x ) Natürlicher ln(x), Zehner-Logarithmus log(x)
sin ( x ), cos ( x ) Sinus, Cosinus, x in Radian
tan ( x ) Tangens, x in Radian
atan ( x ), atan2 ( imag, real ) Arcus-Tangens ±90°, ±180°
abs ( x ) Betrag
sign ( x ) Signum (Vorzeichen) x > 0 → 1, x < 0 → −1, x = 0 → 0
conj ( x ) Konjugiert komplexe Zahl, x = a + ib → x̂ = a − ib
real ( x ), imag ( x ) Realteil, Imaginärteil, real(x)=a, imag(x)=b
angle ( x ) Phase einer komplexen Zahl (mit atan2 gebildet)
Beispiele zum Aufruf mathematischer Funktionen:

√
5−1
y1 = 3 √ 3 − 1
5+1
>> y1 = 3*sqrt(5-1)/(5+1)^(3/2)-1
y1 =
-5.9175e-001
π
y2 = 22 + ln (π) sin (0.75 ) + e2/3π
2
>> y2 = 2^2+log(pi)*sin(0.75*pi/2)+sqrt(exp(2*pi/3))
y2 =
7.9072e+000
π
y3 = sin2 ( ) + log (cos (0.73 ))
4
>> y3=(sin(pi/4))^2+ log10(cos(0.7^3))
y3 =
4.7394e-001
π
y4 = ei 4
>> y4=exp(i*pi/4)
y4 =
7.0711e-001 +7.0711e-001i
π π
y5 = y3 − cos ( ) − i sin ( )
4 4
>> y5=y4-cos(pi/4)-i*sin(pi/4)
y5 =
0

3 3 3π
y6 = ln e sign sin + | i sin(0.7) |
2
>> y_6=log(exp(3))*sign((sin(3*pi/2))^3)+abs(i*sin(0.7))
y_6 =
-2.3558 % Achtung: sign(0)=0, mathematisch nicht definiert
Beispiele zur Arcus-Tangens-Funktion, u. a. y7 = arctan(0.7)
>> y7=atan(0.7) % Hauptwert von atan(x)
y5 =
6.1073e-001 % Radian
>> y8=atan2(0.7,pi) % y=0.7, x=pi; eingeschlossener Winkel

% 4 Quadranten -pi<= atan2(y,x) <= pi
y8 =
2.1924e-001
>> y9=angle(pi+0.7i) % wie y8; vgl. auch phase(pi+0.7i) aus

y9 = % der System Identification Toolbox
2.1924e-001
Beispiel zum konjugiert komplexen Wert
>> y10=conj(0.7+0.1j) % konjugiert komplexer Wert
y10 =
7.0000e-001 -1.0000e-001i
>> y10=(0.7+0.1j)’; % konjugiert komplexer Wert, wie conj

1.4.3 Vektoren und Matrizen

Vektor- und Matrix-Formulierung
[ x1 x2...; y1, y2,... ] Vektor- und Matrix-Eingabe

start: schrittweite : ziel Zahlenfolge; Doppelpunkt-Operator (:), Vektor
linspace ( start, ziel, anzahl ) lineare Zahlenfolge, Vektor-Ausgabe
logspace ( start, ziel, anzahl ) logarithmische Zahlenfolge, Vektor-Ausgabe
(vek/mat) .’ , (vek/mat)’ Transposition: komplexe, reelle Vektoren u. Matrizen
eye ( zeilen, spalten ,classn. ) Einheitsm. zeilen × spalten, classn. z. B. ’single’
ones ( zeilen, spalten ,classn. ) Matrix mit Eins-Elementen, z. B. ones(3,4,’int8’)
zeros ( zeilen, spalten ,..,classn. ) Matrix mit Null-Elementen
repmat ( mat / skalar, n, m) Matrix: [ mat / skalar n mal; mat/skalar m mal ]
diag ( vek , k ) Matrix mit k-ter Diagonalen
diag ( mat , k ) Vektor der k-ten Diagonalen
k = 0 oder leer → Haupt-, k
= 0 → Nebendiagonale
fliplr ( mat) klappt eine Matrix von links nach rechts
rand ( zeilen, spalten) Matrix mit Zufalls-Elementen
a ( index ) Vektor-Element index von a oder einer Matrix
A ( zeile, spalte ) Matrix-Element von A, azeile,spalte
A ( end ) Letztes Vektor-, Matrix-Element von A
sparse (A) Sparse-Matrix, speichert keine Null-Elemente
Die Elemente von Vektoren (vek) und Matrizen (mat) werden in eckige Klammern gesetzt. Die

Zeilen werden durch Semikolon (;) oder / und Zeilenumbruch (Return) abgeschlossen. Die Ele-
mente können durch Leerzeichen oder Komma (,) von einander getrennt werden. Für spezielle
Matrizen, z. B. der Einheitsmatrix, existieren Built-In Functions.
⇒ help matfun
Beispiele zur Vektorformulierung:

>> vz = [1 2 3] % Zeilenvektor
vz =
1 2 3
>> vs = [ 1; 2; 3 ] % Spaltenvektor, statt (;) auch Return

vs =
1
2
3
>> vzi = [1+5i, 2+i, 3-7i] % Zeilenvektor, komplexe Elemente
vzi =
1.0000e+000 +5.0000e+000i 2.0000e+000 +1.0000e+000i ....
Der Spaltenvektor lässt sich auch durch Transponieren des reellen Zeilenvektors erzeugen
>> vs=[1,2,3]’ % transponieren eines Zeilenvektors
vs =
1
2
3
>> vs = vz’; % transponieren von vz und Zuweisung
Bei komplexen Vektoren liefert (..)’ den zugehörigen konjugiert komplexen Vektor. Der Vek-
tor des transponierten komplexen Vektors gewinnt man mit:
>> vsi = vzi.’ % transponieren eines komplexen Vekt.
vsi =
1.0000e+000 +5.0000e+000i
2.0000e+000 +1.0000e+000i
3.0000e+000 -7.0000e+000i
Elementfolgen, z. B. 0, 2, 4, 6, 8, bei denen die Folgeelemente mit fester Schrittweite gebildet

werden, sind mit dem Doppelpunkt-Operator in der Form start : schrittweite : ziel zu erzeugen;
vgl. auch Function linspace. Der Aufruf start : ziel setzt die Schrittweite +1 an.
Beispiele für Elementfolgen:
>> v=0:2:8 % Elementfolge, Schrittweite 2
v = % vgl. auch: >> linspace(0,8,5)
0 2 4 6 8
>> v = [ 8:-2 : 0] % [ ] überflüssig, Schrittw. -2
v =
8 6 4 2 0
>> v = 0:8 % Schrittweite 1
v =
0 1 2 3 4 5 6 7 8
Beispiele zur Matrizen-Formulierung:

>> A=[1 2 3; 3 4 5; 6 7 8] | >> B=[[1 2 3]’,[2 4 7]’]
A = | B =
1 2 3 | 1 2
3 4 5 | 2 4
6 7 8 | 3 7
|
>> C=[1:2:5 ; 7:9] | >> A1 = [1 4 9; 6 4 5]
C = | A1 =
1 3 5 | 1 4 9
7 8 9 | 6 4 5
Spezielle Matrizen werden über Built-In Functions erzeugt: eye, ones, zeros, diag, spdiags...
>> E=eye(3) % 3,3 Einheitsmatrix, Datentyp: double
E = % auch E=eye(3,3)
1 0 0
0 1 0
0 0 1
>> I=ones(2) % 2,2 Einsmatrix, Datentyp: double

I = % auch I=ones(2,2)
1 1
1 1
>> Z=zeros(2,3,’single’) % 2,3 Nullmatrix, Datentyp: single

Z =
0 0 0
0 0 0
Bei einem bzw. zwei gleichen Eingangsargumenten, z. B. zeros(2) bzw. zeros(2,2), wird eine
quadratische, sonst, z. B. eye(3,2), eine Rechteckmatrix erzeugt.
Eine Matrix kann auch mit Submatrizen aufgebaut werden. Gegeben seien die quadratischen
Matrizen A , B und gesucht ist die Hypermatrix Q :

2 4 4 2 0 2×2 E 2×2
gegeben: A = , B= , gesucht: Q = .
7 5 5 7 −AA B
>> A=[2 4; 7 5]; B=A(:,[2 1]); % Matr. A, B; [2 1] Spaltentausch

>> Q=[zeros(2) eye(2); -A B] % Matrix Q
Q =
0 0 1 0
0 0 0 1
-2 -4 4 2
-7 -5 5 7
Die Submatrizen können auch Matrizenoperationen enthalten:
>> Q=[zeros(2) eye(2); -A*B B*A’].
Mit repmat kann eine (n × m)-Matrix aus einer Submatrix / Skalar generiert werden.
1. aus Submatrix A
>> B=repmat(A,2,3); % B = [A A A; A A A]
2. mit Skalar 2, drei Möglichkeiten
>> n=2; m=3; % n=2; m=3; n=5000; m=6000
>> A = 2*ones(n,m); % schnell schnell
>> A = zeros(n,m); A(:) = 2; % gleichwertig langsamer
>> A(n,m)=2; A(:)=2; % gleichwertig etwas langsamer
>> A = repmat(2,n,m) % langsam etwas langsamer
A =
2 2 2
2 2 2
Bei geringerer Dimension von A überwiegt die Zeit zum Aufruf von repmat.
Die interne Function diag schreibt die Haupt-Diagonalelemente einer Matrix in einen Vektor
>> ad=diag(A)’ % Diagonalelemente von A
ad =
1 4 8
und bildet aus einem Vektor eine Diagonal-Matrix

>> Ad=diag(ad) % Diagonalmatrix
Ad =
1 0 0
0 4 0
0 0 8
Optional lassen sich Neben-Diagonalelemente mit diag(d,j) (obere Neben-Diagonale j positiv

untere j negativ) ansprechen. Im folgenden Beispiel ist eine Matrix aus gegebenen Haupt- und
Neben-Diagonalelementen zu bilden:
>> d=[2 4 6 8]; % Haupt-Diagonalelemente
>> d1=-3*ones(1,3); % 1. obere Neben-Diagonale, j=1
>> d2=-ones(1,2); % 2. untere Neben-Diagonale, j=-2
>> Dd= diag(d) + diag(d1,1) + diag(d2,-2) % Matrix-Aufbau
Dd =
2 -3 0 0
0 4 -3 0
-1 0 6 -3
0 -1 0 8
Auch Nebendiagonal-Elemente lassen sich in einen Vektor schreiben:

>> d2=diag(Dd,-2) % 2. untere Neben-Diagonale
Alternativ kann von einer 4,4-Sparse-Matrix nach S. 15 ausgegangen werden, wobei die Vektoren
von Haupt- und Nebendiagonale gleich lang sein müssen – hier mit full voll besetzte Matrix
gebildet –
>> Dds=full(spdiags([[d2’;0;0], d’, [0;d1’]],[-2, 0, 1],4,4));
Die Gegendiagonale wird mit

>> Adn=fliplr(Ad); oder Adn=fliplr(diag(ad)))
besetzt. fliplr klappt eine Matrix von links nach rechts.

Indizierung
Vektoren- und Matrixelemente werden durch ihre Indizes (1, 2,...; nicht: 0) in runden Klammern
nach dem Namen gekennzeichnet. Ganze Zeilen und Spalten sowie Ausschnitte davon lassen
sich mit dem Doppelpunkt-Operator ansprechen. Elemente können überschrieben werden.
⇒ help lists
Beispiele für Elementansprechung:
>> vzi(3) % 3. Vektorelement von vzi
ans =
3.0000e+000 -7.0000e+000i
>> Dd(3,4) % Matrixelement 3. Zeile / 4. Spalte
ans =
-3
>> Dd(:,2) % alle Elemente der 2. Spalte von Dd
ans =
-3
4
0
-1
>> Dd(4,2:3) % 4. Zeile, Spalten-Element 2 bis 3
ans = % auslesen
-1 0
Matrixelemente können mit ihren Indizes (zeile, spalte) oder mit nur einem Index ange-
sprochen werden. Dieser ergibt sich aus einer vektoriellen Darstellung der Matrix, die aus einer
Hintereinanderschaltung aller Spaltenvektoren folgt (Speichermodell). Z. B. gilt für die obige Dd-
Matrix
Dd(3,4) ≡ Dd(15) Umwandlung mit: ind2sub (i,j)→k, sub2ind (k)→(i,j)
und für drei ausgewählte Elemente von Dd
Dd([1 6 10]) ≡ Dd(1,1), Dd(2,2), Dd(2,3)
end-Operator: Das letzte Element einer Matrix bzw. eines Vektors kann mit dem end-Operator
angesprochen werden:
Dd(end,end) oder Dd(end) aber auch Dd(end-2).
Für das letzte Element einer Zeile sowie aller Zeilen oder Spalten folgt entsprechend
Dd(3,end) sowie Dd(:,end) oder Dd(end,:)
Beispiele für Elementzuweisung:
>> vzi(3)=26 * 98 % 3. Element wird geändert
vzi =
1.0000e+000 +5.0000e+000i 2.0000e+000 +1.0000e+000i 2.5480e+003
>> Dd(4,2:3)=[7 0] % 4. Zeile, Element 2 bis 3 neu zuweisen

Dd =
2 -3 0 0
0 4 -3 0
-1 0 6 -3
0 7 0 8
Aufgabe: Erweitere Dd, so dass der Vektor u=[ 5 6 7 8 ] in die letzte Zeile bzw. letzte
Spalte geschrieben wird, lösche anschließend die 1-te und 3-te Zeile bzw. Spalte.
>> u=[5 6 7 8]; % Vektor u
>> D=[Dd;u]; E=[Dd u’]; D([1 3],:)=[]; E(:,[1 3])=[]; % Lösung
Beispiele für Sparse-Matrix: Gegeben sei die Matrix

⎡ ⎤
0 0 0 5
⎢ 0 2 0 0 ⎥
A=⎢ ⎣ 1 3 0 0 ⎦
⎥
0 0 4 0
gesucht ist die Darstellung der Sparse-Matrix S , siehe help sparse:

>> A=[0 0 0 5; 0 2 0 0; 1 3 0 0;0 0 4 0]; % Ausgangsmatrix

>> S=sparse(A) % Sparse-Matrix von A
S = % class double | >> spy(S) % Elemente
= 0
(3,1) 1 |
(2,2) 2 |
(3,2) 3 |
(4,3) 4 |
(1,4) 5 |
Es werden also nur die Indizes (z. B. (3,2)) und die Werte (z. B. 3) der von Null verschiedenen
Elemente gespeichert. Mit full(S) wird wieder die vollbesetzte Matrix A erzeugt. Elementare
Matrizen, wie Einheitsmatrix, Zufallsmatrizen, Diagonalmatrizen können direkt gebildet werden,
z. B.
>> SE = speye(2)
SE =
(1,1) 1
(2,2) 1
Die vollbesetzte Einheitsmatrix erhalten wir mit:
>> E = full(SE)
E =
1 0
0 1
Spezielle mathematische Funktionen (siehe help sparfun) existieren, einige bearbeiten vollbe-
setzte und Sparse-Matrizen, vgl eigs. Mit spy(S) wird die Struktur von S grafisch dargestellt.
Anwendung in QuerSchw_1,2.m und DrehSchw.m aus [52].
1.4.3.1 Vektor-, Matrizen-Operationen und Built-In Functions

Die mathematischen Operationen + − ∗ / sowie die Rangfolgeregeln sind auch auf Vektor- und
Matrizenoperationen bei passender Dimension anwendbar. Zusätzlich stellt MATLAB Rechenope-
rationen für die elementweise Verknüpfung sowohl für reelle als auch komplexe Vektoren und
Matrizen zur Verfügung. Sie werden aus den Grundoperatoren mit vorangestelltem Punkt, z. B.
.* für elementweise Multiplikation, gebildet.
⇒ help ops, help arith, help matfun, help slash
oder statt slash: mrdivide (right matrix divide), mldivide, rdivide, ldivide
Erläuterungen zur Tabelle Vektor- und Matrix-Formulierung: Ab (R14) können die Eingangs-
variablen der Built-In-Functions, z. B. inv, det, linsolve, eig vom Typ single oder double sein.
Das Ergebnis ist dann vom entsprechenden Typ, vgl. Beispiel zu linsolve Seite 22. Namen von
Built-In Functions können aber sollten nicht als Variablen- oder Functionnamen benutzt werden.
Für das Eingangsargument vek / mat kann sowohl ein Vektor als auch eine Matrix stehen. Ist
in sum ... find das Argument eine Matrix, dann bezieht sich das Ergebnis in der Regel auf die zu-
gehörigen Spaltenvektoren, so dass ein Zeilenvektor ausgegeben wird. Darüber hinaus wird ein
Index-Vektor der Matrix-Indizes zu den Maximal/Minimal-Elementen ausgegeben, siehe Bei-
spiele. Weitere Eingangsargumente sowie Ausgaben sind möglich; siehe Online-Hilfe.
Vektor- und Matrix-Operationen, Built-In Functions
.* .\ ./ .ˆ Elementweise Rechenoperationen
\ / Links- und Rechts-Division
transpose ( vek / mat ) oder vek / mat .’ Transposition: Vektor, Matrix
ctranspose ( vek / mat ) oder vek / mat ’ Transposition, konjugiert-komplex
dot ( vek, vek ), cross ( vek, vek ) Skalar-, Kreuz-Produkt
inv ( mat ) Inverse einer quadratischen Matrix
det ( mat ) Determinante einer quadratischen Matrix
linsolve ( mat, vek / mat , option ) lineares Gleichungs-Syst. LU-Zerlegung (ab R14)
[V, D]= eig ( mat ), eigs ( mat ) Eigenwerte, Eigenvektoren einer quadrat. Matrix
condeig ( mat ), [V,D,s]=condeig (...) Konditionszahl bez. der Eigenwerte von mat
rank ( mat , toleranz ) Rang einer Matrix, siehe auch rref
[m, n]= size( vek / mat , i ) Matrix-, Vektordimension, i=1 Zeilen, i=2 Spalten
length ( vek / mat ) Größter Wert aus Spalten-, Zeilenindex
identisch mit max(size( vek / mat ))
sum ( vek / mat ) Summe der Vektorelemente bzw. Spaltenvektorel.
prod ( vek / mat ) Produkt der Vektorelemente bzw. Spaltenvektorel.
[vmin,index]=min ( vek / mat ) Kleinstes Vektorelement bzw. Spaltenvektorelement
[vmax,index]=max ( vek / mat ) Größtes Vektorelement bzw. Spaltenvektorelement
max ( mat(:) ) Größtes Matrixelement
sort ( vek / mat ) Elemente in aufsteigender Folge
find ( vek / mat ,’last’ | ’first’ ) Von Null verschiedene Elemente, oder find(A==2)
Anhand der Beispiel-Matrizen und -Vektoren

>> A=[1 2 3; 4 5 6; 7 8 9]; B=[1 2 3; 2 4 5;3 7 8];
>> b=[ 2 4 6 8 10]’; v=0:2:8;
sollen einige Operationen erläutert werden:
>> v*b % oder: dot(v,b) % Skalar-Produkt
ans =
160
>> Dy_pr=v’*b’ % Dyadisches Produkt

Dy_pr =
0 0 0 0 0
4 8 12 16 20
8 16 24 32 40
12 24 36 48 60
16 32 48 64 80
>> size(Dy_pr) % Matrix-Dimension
ans =
5 5 % 5,5-Matrix
>> size(Dy_pr,1); size(Dy_pr,2); % Zeilen-/Spalten-Dimension
>> c=v+b’; c=v-b’; % Vektor-Addition, -Subtraktion

>> C=A+B; C=A-B; % Matrix-Addition, -Subtraktion

>> C=A*B; % Matrix-Multiplikation
>> c=A*v(1:3)’ % Matrix-Vektor-Multipl.
c =
16
34
52
Beispiele elementweiser Operationen:
>> c=v.*b’ % Vektorelement-Multipl.

c = % c(i) = v(i) * b(i)
0 8 24 48 80
>> c=v./b’ % Vektorelement-Rechts-Div.

c = % c(i) = v(i) / b(i)
0 5.0000e-001 6.6667e-001 7.5000e-001 8.0000e-001
>> c=v.\b’ % Vektorelement-Links-Div.

Warning: Divide by zero.
c = % c(i) = b(i) / v(i)
Inf 2.0000e+000 1.5000e+000 1.3333e+000 1.2500e+000
>> sin(v) % elementweise Sinus-Bildung

ans = % sin(v(i))
0 9.0930e-001 -7.5680e-001 -2.7942e-001 9.8936e-001
>> C=A.*B % Matrixelement-Multipl.

C = % C(i,j) = A(i,j)*B(i,j)
1 4 9
8 20 30
21 56 72
>> C=A./B % Matrixelement-Rechts-Div.

C = % C(i,j) = A(i,j) / B(i,j)
1.0000e+000 1.0000e+000 1.0000e+000
2.0000e+000 1.2500e+000 1.2000e+000
2.3333e+000 1.1429e+000 1.1250e+000
>> C=A.\B % Matrixelement-Links-Div.

C = % C(i,j) = B(i,j) / A(i,j)
1.0000e+000 1.0000e+000 1.0000e+000
5.0000e-001 8.0000e-001 8.3333e-001
4.2857e-001 8.7500e-001 8.8889e-001
>> C=A.^B % Matrixelement-Potenz

C = % C(i,j) = A(i,j)^B(i,j)
1 4 27
16 625 7776
343 2097152 43046721
>> sqrt(A) % elementw. Quadratwurzel

ans =
1.0000e+000 1.4142e+000 1.7321e+000
2.0000e+000 2.2361e+000 2.4495e+000
2.6458e+000 2.8284e+000 3.0000e+000
Beispiele spezieller Matrizenoperationen und Matrix-Funktionen:
>> C=A\B % Matrix-Links-Div.; A^(-1)*B
Warning: Matrix is close to singular or badly scaled.
Results may be inaccurate. RCOND = 1.541976e-018.
C = % Achtung! A singulär
-3.3333e-001 -4.5036e+015 -4.5036e+015
6.6667e-001 9.0072e+015 9.0072e+015
0 -4.5036e+015 -4.5036e+015
>> C=A/B % Matrix-Rechts-Div.; A*B^(-1)

C =
1.0000e+000 0 0
-5.0000e+000 9.0000e+000 -3.0000e+000
-1.1000e+001 1.8000e+001 -6.0000e+000
>> detA=det(A), detB=det(B) % Determinante von A und B

detA =
0 % Matrix A ist singulär
detB =
1 % Matrix B ist regulär
>> inv(B) % Inverse von B; B^(-1)

ans =
-3.0000e+000 5.0000e+000 -2.0000e+000
-1.0000e+000 -1.0000e+000 1.0000e+000
2.0000e+000 -1.0000e+000 0
>> B*inv(B) % Kontr.: B * B^(-1) = E oder B/B = E

ans = % Elemente: ~ 0; numerischer Fehler
1.0000e+000 0 4.4409e-016
0 1.0000e+000 8.8818e-016
0 -1.7764e-015 1.0000e+000
>> eig(A) % Eigenwerte der Matrix A

ans =
1.6117e+001
-1.1168e+000
-1.0307e-015 % Hinweis auf Singularität, 0-Eigen-W.
>> [V,D]=eig(B) % Eigenwerte D und Eigenvektoren V

V = % Eigenvektoren
-2.8096e-001 8.1276e-001 8.1276e-001
-5.0038e-001 2.4854e-002 -3.6883e-001i 2.4854e-002 +3.6883e-001i

-8.1895e-001 -3.2897e-001 +3.0749e-001i -3.2897e-001 -3.0749e-001i
D = % Diagonalelemente sind die Eigenwerte
1.3306e+001 0 0
0 -1.5313e-001 +2.2739e-001i 0
0 0 -1.5313e-001 -2.2739e-001i
>> rank(A) % Rang der Matrix A

ans = % Rangabfall, lineare Zeilen-, Spalten-
2 % Abhängigkeit, vgl. Singularität von A
Beispiele zu den Befehlen: sum, max, min:

>> sum(A) % oder sum(A,1), Spaltensummen
ans =
12 15 18
>> sum(A,2) % Zeilensummen
ans =
6
15
24
Die Summe aller Matrix-Elemente ergibt sich durch doppelte Summenbildung oder mit dem Speichermo-
dell von S. 15 zu:
sum(sum(A)) oder sum(A(:)).
>> [vmax,I]=max(A) % vmax maximale Spaltenelemente

vmax = % I zugehöriger Index von A
7 8 9
I = % I Index von A der Maximalelemente
3 3 3 % alle Maximal-Elemente in 3. Zeile
Entsprechendes gilt für den Befehl min.
1.4.4 Lineare Gleichungssysteme

In MATLAB können lineare Gleichungssysteme
AX = B bzw. Ax = b
mit der (m × n) Koeffizienten-Matrix A (m Gleichungen, n Unbekannte), der (n × r) Matrix X

bzw. dem n × 1 Vektor x der Unbekannten und der (n × r) Matrix B der r rechten Seiten bzw. dem
(n × 1) Vektor b der rechten Seite mit dem Backslash-Operator \ (siehe help mldivide) ge-
löst werden. Es ist keine Auswahl eines geeigneten Lösungsverfahrens erforderlich. Der mit dem
Backslash-Operator aufgerufene Algorithmus analysiert die übergebenen Matrizen A , B bzw. b
und wählt ein geeignetes Verfahren aus. Gleichungssysteme mit Sparse-Matrizen und symboli-
schen Matrizen, Seite 88, sind zulässig.
Allgemein unterscheidet man direkte und iterative Verfahren. Der G AUSS-Algorithmus ist ei-
ne direkte Methode, weil nur durch Umformen eine auflösbare Form gefunden wird. Die direkten
Methoden, siehe help matfun / lineare equations, basieren u. a. auf den Functions rref, chol, lu,
die iterativen können unterteilt werden in:
• Konjugierte Gradientenmethoden: bicg, bicgstab, cgs,lsqr, pcg.

• Residuen Verfahren: gmres, minres, qmr.
• Symmetrisches LQ-Verfahren: symmlq, Symmetrie A T = A , nicht notwendig positiv definit.
Alle Methoden lassen sich auch direkt aufrufen. Darüber hinaus existiert die Function linsolve.
Bei ihrem Aufruf können spezielle Eigenschaften, wie Symmetrie, positive Definitheit usw. op-
tional übergeben werden. Die angewendeten Methoden sind die direkte LU Faktorisierung bei
quadratischer Koeffizientenmatrix, anderenfalls die QR Faktorisierung. Der Aufruf der iterativen
Verfahren erfordert einige Erfahrung, da sehr spezifische Angaben zu machen sind.
Die Lösbarkeit des Gleichungssystems A x = b mit beliebiger rechteckiger (m × n)-Koeffi-
zientenmatrix A basiert auf der Definition für den Rang einer Matrix. Ein System kann eindeutig
lösbar, lösbar oder nicht lösbar sein. Das System ist lösbar, wenn der Rang r(A A) gleich dem
der um b erweiterten Matrix r(A A, b ) ist. Eindeutig lösbar, wenn r(A
A) = r(A
A, b ) = n ist. Nicht
eindeutig lösbar, wenn r(AA) < n, dann sind n − r(A A) Unbekannte frei wählbar. Einen detaillier-
ten Überblick mit vielen Anwendungen ist unter: http://www.dankertdankert.de/ zu
finden, weitere Hinweise zu den Verfahren in [57].
Anhand von Beispielen sollen einige Lösungsmethoden kurz aufgezeigt werden, siehe auch
[52] unter Lin_Gleichung.m.
Quadratische Koeffizientenmatrix
Die Matrix A kann regulär bzw. singulär (r(A
A) < n) sein.
Beispiel mit regulärer Matrix A , eindeutige Lösung:
A=[10,2,3;4,5,6;7,8,9]; b=[15; 15; 24]; % Koeffizientenm., rechte Seite
det_A = det(A); % Determinante: det_A = -27.0
r_A = rank(A); % Rang: r_A = 3
r_Ab = rank([A,b]); % Rang: r_Ab=3
x = A\b; % Lösung: x = [1, 1, 1]
Beispiel mit singulärer Matrix A , System unlösbar:

A(1)=1; % Element geändert
det_A = det(A); % Determ.: det_A=6.66e-016
r_A = rank(A); % Rang: r_A = 2
r_Ab = rank(A,b); % Rang: r_Ab= 1
x=A\b; % Warning!! + falsche Lösung
Beispiel mit singulärer Matrix A und geänderten rechten Seite b , lösbar:

b_neu = [15; 15; 15]; % rechte Seite geändert
r_Ab = rank([A,b]); % Rang: r_Ab=2=r_A
Ar = A(:,1:2); % x3 vorgegeben, z. B. x3=1
r_Ar = rank(Ar); % Rang: r_Ar = 2
r_Arb= rank([Ar,b_neu]); % Rang: r_Arb= 3
bx=A(:,3); % Spalte 3 auf rechte Seite
x3=1; % x3 beliebig vorgegeben
Das um eine Spalte reduzierte, überbestimmte Gleichungsystem kann unmittelbar gelöst werden:
Überbestimmtes Gleichungssystem
xr=Ar\(b_neu-bx*x3); % Lösung: xr=[x1; x2]=[-14; 13]
x=[xr;x3]; % kompletter Lösungsvektor
Weil x3 beliebig, existieren unendlich viele Lösungen. Die Lösung x wird durch die Lösung
eines Ausgleichsproblems bestimmt.
Da die Lösung alle drei Gleichungen erfüllt, kann man für die Berechnung eine Zeile, z. B. die
zweite, streichen, so dass wieder ein reguläres System entsteht:
Arr=Ar([1 3],:); % Arr=[1 2; 7 8]; regulär
det_Arr = det(Arr); % det_Arr = -6
brr = b_neu([1,3]); bxx = bx([1,3]); % reduzierte rechte Seite
xrr = Arr\(brr-bxx*x3); % xrr = [-14; 13], wie xr
Unterbestimmtes Gleichungssystem
Beispiel mit rechteckiger Matrix A , lösbar, Ausgleichslösung:
Wir konstruieren uns ein System, indem wir zwei Spalten hinzufügen:
Au=[A,2*A(:,2)+A(:,3),A(:,1)-A(:,3)]; % (3,5)-Koeffizientenmatrix
rank(Au); % Rang: 3
bu=sum(Au,2); % rechte Seite, Zeilensumme Au
rank([Au,bu]); % Rang: 3
xu=Au\bu; % xu=[1.5; 0; 0; 1.5; 0.5]
Symmetrische Matrix A, die linsolve Function

Sind spezifische Eigenschaften wie Symmetrie des Gleichungssystems bekannt, dann können
diese mit linsolve übergeben werden.
Beispiel mit regulärer symmetrischer und positiv definiter Matrix A :
As=A*A’ % symmetrische Matrix As
lambda=eig(As); % Eigenw. pos. -> As pos. def.
det_As = det(As); % det_As = 729, positiv
opts.SYM = true; opts.POSDEF = true; % Optionen: Symm., pos. def.
x_linsolve = linsolve(single(As),b,opts)% x_linsolve=[0; -0.333; 0.333]
% x_linsolve vom Typ single
Aufrufe ausgewählter Methoden

In machen Fällen kann es erforderlich sein, auf die Functions, die hinter dem Backslash-Operator
stehen, zurückzugreifen. Dies setzt Kenntnisse der Algorithmen voraus. Hierzu zwei Beispiele:
Beispiel zur LU-Faktorisierung (Zerlegung), direktes Verfahren.
Die reguläre Matrix A wird in eine obere U Dreiecksmatrix und fast untere L zerlegt, so dass
L U = A . Mit [L,U,P]= lu(A); sind L und U Dreiecksmatrizen. Die Lösung ergibt sich
anschließend durch Vorwärts- und Rückwertseinsetzen.
[L,U] = lu(A) % U obere Dreiecksmatrix
x_lu = U\(L\b) % Lösung: x_lu=[1; 1; 1]
Beispiel zur iterativen Vorgehensweise. Als Löser wählen wir qmr.

x_qmr=qmr(A,b,1.0e-8,25,[],[],[10;0;-10]) % x_qmr=[1; 1, 1]
In der Argumentenliste folgen auf die Systemgrößen, optionale Angaben: geforderte Genau-
igkeit, maximale Anzahl der Iterationsschritte, zwei Matrizen M 1 , M 2 zur Präkonditionierung
(hier Platzhalter) und Startwerte. Die iterativen Methoden sind insbesondere für große und dünn
besetzte (Sparse-) Matrizen geeignet.
Sind A , b oder A bzw. b vom Typ single, dann ist das Ergebnis auch vom Typ single, in
der Regel vom Typ double. Zusätzliche Beispiele sind in Lin_Gleichung.m zu finden.
• Hinweis zur Rangfolgeregel (Potenzieren vor Multiplikation oder Division, dann Addition
oder Subtraktion): Gegeben sei die algebraische Gleichung

2 4 3.5
K x = 0.5 b , K= , b=
7 5 7.75
mit der quadratischen Matrix K und dem Vektor b passender Dimension; gesucht sei x . Ergebnis:
mit Rangfolgeregel-Fehler richtig
>> x=0.5*K\b >> x=0.5*(K\b) oder: >> x=K\b*0.5
x = x =
1.5000e+000 3.7500e-001
1.0000e+000 2.5000e-001
1.4.5 Spezielle Datenstrukturen

Unter MATLAB sind weitere Datenstrukturen vorhanden, die kurz erläutert werden sollen.
⇒ help class, help strfun, help struct, help cell, help char
1.4.5.1 Mehrdimensionale Matrizen

Mehrdimensionale Matrizen-Elemente werden mit mehr als zwei Indizes angesprochen. Mit den
Built-In Functions zeros, ones, rand, randn können derartige Matrizen gebildet werden, z. B.
>> O=ones(2,3,4,3); mit dem Element >> O(2,2,3,1);
Anschaulicher und von größerer Bedeutung sind 3D-Arrays:
Beispiel für 3D-Array: Struktur: K(zeile,spalte,seite)
Zuweisung:
>> K(1,1,1)=1; >> K(2,2,2)=2; >> K(3,3,3)=3;
Erst letzte Zuweisung erzeugt 3 × 3 × 3-Array.

Aufruf:
>> K(:,:,3) ans = 0 0 0 Seite 3
0 0 0
0 0 3
>> K(:,:,2) ans = 0 0 0 Seite 2
0 2 0
0 0 0
>> K(:,:,1) ans = 1 0 0 Seite 1

0 0 0
0 0 0
1.4.5.2 Zeichenketten (Character, String)

• Zeichenketten vom Typ char werden durch Hochkomma begrenzt, Beispiel:
>> ’ Zeichenketten werden durch Hochkomma begrenzt ’
• Mehrzeiliger Text gleicher Länge wird mit einem normalen Array
>> [’Textzeile 1’;’Textzeile 2’]
• mehrzeiliger Text unterschiedlicher Länge mit einem Cell Array, siehe Abschn. 1.4.5.4, und
anschließender Konvertierung (cell → char) formuliert
>> char({’Textzeile 1’;’Textzeile 2 ist länger’})
• Jedes Zeichen eines Character Arrays benötigt 2 Byte Speicherplatz.
1.4.5.3 Strukturen, (Structure Array)

• In Strukturen lassen sich Variablen unterschiedlichen Datentyps verwalten. Dies bietet sich
für die Datenverwaltung einzelner System-Komponenten an, siehe Abschn. 8.6
• Der Name einer Structure besteht aus zwei Teilen, dem Structure-Namen vor dem Punkt
und dem Feldnamen innerhalb der Structure nach dem Punkt (Separator).
• Structure-Elemente werden über Namen und Indizes angesprochen.
Syntax:
struktur=struct(’name1’,wert1,’name2’,wert2, . . . ) % Structure-Erzeugung
struktur.name1 % Feld-Element-Zugriff
oder Erzeugung über direkte Zuweisung
struktur.name1 = wert1;
struktur.name2 = wert2;
Beispiel, Structure erstellen, erweitern und Ausgabe:
>> A=[1 2 6; 4 5 9; 7 8 3]; % gegebene 3,3-Matrix

>> user_struktur = struct(’daten’,A,’dimension’,[3 3])
user_struktur =
daten: [3x3 double]
dimension: [3 3]
>> user_struktur.dimension % Ausgabe: Feld ’dimension’

ans =
3 3
>> user_struktur(2).daten=inv(A) % Erweiterung um inv(A)

user_struktur =
1x2 struct array with fields:
daten
dimension
>> user_struktur.daten % Ausgabe

ans = % Matrix A, auch mit

1 2 6 % user_struktur(1).daten
4 5 9
7 8 3
ans = % Inverse von A, auch mit
-2.1111e+000 1.5556e+000 -4.4444e-001 % user_struktur(2).daten
1.8889e+000 -1.4444e+000 5.5556e-001
-1.1111e-001 2.2222e-001 -1.1111e-001
>> % Elemente ansprechen, z.B.

>> user_struktur(1).daten(2,3) % Matrix A, Element A(2,3)
ans =
9
1.4.5.4 Zellen (Cell Array)

• Daten unterschiedlichen Typs, z. B. Zeichenketten (class char), Matrizen (class double,
single) unterschiedlicher Dimension, Structure Arrays können als Zellen in einer Varia-
blen verwaltet werden.
• Cell-Elemente werden über ihre Indizes angesprochen.
• Zur Kennzeichnung von Cell-Elementen dienen geschweifte Klammern.
Beispiel, Cell Array erstellen (zwei Möglichkeiten) und ausgeben:
>> A(1,1) = {[1 2 3; 4 5 6; 7 8 9]}; % Zuweisung der Zelle 1,1
>> A(1,2) = {’ Testmatrix ’}; % Zuweisung der Zelle 1,2
>> A(2,1) = {3 + 7i}; % Zuweisung der Zelle 2,1
>> A(2,2) = {0 : pi/100 : 2*pi}; % Zuweisung der Zelle 2,2
oder
>> A{1,1} = [1 2 3; 4 5 6; 7 8 9]; ... % auf Klammertyp achten!
Aufruf:
>> A | >> A(1,1)
A = | ans =
[3x3 double] ’ Testmatrix ’ | [3x3 double]
[3.0000e+000 +7.0000e+000i] [1x201 double] |
>> A{1,1} % 1. Zelle, [3x3 double]

ans = % Element-Aufruf: A{1,1}(2,3) -> 6
1 2 3
4 5 6
7 8 9
Ein leeres Cell Array und anschließende Besetzung mit einem Structure Array folgt mit:
>> Z=cell(2,4); Z{1,3}=user_strutur
Z = % vgl. Programms.: Basis_Elemente.m
[] [] [1x2 struct]
[] [] []
Mit cellplot kann Z grafisch angezeigt werden: >> cellplot(Z,’legend’)
1.4.6 Vergleichsoperatoren und logische Operatoren

Vergleichsoperatoren Logische Operatoren
==, ∼= gleich, ungleich ∼ Negation
< , <= kleiner, kleiner gleich &, && Und; Matrix-, Skalar- Vergl.
> , >= größer, größer gleich |, || Oder; Matrix-, Skalar- Vergl.
exist (’x’) Existenz von x prüfen xor Exklusiv ODER
⇒ help ops, help relop, help logical, help bitand
Die Symbole &, | und ∼ sind die logischen Operatoren AND, OR und NOT. Sie können auf
Zahlen, arithmetische Ausdrücke sowie Matrizen angewandt werden. Matrizen werden element-
weise verknüpft. Logisch falsch wird durch 0, logisch wahr durch einen Wert ungleich Null
gekennzeichnet.
Syntax: a & b oder and(a,b)
a|b oder or(a,b)
∼a oder not(a)
Der NOT-Operator negiert den Wahrheitswert des Ausdrucks. xor(a,b) ist der Exclusiv-OR-Ope-
rator. Die einzelnen Verknüpfungen sind in folgender Tabelle zusammengefasst.
Eingang and or xor not

a b a&b a|b xor(a,b) ∼a
0 0 0 0 0 1
0 1 0 1 1 1
1 0 0 1 1 0
1 1 1 1 0 0
Die NOT-Verknüpfung hat die höchste Priorität. Der AND-Operator hat gegenüber dem OR-
Operator in MATLAB die höhere Priorität. Im Zweifelsfall sollten Klammern gesetzt werden:
identisch
a | b & c −→ a | (b & c)
Die Vergleichsoperatoren arbeiten bei Matrizen ebenfalls elementweise. Logisch wahr ist 1, lo-
gisch falsch 0. Die Operatoren <, <=, >, >= beziehen sich bei komplexen Variablen nur auf
den Realteil, die Operatoren == und ∼= auf Real- und Imaginärteil.
Beispiele einfacher Verknüpfungen:
>> a = 5; b=-a; % Zuweisung, a ist wahr
>> ~a % Negation von a
ans =
0
>> (7 > 11-5 & 7 <= 5*2 ) | ~a % besser &&-Verknüpfung
ans =
1
Nachweis des kleinsten Abstandes eps(b) zur nächst größeren Zahl von b, vgl. S. 6 und
S. 28:
>> s=(abs(b)-eps(b)) < abs(b) & (abs(b)-0.5*eps(b)) < abs(b)

s = % erster Ausdruck ist wahr, zweiter falsch
0
Elementweiser Matrix-Vergleich:
>> X=5; X>=[1 2 3; 4 5 6; 7 8 10] % beide Zeilen ergeben
>> X=5*ones(3,3); X>=[1 2 3; 4 5 6; 7 8 10] % gleiches Ergebnis
ans =
1 1 1
1 1 0
0 0 0
Die Operatoren &&, || werden als Kurzschluss-Operatoren (Short-Circuit Operators) bezeich-
net. Ihre skalaren Operanden werden nicht weiter evaluiert als zur Ermittlung des Wahrheitswer-
tes erforderlich. Beispiel zum Short-Circuit Operator &&, siehe Online-Hilfe:
>> b=0; a=5 % a ist beliebig
>> x = (b ~= 0) && (a/b > 18.5) >> x = (b ~= 0) & (a/b > 18.5)
x = Warning: Divide by zero.
0 x =
0
Es wird deutlich, dass im ersten Fall nur der Ausdruck (b ~= 0) auf den Wahrheitswert
untersucht wird, im zweiten Fall – angedeutet durch das Warning – aber beide.
1.4.7 Verzweigungen und Schleifen

Verzweigungen und Schleifen
if bedingung... elseif... else... end If-Anweisung
switch...case... otherwise... end Switch-Anweisung
for variable = bedingung, befehle end for-Schleife
while bedingung, befehle end While-Schleife
break Vorzeitiger Schleifenabbruch in for, while
continue Abbruch des aktuellen Schleifendurchlaufs
⇒ help lang
Beispiel für: for, if, else, elseif – vgl. For_schleife.m in Programmsammlung [52] –
>> for t = 1.0: -0.1: 0.0, Befehle , end % 1. For-Schleife
k=5;
% 2. For-Schleife,
for m = 1:k
% If-Anweisung
for n = 1:k
if m == n
Ergebnis:
A(m,n) = 2;
A =
elseif abs(m-n) == 2
2 0 1 0 0
A(m,n) = 1;
0 2 0 1 0
else
1 0 2 0 1
A(m,n) = 0;
0 1 0 2 0
end
0 0 1 0 2
end
end
Anmerkung: Obige Erstellung von A ist unzweckmäßig, besser:

d1=2*ones(k,1); d2=ones(k-2,1);
A=diag(d1)+diag(d2,2)+diag(d2,-2); % bzw.: A=2*eye(k)+...
For-Schleifen: Werden Vektoren, Matrizen, wie in der obigen for-Schleife, elementweise besetzt,
dann sollte man zur Rechenzeitersparnis und zur zusammenhängenden Speicherplatzadressie-
rung die Felder präallozieren. Dies kann durch Vorabbelegen mit:
A = zeros(nmax,mmax); oder durch A(nmax,mmax)=0
geschehen. Sind nmax, mmax unbekannt, dann geht man von einem Schätzwert aus und passt
nach den Zuweisungen die aktuelle Dimension an; vgl. folgende Beispiele mit Rechenzeitanga-
ben – siehe auch praeall.m in [52] –, in denen einer Matrix elementweise ein Wert zugewie-
sen wird. Die Rechenzeit wird mit den tic, toc Befehlen, vgl. Tabelle auf S. 32, ermittelt.
nmax=600; mmax=600; wert=12.345; % Programm: praeall.m
% ohne Felddimensionierung
tic
for i=1:nmax, for j=1:mmax, A(i,j)=wert; end, end
toc, clear A
Elapsed time is 2.515000 seconds. % Pentium (R)4 CPU 3.20 GHz
% mit Felddimensionierung
A=zeros(nmax,mmax); % oder A(nmax,mmax)=0;
tic
for i=1:nmax, for j=1:mmax, A(i,j)=wert; end, end
toc, clear A
Elapsed time is 0.016000 seconds.
% Rückwärtsbelegung ohne präallozieren, 1. Zuweisung legt Matrix an

tic
for i=nmax:-1:1, for j=mmax:-1:1, A(i,j)=wert; end, end
toc, clear A
Elapsed time is 0.016000 seconds.
% Felddimensionierung geschätzt
nmax=700; mmax=600; A=zeros(nmax,mmax); t=cputime;
for i=1:nmax, for j=1:mmax, A(i,j)=wert; end
if (cputime-t) > 0.1 , break, end
end
A=A(1:i,1:j); % tatsächliche Feldgröße
Vielfach wirkt sich auch eine Speicher-Defragmentierung durch pack positiv auf die Rechenzeit
aus.
Zwei Beispiele zur While-Schleife
Beispiel 1: Gesucht ist der kleinste positive Abstand eps_a von |var|, so dass numerisch
!
|var| + eps_a(var) > |var| , vgl. eps S. 6, Maß für relativen Fehler von var.
var=5; eps_a = 1; % var=5, Startwert eps_a

while (var+eps_a) ~= var % while-Schleife
eps_a = eps_a/2; % eps_a wird fortlaufend halbiert
end
eps_a = eps_a*2 % damit wieder: var+eps_a > var
Ergebnis: >> eps_a = 2.2204e-016 % kleinster Abstand: var+eps_a > var
Beispiel 2: Iterative Nullstellenbestimmung von f = 0,5 − x + 0,2 sin x mittels N EWTON-

Verfahren, vgl. Newton.pdf, newton.m, newton0.m mit Darstellung der Iterationsfolge
in [52]:
f (xi ) ∂f
xi+1 = xi − , i = 0, 1, . . . ; f = , i-ter Iterationsschritt
f (xi ) ∂x
MATLAB Code:
x = 3.0; % Startwert
ab=1; tol=1.0e-7; % 1. Abbruch-Wert und Abbruch-Toleranz
Imax=100; I=1; % max. Iterationen, 1. Iter.-Schritt
while abs(ab) > tol && I < Imax
x0=x; % Datensicherung
x =x0-(0.5-x+0.2*sin(x))/(-1+0.2*cos(x))
ab=x-x0; I=I+1; % Lösungsänderung, Iter.-Schritte
end
Ergebnis: x = 6.1547e-001
Beispiele zum Switch-Befehl
Zu den über die Tastatur eingegebenen Werten: a=1, 2, 3 bzw. a=eins, a=zwei, a=drei, sind die
Zuweisungen x=1 für a=1, x=2 für a=2 usw. gesucht. Die zugehörigen Anweisungen könnten
wie folgt aufgebaut sein.
% 1. numerischer Wert für a einlesen

a=input(’Eingabe: a = ’); % Tastatureingabe von a, num. Wert
switch a % switch Anweisung für a
case 1, x=1 % a = 1
case 2, x=2 % a = 2
case 3, x=3 % a = 3
otherwise error(’Fehler a nicht 1, 2, 3’)
end
% 2. String einlesen
a=input(’Eingabe: a= eins, zwei, drei, a = ’,’s’) % String Eingabe
switch a
case ’eins’, x=1 a = eins
case ’zwei’, x=2 a = zwei
case ’drei’, x=3 a = drei
otherwise error(’Fehler a nicht eins, zwei, drei’)
end
1.5 Programmerstellung, MATLAB Script und Function

Es wird zwischen Script-File (kurz: Script) und Function-File (kurz: Function) unterschieden.
Beide werden durch den File- bzw. Function-Namen mit der Endung .m gekennzeichnet und
deshalb kurz M-File genannt. Die Bearbeitung des Files erfolgt mit dem M-File-Editor.
Script- und Function-Befehle

% com, %{com %} %% name Kommentar-Zeile, -Block, Cell-Divider (R14)
... Zeilenumbruch innerhalb eines Ausdrucks
help filename zeigt erste Kommentarzeilen des Progammkopfs
eval ( string) Auswertung des Strings string
feval ( F, in_1,..., in_n) Auswertung des Function Handle F
F ( in_1,..., in_n) ab (R14)-Version, feval rückwärtskompatibel
inline ( ’funktion’,’t’,.. ) Inline Function
function [out_1,..] = name ( in_1,.. ) MATLAB Function, Kopfzeile (Definitionszeile)
@ Function Handle (class: function_handle)
nargchk ( min,max,m ) Übergabeparameter-Anzahl m prüfen: min ≤ m ≤ max
isempty ( ’var’ ) Existenz von var prüfen
nargin, nargout Anzahl der Ein- bzw. Ausgangsparameter abfragen
global var var1, clear global var Definition bzw. löschen von Global-Variablen
persistent var Definition persistenter (statischer) Variablen
return Rücksprung aus Function bzw. Script-Abbruch
error ( ’bemerkung’ ) Function-Abbruch mit Ausgabe von bemerkung
clear function_name Löschen der übersetzten Function
⇒ help function, help function_handle, help funfun
1.5.1 MATLAB Editor und Verzeichnispriorität

Wichtige Informationen zum Editieren können mit dem Help Button unter Using the M-File-
Editor der Editor-Menüleiste eingesehen werden. Ein neues M-File (ASCII-Text) ist nach fol-
Bild 1.3: Editor-Fenster, MATLAB 7.12

1.5 Programmerstellung, MATLAB Script und Function 31
gendem Muster zu erstellen.

• Öffnen des MATLAB Editors, Bild 1.1, aus dem Command Window bzw. der Menü-Leiste:
– Eingabe nach dem Prompt: >> edit
– File-Button/Menü: File/New/M-File
– Leerblatt-Button in der Menü-Leiste
• Programmerstellung: Zeilenweise Eingabe der MATLAB-Befehlsfolgen. Das Function-File
erhält eine spezielle Kopfzeile mit dem Schlüsselwort function
• Speichern des Files in das aktuelle oder mit Angabe eines ausgewählten Verzeichnisses aus
der Editor-Menü-Leiste, vgl. Bild 1.3, durch Eingabe des Filenamens (z. B. Ueb.m oder
C:\BMATL\Ueb.m) in die geöffnete Dialogbox:
– File-Button/Menü: File/Save As..
– Disketten-Button
– Save and run- bzw. Run-Button , Bild 1.3. File wird zunächst gespeichert.
Die ersten Programmzeilen eines Script-Files bzw. die bei einem Function-File nach der Defini-
tionszeile mit dem Schlüsselwort function folgenden, sollten Kommentarzeilen z. B. zum Inhalt,
zur Erstellung und Änderung enthalten. Sie werden bis zur ersten MATLAB-Anweisung, u. a.
wie bei allen Built-In Functions, mit help filename oder type filename im Command Win-
dow angezeigt; type filename.m listet das File auf. Sind dem Namen nach bekannte Built-In
Functions zu integrieren, dann kann nach Eingabe des Function Namens mit der Taste F1 ein
Help-Browser mit zugehörigen Details geöffnet werden, vgl. Seite 4.
Eine benutzereigene Toolbar ist unter Desktop/Toolbars/Customize einstellbar.
Bemerkungen zum Verzeichnis bzw. Pfad (Path): Vorausgesetzt ein Benutzerverzeichnis z. B.
C:\BMATL für eine MATLAB-Sitzung sei – entweder aus der Windows- oder MATLAB-Umge-
bung – erstellt, dann wird es mit dem DOS-Befehl cd (Change Directory)
>> cd C:\BMATL % im Command Window
zum aktuellen Verzeichnis; es wird in der Menü-Leiste des Command Windows, vgl. Bild 1.1,
angezeigt und ist für spätere Sitzungen wieder anwählbar. Eine Pfad-Wahl ist auch mit dem
Verzeichnis Button in Bild 1.1 zu treffen.
Verzeichnis- und File-Verwaltung
cd verzeichnis Verzeichniswechsel aus dem Command Window
dir auswahl Liste des Verz.-Inhalts, z. B. dir *.m, alle M-Files
pwd Anzeige des aktuellen Verzeichnisses
path Liste des MATLAB-Path
addpath verzeichnis -begin | -end Übernahme des Pfads verzeichnis in MATLAB-Path,
Position-Optionen für: Listen-Anfang oder -Ende
rmpath verzeichnis Löscht verzeichnis aus MATLAB-Path
what Liste der m-, mat-, mex-Files des aktuellen Verz.
which filename -all Directory-Anzeige von File filename im Suchpfad
lookfor such -all M-File mit such in erster Zeile, -Block im Suchpfad
Das aktuelle Verzeichnis hat nun, bei Suchstrategien z. B. mit dem which Befehl, erste Priori-
tät, es folgen die des MATLAB-Path, in dem sich ursprünglich MATLAB’eigene Files befinden,
z. B. C:\Programme\MATLAB\R2011a\. Wird ein anderes Verzeichnis als aktuelles ausge-

wählt, so ist C:\BMATL nicht mehr in dem Suchpfad enthalten. Dieses kann man ändern, wenn
C:\BMATL dem MATLAB-Path hinzugefügt wird. Diesbezügliche Befehle sind:
• addpath C:\BMATL -begin | -end oder ... -0 | -1

Mit den Optionen -begin | -end wird das neue Verzeichnis an den Beginn oder ans Ende der
Path-Liste gesetzt, path zeigt dies an. Mit
• rmpath C:\BMATL
kann das Verzeichnis wieder entfernt werden.
• File-Button/Menü: File/Set Path...
öffnet ein Fenster, mit dem diese und weiter Verwaltungen zum MATLAB-Path möglich sind,
dies wird auch durch die Befehls-Eingabe von pathtool erreicht.
Der erweiterte MATLAB-Suchpfad wird vom ersten bis zum letzten Listeneintrag nach Functions
oder Files, z. B. mit while filename und nach Ausdrücken u. a. in der Kopfzeile (H1 Line) der
M-Files mit lookfor ausdruck, durchsucht. Dies erklärt auch die Option -begin | -end.
1.5.2 Datenein- und Ausgabe

Ein- und Ausgabebefehle, Konvertierung
disp ( string ) Textausgabe, z. B. string=’Ausgabe’
disp ( variable ) Unformatierte Datenausgabe
num2str ( variable , format ) Konvertiert Real-Variable in String
int2str ( variable) Konvertiert Integer-Variable in String
variable= input ( string ) Einlesen der Variablen variable
string = input ( string, ’s’ ) Einlesen des Strings string
pause ( zeit ) Pause bis Tastenbetätigung/Zeitablauf
fprintf ( fid, format-string, variable ) Datenausgabe u. a. in ASCII-Datei
sprintf ( format-string, variable ) formatierte String-Ausgabe; ANSI C
fid = fopen ( datei.endung, write / read ) Datei öffnen
fclose ( fid ) Datei schließen, fid Datei-Identität
tic operationen toc Rechenzeit zwischen tic → toc in Sek.
Genaue Angaben zu den Konvertierungs-Symbolen u. a. d, e, f, s,.. und den speziellen For-

matierungshilfen \n, \r, \t,.. im format-string sind unter doc fprintf und help fprintf
nachzulesen. Alle File-Eingabe- und -Ausgabe-Functions finden wir mit: help iofun.
Aus- und Eingabe-Beispiele

>> format long e; a=12.34567890; % Format / Daten
>> disp(a) % unformatierte Ausgabe
1.234567890000000e+001
>> fprintf(’%3.5f\n’,a) % formatiert mit Übergang \n in neue Zeile

12.34568
>> fprintf(’%s %3.2f\n’,’mit Variablenzuweisung a = ’,a)
mit Variablenzuweisung a = 12.35
>> sprintf(’%3.2e’,a) % Ausgabe als Character bzw. String

ans =
1.23e+001 % class char, endgültige Ausgabe mit disp
>> disp([’a = ’,num2str(a,’%3.2f’)]) % [...] beachten; oder

>> disp([’a = ’,num2str(a,4)]) % oder
>> disp([’a = ’,sprintf(’%3.2f’,a)])
a = 12.35
>> % Ausgabe mit Text in Hochkomma, ’ -> ’’

>> disp([’’’Ergebnis: ’’, a = ’,num2str(a,’%3.2f’)])
’Ergebnis: ’, a = 12.35
Ein typisches Programmsegment mit einer Aufforderung zur Tastatureingabe und einer an-
schließenden Überprüfung dieser Eingabe, siehe auch newton_sys.m in [52], folgt in:
disp(’vgl. Programm: newton_sys.m der Programmsammlung im www’)

disp(’ ’) % Leerzeile
beispiel=input(’Beispiel 1 oder 2 ? ’); % Eingabeaufforderung
if isempty(beispiel) || beispiel > 2 || beispiel < 1,
disp([’Eingabe-Fehler: beispiel = ’,num2str(beispiel)]),
return % Prog. beenden
end
Für disp([’Eingabe-Fehler:.. kann auch die Function error([’Eingabe-.., die

gleichzeitig das Programm beendet, verwendet werden.
Abschließend legen wir ein Text-File mit zunächst erzeugten Daten an:
>> t=0:pi/2:2*pi; x=[t; sin(t)]; % Datenerzeugung

>> fid = fopen(’Text_File.text’,’w’); % Datei öffnen, fid Ident.
>> fprintf(fid,’%3.6f %10.6e\n’,x); % formatierte Ausgabe
>> fclose(fid); % Datei schließen
– vgl. auch save, load. Den Inhalt des Files Text_File.text zeigen wir mit dem Editor –
z. B. >> edit Text-File.text – an:
0.000000 0.000000e+000
1.570796 1.000000e+000
3.141593 1.224647e-016
4.712389 -1.000000e+000
6.283185 -2.449294e-016
1.5.3 MATLAB Script

Ein Script-File ist ein Programm mit MATLAB-Anweisungen, siehe Bild 1.3. Ein Script-File kann
auf Daten des Workspace zugreifen und legt erzeugte Daten dort ab. Sie sind nach Programm-
Ablauf verfügbar und können somit zur Datenkontrolle abgerufen oder zur grafischen Ausgabe
weiterverarbeitet werden. D. h. die Variablen sind global.
Script-Files enthalten keinen Deklarationsteil und keine Abgrenzung durch begin / end.
Kommentare sind zeilenweise durch vorangestelltes % zu kennzeichnen. Ab MATLAB 7 wird
eine Block-Kommentierung – eingeschlossen durch %{.. Block ..%} –, ähnlich der C-Verein-
barung, möglich; %{ und %} stehen alleine in separaten Zeilen. Ein Zeilenumbruch innerhalb
eines Ausdrucks wird durch die Punktfolge ... erreicht, z. B.: 5+6-... und 5+6 ... –
Leerzeichen beachten. Scripts können von anderen Scripts aufgerufen werden.
Messbar ist die Rechenzeit einer Befehlsfolge u. a. innerhalb der Zeitmarken tic....toc. Die
Function tic speichert den Startzeitpunkt, toc ermittelt die Rechenzeit. Mit return kann eine Pro-
grammausführung vorzeitig beendet werden.
Die Ausführung (Start) eines zuvor gespeicherten M-Files aus dem Command Fenster erfolgt
durch Eingabe des File-Namens ohne Endung (.m) oder mit dem Run- Button in der Editor-
Menü-Leiste nach Bild 1.3.
Ab MATLAB 7 (R14) stehen zusätzliche nennenswerte Tools zur Programmentwicklung zur
Verfügung. Ausführliche Information findet man im Help Browser unter MATLAB/Release
Notes/New Features und in den Video-Demos, z. B. The Editor. Zum einen lässt sich
Bild 1.4: Editor mit eingeblendeter Cell-Toolbar und Programmstruktur unter MATLAB 7.12
der Programm-Code in Programmsegmente so genannte Zellen (Cells) unterteilen, vgl. [26]. Jede
Zelle beginnt, wie in Bild 1.4, mit einem doppelten Prozentzeichen %% (Cell divider) und einem
Zell-Titel. Die Zelle selbst enthält mehrere Anweisungen. Zur Ausführung des Programms muss
die zugehörige Menüleiste über den Editor-Button Cell, Menüpunkt Enable Cell Mode ein-
geblendet werden. Steht danach der Cursor in der Titelzeile, z. B. Start wie in Bild 1.4, so ist
der Programmabschnitt bis zum nächsten Zellteiler %% farbig (gelb) unterlegt. Durch Betätigung
des Button Evaluate cell and advance wird dieser Programmabschnitt ausgeführt und
die nachfolgende Zelle angesprungen. Mit dem Button Evaluate cell wird nur die angewählte
Zelle ausgeführt. Die abschnittsweise berechneten Daten und Grafiken können, z. B. im Com-
mand Fenster oder im Variable Editor, auf ihre Richtigkeit überprüft und Fehler korrigiert
werden, vgl. Hinweis Seite 6. Ein kompletter Programmdurchlauf erfolgt mit dem Run-Button
der Editor-Menü-Leiste. Beispielprogramm: Cell_structure.m in [52].
Mit File/Publish filename wird der Code eines Scripts einschließlich der Ergebnisse und
Grafiken in ein HTML-Dokument konvertiert und im Web Browser angezeigt. Über View/Page
Source wird der HMTL Source Code eingeblendet. Besitzt das Script Cell-Struktur, wie z. B.
Cell_structure.m in [52], dann wird zusätzlich ein Inhaltsverzeichnis mit den Links der
Cell-Titles angelegt. Die Zellen enthalten nun den Cell-Title, den Programmcode und die Ergeb-
nisse.
Zum anderen existiert ein Code Analyzer, der unter dem Tools-Button mit dem Menü-Punkt
Show Code Analyzer Report gestartet wird. Es wird ein Report erstellt, in dem Hinweise
auf mögliche Fehler aufgelistet sind. Ab (R2006a) wird damit die Programmerstellung fortlau-
fend kontrolliert und mit Farbkennung auf mögliche Fehler hingewiesen, siehe Bild 1.3.
Darüber hinaus ist ebenfalls unter Tools ein Profiler zu öffnen (Open Profiler). Er
unterstützt die Verbesserung der Code-Performance, vgl. Abschn. 1.5.5.
Mit der Desktop-Architektur ab (R14) ist auch ein An- und Ausdocken u. a. des Editor-Fensters
in den Desktopbereich mit dem Button: im Editor-Kopf nach Bild 1.3 möglich. Dadurch sind
die wesentlichen Arbeits-Fenster in einer Ebene verfügbar.
Beispiel zur Programmerstellung: Es soll ein M-File zur Darstellung eines Kreises vom
Radius r geschrieben werden. Zu definierten Winkeln aus dem Intervall 0 ≤ Θ ≤ 2π sind da-
für die kartesischen Koordinaten x, y zugehöriger Kreispunkte zu berechnen, womit der Kreis
grafisch darzustellen ist; Plot-Befehle siehe Abschn. 1.6.2.
r=1; % Kreisradius
theta=linspace(0,2*pi,100); % Winkelfolge
x=r*cos(theta); % x-Koordinate
y=r*sin(theta); % y-Koordinate
plot(x,y) % Kreisdarstellung
axis(’equal’) % Achs-Skalierung, auch: axis equal
title([’Kreis vom Radius r=’,num2str(r)])
Das Programm speichern wir mit dem Namen kreis.m in das aktuelle Verzeichnis, vgl.
[52]. Der Start erfolgt z. B. mit der Eingabe von kreis in das Command Window. Nach der
Ausführung stehen alle Variablen r, theta, x, y im Workspace.
Sind Kreise unterschiedlicher Radien zu zeichnen, so ist r in der ersten Programmzeile stets
neu zuzuweisen bzw. einzulesen: r=input(’r = ?’);. In jedem Fall ist es sinnvoller für die
obige Befehlsfolge eine Function mit der Eingangsvariablen r zu schreiben. Dies zeigen wir im
folgenden Abschnitt.
1.5.4 MATLAB Function

Zwei Function-Typen unterscheiden wir. Erstens Functions die in einem M-File stehen und zwei-
tens solche, die in einer Command- oder Script-Zeile ausgewertet werden. Zum ersten Typ zählen
die traditionellen Standard-Functions und die ab MATLAB 7 neuen Nested (eingebettete) Func-
tions. Zum zweiten Typ, diejenigen die eine in String gefasste Funktion auswerten und die in
MATLAB 7 neu aufgenommenen Anonymous Functions.
1.5.4.1 Standard-Function und Function Functions

Für eine standardmäßige Unterprogrammstruktur stehen die sog. MATLAB Functions (Schlüssel-
wort function) zur Verfügung, es ist ebenfalls ein M-File. Bis auf die Ausgangsvariablen sind alle
vorkommenden Variablen lokale Variable und stehen somit nicht im Workspace. Der Function-
Kopf hat die Struktur
function[ausgangsvariablen] = function_name(eingangsvariablen)
function_name und File-Name sollten identisch sein. Ein zusätzlicher Variablenaustausch
kann mit der global-Vereinbarung
global variable_1 variable_2, Anzeige: who/whos Attributes global
erfolgen. Diese Vereinbarung muss gleichzeitig in dem M-File (Skript, Hauptprogramm), in der
die Function aufgerufen wird, stehen; d. h. die aufgeführten Variablen müssen vor dem Function-
Aufruf als globale Größen im Workspace stehen, vgl. wurf.m, S. 283.
Darüber hinaus können in einer Function persistente Variable mit
persistent variable_1 variable_2
vereinbart werden. Im Gegensatz zu den global vereinbarten Größen, sind die persistenten Größen
nur in der Function, in der sie deklariert werden, bekannt; es kann also keine andere Functions
darauf zugreifen. Persistente Variable werden nur gelöscht, wenn die Function aus dem Speicher
entfernt wird (clear function_name) oder die Function geändert und danach abgespeichert wird.
Programmbeispiel: fcnPersist.m und Basis_Elemente.m in [52].
Anhand zweier Beispiele wollen wir die Handhabung mit Functions erläutern.
Beispiel 1: Zunächst sollen, entsprechend dem besprochenen Script zur Kreiserzeugung, jetzt
Kreise unterschiedlicher Radien r gezeichnet werden; es bietet sich eine Function-Formulierung
an. Der Eingangsparameter ist r, als Ausgänge wählen wir die kartesischen Koordinaten x, y;
Plot-Befehle siehe Abschn. 1.6.2. Die Function mit dem Namen fkreis kann wie folgt aufge-
baut sein:
function [x,y]= fkreis(r) % Function-Kopf
theta=linspace(0,2*pi,100); % Winkelfolge
................ wie oben, d.h. wie in kreis.m
title([’Kreis vom Radius r=’,num2str(r)])
Der Aufruf aus dem Command Window oder einem M-File kann ohne oder mit Ausgabe der
kartesischen Koordinaten erfolgen:
>> fkreis(2); % zeichnet Kreis mit r=2, keine Ausgänge
>> [x,y]=fkreis(4); % mit Übergabe von x, y; Workspace-Daten
>> [~,y]=fkreis(4); % mit Übergabe von y; Workspace-Daten
oder mit Function Handle func_h, vgl. u. a. auch Function eulerApprox:

>> func_h=@fkreis % Function Handle
>> [x,y]=feval(func_h,2); % Function evaluation bis MATLAB 6.5..
>> [x,y]=func_h(2); % ab MATLAB 7
Die Befehle nargin, nargout (number of function input, output arguments), können zur Kon-
trolle der Ein- und Ausgangsargumente oder zur Steuerung des Programmablaufes eingesetzt
werden. Wir zeigen dies unten mit der modifizierten Function fkreis; vgl. fkreis_Rr.m in
[52]. Es lassen sich sowohl einfache Kreise mit den Radien R als auch zusätzliche Innenkreise
mit den Radien r < R zeichnen. Dazu muss die Anzahl der Ein- und Ausgangsargumente variiert
werden. Mit R als Eingang wird ein einzelner Kreis, mit R, r ein zusätzlicher Innenkreis bearbei-
tet. Die Rückgabe-Matrizen V R , V r enthalten spaltenweise die kartesischen Koordinaten x, y, es
können wahlweise beide oder nur V R ausgegeben werden.
function [VR,Vr]= fkreis_Rr(R,r) % Außen- (R), Innenkreise (r)
theta=linspace(0,2*pi,100)’; % Winkelfolge
VR=R*[cos(theta) sin(theta)]; % x-, y-Koordinaten für R
plot(VR(:,1),VR(:,2)), axis(’equal’)% Plot des Kreises
if nargin == 1 && nargout == 2 % einzelner Kreis, Radius R
Vr=[]; % Leer-Matrix
return % Rücksprung u.a. ins M-File
elseif nargout <= 2 && nargin == 2 % Außen- u. Innenkreis
Vr=r*[cos(theta) sin(theta)] % x-, y-Koordinaten für r
hold on, plot(Vr(:,1),Vr(:,2)), hold off % Innenkreis zeichnen
end
Aufruf, z. B.: [VR,Vr]=fkreis_Rr(2,1) oder [VR]=fkreis_Rr(2,1), .....
Beispiel 2, Function Functions Formulierung: Es soll der Differenzialgleichungstyp erster

Ordnung
ẏ = f (t, y)
mit Hilfe der E ULER-Approximation mit fester Schrittweite h nach Bild 1.5 näherungsweise be-
rechnet werden. Dabei ist es zweckmäßig, wie in Bild 5.8, neben dem Hauptprogramm bzw.
exakte Lösung
y 6 e
ẏk−1 Differenzialgl.: ẏ = f (t, y) , Lösung y(t)
d Approximation: yk = yk−1 + h f (tk−1 , yk−1 )
yk
yk−1 Definition: tk := kh, yk := y(tk ), k = 0,1,2, ..
- Beispiel: ẏ = 1/y, (·) = d /dt
h - √
t exakte Lösung: y = 2t + 1
tk−1 tk
Bild 1.5: E ULER-Approximation
Script (dgl.m) eine Function (fdgl.m) für die zu bearbeitende Differenzialgleichung ẏ =

1/y und eine Function zur problemunabhängigen Approximationsmethode (eulerApprox.m)
– hier: E ULER-Vorwärtsverfahren nach Bild 4.3 – für beliebige rechte Seiten f (t, y), einzurich-
ten.
Schreiben wir fest, dass die diskreten Zeitpunkte tk und die zugehörigen Funktionswerte
yk := y(tk ) als Ergebnisse ins Hauptprogramm dgl einfließen sollen, dann müssen dies Aus-
gangsparameter von eulerApprox.m sein. Ferner ist zu bedenken, dass in die Approximation
nach Bild 1.5 zu jedem Integrationsschritt k die Ableitungsfunktion ẏk−1 = f (tk−1 , yk−1 ) der zu
integrierenden Differenzialgleichung, sie soll in der Function fdgl.m stehen, zu berechnen ist.
Dies geschieht durch den Aufruf von fdgl in eulerApprox, wenn ẏk−1 Ausgangsgröße ist. In
diesem Fall muss die Function fdgl, repräsentiert durch das zugehörige Handle func=@fdgl,
Eingangsargument von eulerApprox sein; vgl. Integratoraufruf im Hauptprogramm. Darüber
hinaus muss das Integrationsintervall z. B. aus Anfangs- und Endzeitpunkt (ta , te ), der Anfangs-
wert (y0 = y(ta )) sowie die Schrittweite h als Eingangsgrößen definiert werden. Selbstverständ-
lich brauchen die Bezeichnungen des aktuellen Aufrufs von eulerApprox.m in dgl.m nicht
mit denen der Integrationsroutine eulerApprox übereinstimmen. Um die allgemeine Gültig-
keit dieser Function deutlich zu machen, führen wir andere Bezeichnungen ein:
function [x,y]=eulerApprox(func,startx,endx,starty,h)
x=startx:h:endx; y=0*x; y(1)=starty(1);
for i=2:length(y)
% y(i)=y(i-1) + h * feval(func,x(i-1),y(i-1)); % MATLAB ...6.51
y(i)=y(i-1) + h * func(x(i-1),y(i-1)); % MATLAB 7
end
Da eine Eingangsgröße wieder eine Function (func) ist, spricht man von Function Func-
tions, deren Aufruf in der Function Regeln unterliegt, vgl. newton_Sys.m in [52]. Bis zur
Version 6.5.1 erfolgte der Aufruf mit der feval Formulierung, dies wurde mit MATLAB 7 geändert.
Beide Formen sind in der obigen Function eulerApprox gegenübergestellt.
Die von eulerApprox aufgerufene Function fdgl der Dgl. ẏ = 1/y, in der die Ableitungs-
funktion (ẏ) näherungsweise berechnet wird, hat die einfache Form:
function [yp] = fdgl(t,y) % da eine Ausgangsv. auch: function yp=..
yp = 1/y; % Differenzialgleichung
Die Ableitungsfunktion ẏ → yp wird an eulerApprox übergeben und yk berechnet. Schließ-

lich ist für die Integration von ẏ = 1/y das Hauptprogramm als Script-File (hier: dgl.m) mit der
Parameterinitialisierung, dem Aufruf der Integrations-Function und der grafischen Darstellung
der Ergebnisse zu schreiben. Da die exakte Lösung bekannt ist, können wir einen Approximati-
onsfehler angeben. Programm dgl.m, siehe auch [52], Plot-Befehle Abschn. 1.6.2:
%---- Hauptprogramm % dgl.m
ta=0; te=20; % Startwert, Endwert
h=(te-ta)/20; % feste Schrittweite
y0=1.; % Anfangswert
[t,y]=eulerApprox(@fdgl,ta,te,y0,h);% Integrations-Aufruf
y_exakt = sqrt(2*t+1); % bekannte exakte Lösung
figure(1) % grafische Auswertung
subplot(221) % Grafik 1
plot(t,y,t,y_exakt,’r.’), xlabel(’t’), ylabel(’y, y_{exakt}’)
subplot(222) % Grafik 2
plot(t,abs(y-y_exakt)), xlabel(’t’), ylabel(’abs(y-y_{exakt})’)
Der Datenaustausch mit dem Script und den Functions ist in Bild 5.8 veranschaulicht. In
Bild 1.6 sind die Simulationsergebnisse dargestellt.
1.5.4.2 Nested Function

Nested Functions sind eingebettete Functions, die innerhalb einer anderer Function, der Parent
Function, angeordnet sind und mit ihr als M-File gespeichert wird. Der Aufruf erfolgt meist aus
einem M-File seltener aus einer Command Zeile. Die Parent Function haben Zugriff auf den
Parent Function’s Workspace. Abgeschlossen wird jede Nested Function und die übergeordnete
7 0.35
6 0.3
0.25
abs(y−yexakt)
5
y, yexakt
0.2
4
0.15
3
0.1
2 0.05
1 0
0 5 10 15 20 0 5 10 15 20
t t
Bild 1.6: Trajektorien und Integrationsfehler, – Approximation, · · · exakte Lösung
Parent Function mit einem end. Dies unterscheidet diesen Function-Typ von den traditionell ver-
wendeten Standard-Functions. Wir erläutern dies am Beispiel der N EWTON-Iteration von S. 29.
Die Parent Function sei newton_par.m – siehe [52] –, die Nested Function newton_it, sie
enthält die N EWTON-Methode.
function y = newton_par(startwert,tol) % Parent Function
% Ermittelt iterativ die Loesung ausgehend von y=startwert
ab=1; % 1. Abbruch-Vergleichswert
Imax=100; I=1; % max. Iter., 1. Iter.-Schritt
y=newton_it; % Aufruf ohne Parameter-Uebergabe
%
function y=newton_it % Nested Funct. fuer NEWTON-Iter.
y=startwert; % Startwert-Umbenennung
y0=y; % Datensicherung
y=y0-(0.5-y+0.2*sin(y))/(-1+0.2*cos(y));
ab=y-y0; % Loesungsaenderung
I=I+1; % Iterations-Schritt
end % end While-Schleife
end % end Nested Function
end % end der Parent Function
Die Nested Function newton_it kann auf die Variablen des Parent-Function’s Workspace
(hier von: startwert, ab, tol, Imax, I) zugreifen und sie verändern. Dies macht den Da-
tentransfer zwischen mehrfach geschachtelten Functions (multiple nested functions) einfach. Wir
können die Function in gewohnter Weise aufrufen, z. B. für startwert=3 und tol=1e-6:
>> y=newton_par(3,1.0e-06)
y =
6.1547e-001
Die Fähigkeit von Nested Functions auf den Parent’s Workspace zuzugreifen ermöglicht eine
übersichtliche Kontrolle der eingehenden Variablen, vgl. u. a. fmetro.m, GTräger.m in [52].
Insbesondere, wenn sie in mehrfach geschachtelte Functions eingehen. Der unangenehme Effekt
einer unkontrollierten Überschreibung von mit global vereinbarten Variablen entfällt. Darüber
hinaus wird der Speicherbedarf bei gemeinsamer Nutzung großer Datensätze reduziert.
Das obige Beispiel ließe sich auch mit einer traditionellen Function erzielen und bietet so-
mit keinen wesentlichen Vorteil. Dies sieht anders aus, wenn wir die Struktur – siehe auch
newton_parent.m in [52] – geringfügig ändern, vgl. Zeile 1, 5, 6, 11:
function y = newton_parent(tol) % Parent Function
% Ermittelt iterativ die Loesung ausgehend von y=startwert
ab=1; % 1. Abbruch-Vergleichswert
Imax=100; I=1; % max. Iter., 1. Iter.-Schritt
y=@newton_it; % Funct.-Handle y bez. newton_it
function y=newton_it(startwert) % Nested Funct. fuer NEWTON-Iter.
y=startwert; % Startwert-Umbenennung
................ wie oben
end % end While-Schleife
ab=1; I=1 % müssen zurückgesetzt werden
end % end Nested Function
end % end der Parent Function
Wird newton_parent aufgerufen, dann wird das Function Handle y bezüglich der Nes-
ted Function newton_it zurückgegeben, welcher individuell gemäß der Parameterübergabe
– hier: tol=1e-7 bzw. tol=1e-2 – der übergeordneten Function (Parent Function)
newton_parent angelegt ist, z. B.
>> y1 = newton_parent(1.0e-07); % Handle y1 für tol=1e-7
>> y2 = newton_parent(1.0e-02) % Handle y2 für tol=1e-2
y2 =
@newton_parent/newton_it
Wir können jetzt, wie bisher, diese individuellen Functions z. B. für die Startwerte 3 und 6
auswerten.
>> y1(3) % Rechnung mit tol=1.0e-07
ans =
6.154681694899654e-001
>> y2(6) % Rechnung mit tol=1.0e-02
ans =
6.154681876614523e-001
In diesem Fall werden einige Variablen der Parent Function nur einmal zugewiesen bzw. be-
rechnet, was u. a. bei komplexeren Ausdrücken Vorteile bietet. Dies entspricht der Vereinbarung
als persistente Variablen.
Bemerkung: Da die beiden Variablen ab, I in der Nested Function verändert werden, müssen
sie vor dem Verlassen der Function auf die ursprünglichen Werte zurückgesetzt werden. Ohne
diese Rücksetzung müssen die Function Handles nach jeder Ausführung neu erzeugt werden, um
den Ausgangszustand wieder herzustellen.
Beispiele mit unterschiedlichen Function-Formulierungen sind im M-File Function_Cre-
ation.m der Programmsammlung [52] zu finden. Darin sind neben den größeren Textpassagen
die Befehlszeilen enthalten, so dass einerseits Ergebnisse im Command Fester und andererseits
Grafikausgaben verfolgt werden können. Das M-File ist in Zellen (Cells) unterteilt, so dass ausge-
wählte Programmabschnitte (Zellen) mit dem Button in der Editor-Kopfzeile gestartet werden
können – vgl. Kommentarzeilen im M-File. Zuvor sind die gekennzeichneten Functions in das
aktuelle Verzeichnis zu kopieren. Ein HTML-Dokument kann erstellt werden, vgl. S. 34.
1.5.4.3 String-Auswertung und Anonymous Function

Die folgenden Function-Typen dienen der Formulierung einer Function in einer Command-Zeile
oder in einem M-File ohne dafür ein eigenes File anzulegen. Wir führen drei Typen beispielori-
entiert auf:
• Der eval-Befehl (evaluation) – vgl. newtone.m in [52] –
Syntax: [u,v,w,...] = eval(string) liefert Ausgangsargumente u, v, w,... des
String-Ausdrucks string.
>> x=’1/y*sin(y)’; % String-Ausdruck, vgl. newtone.m
>> y=0.875; % Wertzuweisung
>> a=eval(x) % Ausführung des String-Ausdrucks
a =
8.771925739840309e-001
• Die inline Function – vgl. newton_sys.m in [52] –
Syntax: inline(expr) erzeugt ein inline function object des String-Ausdrucks expr.
>> g=inline(’5*a+7*sin(b)’) % g ist Function Handle oder
>> g=inline(’5*a+7*sin(b)’,’a’,’b’) % a, b Eingangsvariablen
g =
Inline function:
g(a,b) = 5*a+7*sin(b)
>> c=0:2; b=pi/4; % neue Variablen eingeführt

>> z=g(c,b) % c -> a, Ausführung der Funct.
z =
4.9497e+000 9.9497e+000 1.4950e+001
Da g Function Handle, gilt auch: z=feval(g,c,b).
• Die Anonymous-Function (ab R14) – vgl. newtona.m, newton_sys.m und insbesondere

Function_Creation.m bzw. Function_Creat.pdf in [52].
Syntax: fhandle = @(argumliste) Ausdruck
>> om=5; % Variablenzuweisung
>> f = @(y) cos(om*y); % Function-Formul. class: function_handle
>> t=linspace(0,2*pi/om); % Zeitfolge
>> f(t); % Auswertung der Function, f=cos(om*t)
Im Beispiel zur numerischen Integration mit der E ULER-Methode S. 37 kann die Function
fdgl.m der zu bearbeitenden Differenzialgleichung ẏ = 1/y durch eine Anonymous Function
im Hauptprogramm ersetzt werden:
fdgl = @(t,y) 1/y; % Function Handle der Dgl.
[t,y] = eulerApprox(fdgl,ta,te,y0,h); % Integrator-Aufruf
Die Anonymous Function löst insbesondere den Typ inline sowie die Auswertung mit dem
feval-Befehl von Function in einer Function, wie auf S. 38, ab.
1.5.5 Code-Beschleunigung, der Profiler
Maßnahmen zur Code-Beschleunigung und/oder -Verbesserung werden bereits im Editor durch

farbige Hinterlegung an den entsprechenden Stellen angezeigt. Diese Hinweise erhält man auch
im Code Analyzer Report, der aus der Editor-Menü-Leiste unter: Tool/Code Analyzer
Show Code Analyzer Report oder durch Eingabe von » mlintrpt(’filename’) ge-
öffnet wird. Mit » mlint(’filename’) erscheint diese Information im Command Window.
Der MATLAB Profiler liefert eine ausführliche Programmanalyse mit Angaben zur Rechenzeit,
Anzahl der Aufrufe usw. Damit können Auswirkungen einer schrittweisen Code-Änderung ver-
folgt werden. Dies soll wie in [25] an dem Programm-Code zur Berechnung eines Mandelbrots
nach http:/www.students.tut.fi/∼warp/MandScript/ erfolgen:
1 clear
2 xmax=2;
3 steps=2000; % und 500
4 maxiter=32;
5 for m=1:steps
6 for n=1:steps
7 c=-xmax+2*xmax*n/steps-.5 + i*(-xmax+2*xmax*m/steps);
8 z=c;
9 for r=0:maxiter
10 z=z*z+c;
11 if abs(z)>2 break
12 end
13 end
14 Z(m,n)=sqrt(r/maxiter);
15 end
16 end
Dieser Code (mandelbr1.m aus [52]) ist einerseits aus der Command-Zeile mit
>> profile on, Mandelbr1, profile report
andererseits aus dem Profiler-Fenster, welches durch Eingabe von
>> profile viewer
bzw. mit dem Menü Tool/Open Profiler des Editors geöffnet wird, zu starten. Das Ergeb-
nis wird im Profiler-Report angezeigt. Er enthält u. a. die Gesamtrechenzeit (hier: T1 ≈ 55 s für
2000 Steps), eine Liste (Lines where the most time was spent) mit den rechenintensivsten Zeilen,
den Analyzer Report sowie eine Programmliste (Function Listing) mit den vorangestellten Spal-
ten
time: benötigte Rechenzeit, calls: Anzahl der Aufrufe, line: Zeilennummer,
wobei Zeilen u. a. bezüglich der Rechenzeit (Einstellung: time), der Anzahl maximaler Aufrufe
(numcalls) oder der Analyse (code analyzer) farbig hervorgehoben werden. Danach benötigt die
Zeile 14 76%, die anderen zwischen 8% und 3% der gesamten Rechenzeit.
Wir wollen zunächst den Einfluss der im Analyzer Report angegebenen Vorschläge:
auf die Rechenzeit untersuchen. Da i mit einer Built-In Function ermittelt wird, kommt es in
der for-Schleife zum wiederholten Aufruf dieser Function. Um dies zu umgehen, kann man
einerseits nach Zeile 4
i=sqrt(-1); % einmaliger Aufruf, Variablen-Zuweisung
oder andererseits, wie vorgeschlagen, in Zeile 7 i durch 1i ersetzen. Wir wählen die zweite
Möglichkeit, wie in mandelbr2.m. Nach einem Neustart aus dem Profiler-Fenster ergibt sich
kaum eine Reduzierung der Rechenzeit im Gegensatz zu früheren MATLAB-Versionen.
Als weitere rechenzeitreduzierende Maßnahme bietet sich das Präallozieren; vgl. S. 28, des
erforderlichen Array-Speicherplatzes von Z mit
Z=zeros(steps);
– File mandelbr3.m – an. Die Rechenzeit reduziert sich auf T3 ≈ 14.2 s für steps=2000.
Bei kleineren Arrays, z. B. für steps=500, ist der Zeitgewinn minimal.
Schließlich führen wir eine rein reellwertige Rechnung durch. Hierzu sind die komplexen
Ausdrücke in Real- und Imaginärteile zu zerlegen; vgl. Programm-Code mandelbr4.m in [52].
Diese Vorgehensweise ist ziemlich ungewöhnlich und macht den Code äußerst undurchsichtig.
Es zeigt sich aber, dass die Berechnung mit reellen Ausdrücken gegenüber komplexen ab MAT-
LAB 6.5 erheblich schneller abläuft: T4 ≈ 6.6 s für steps=2000.
Gegenüberstellung der Rechenzeiten: Im Bild 1.7 sind die bezogenen Rechenzeiten für
steps=2000 und steps=500 gegenübergestellt. Die Rechenzeiten sind jeweils auf die von
mandelbr1.m, also dem Ausgangs-Code, bezogen. In beiden Fällen ist insgesamt eine Re-
chenzeitreduzierung von ca. 90 % bzw. ca. 60 % erreicht worden. Bemerkenswert ist der star-
ke Einfluss einer reellwertigen Rechnung mit erheblich mehr Rechenoperationen gegenüber der
komplexen Formulierung.
Bild 1.7: Gegenüberstellung der Rechenzeiten
Zusammenfassung: Der Profiler unterstützt den Programmierer, einen bezüglich der Rechen-
zeit ausgereizten Code zu erzeugen. Wichtig ist dennoch einen gut strukturierten und damit leicht
nachvollziehbaren Code zu schreiben, wobei übliche programmiertechnische und zeitreduzieren-
de Maßnahmen, u. a. präallozieren des Speicherplatzes eines Arrays, beachtet werden sollten.

Nach wie vor ist dabei die Vektorisierung ein effektives Hilfsmittel.
1.6 Grafik
Visualisierung von Ergebnissen als 2D- und 3D-Grafiken trägt maßgeblich zur Veranschauli-
chung der untersuchten Vorgänge bei. MATLAB bietet diesbezüglich vielfältige Möglichkeiten.
Wir werden, bezogen auf die Buchthemen, einige Grundlagen zur grafischen Darstellung präsen-
tieren. Erweiterungen sowie Grafik-Beispiele in [41], [53], [57] und insbesondere die MATLAB-
Demo-Beispiele abrufbar im Help Browser , vgl. Bild 1.1, unter MATLAB Demos → Graphics
liefern zusätzliche Anregungen.
Bild 1.8: Vereinfachte Grafik-Objekt-Hierarchie mit Core Objects
Um die im Folgenden eingeführten Objekt-Eigenschaften und ihre Zuordnung besser zu ver-

stehen, gehen wir zunächst kurz auf die Grafik-Strukturierung ein. Die MATLAB-Grafik besitzt
einen objektorientierten Aufbau mit der Hierarchie für die Core Graphics Objects nach Bild 1.8.
Danach besitzt ein eindeutiges Eltern-Objekt (Parent) beliebig viele Kind-Objekte (Children).
Das einzige Grafik-Objekt Root korrespondiert mit dem Bildschirm und besitzt als Eltern-Objekt
die Kind-Objekte Grafik-Fenster (Figure) – umfasst alle erzeugten Fenster. D. h. sollen Eigen-
schaften aller Grafik-Fenster, z. B. die Linienstärke der Grafen, gegenüber den Standardwerten
geändert werden, dann kann dies nur durch das Root-Objekt – Kennung 0 – erfolgen. Jedes
Figure-Objekt ist wiederum Eltern-Objekt zum Axes-Objekt (Koordinatensysteme) als Kind,
es enthält die eigentlichen Grafik-Objekte. Letztendlich sind dem Axes-Objekt u. a. die Kind-
Objekte: Image, Light, ....., Text – auch als Kern-Objekte bezeichnet – zugeordnet. Die vollstän-
dige Hierarchie ist im Help Browser unter Handle Graphics / Object Properties einzusehen.
In der Root-, Figure- und Axes-Ebene sind nach dem Start von MATLAB Standardwerte fest-
geschrieben, sie können beispielhaft für die Line-Objekte mit:
set(0,’DefaultLinePropertyName’,PropertyValue,...)
set(gcf,’DefaultLinePropertyName’,PropertyValue,...)
set(gca,’DefaultLinePropertyName’,PropertyValue,...)
neu gesetzt werden. Groß- und Kleinschreibung dient nur der Übersichtlichkeit. PropertyName
ist der Name der Line-Eigenschaft – LineWidth, Color, usw. – und PropertyValue ist der zu spe-
zifizierende Wert, z. B. für die Linienstärke. Mit ’DefaultAxesPropertyName’ sind die
Axes-Eigenschaften usw. in den oberen beiden Anweisungen (0, gcf) anzusprechen.
Beispiel: Die bezüglich der Root-Ebene (0) festgeschriebenen Standardwerte, u. a. für die
1.6 Grafik 45
Bildschirmausgabe das Ausgabe-Format shortE und für die Grafik die Linienstärke sowie
Linienart-Reihenfolge (LineStyleOrder) bei mehreren Grafen aller angelegten Figure, kann
mit get – z. B. get(0,’DefaultTextFontName’) für die Schriftart – abgefragt und nach
Bedarf mit set geändert werden, wie in:
>> get(0,’format’) % Format-Abfrage
ans = % z. B.
shortE % vorhandenes Format
>> set(0,’format’,’longE’) % es geht einfacher!
>> get(0,’DefaultLineLineWidth’) % Linienstärke ?
ans =
5.000000000000000e-001
>> set(0,’DefaultLineLineWidth’,1) % Linienstärke geändert
>> get(0,’DefaultFigureColor’); % FigureColor abgefragt
>> set(0,’DefaultFigureColor’,[0.5 0.5 0.5]) % FigureColor gesetzt
>> set(0,’Default...’,’remove’) % Standardeinstellung
Mit der Anweisung der letzten Zeile wird die Standardeinstellung wieder hergestellt. Über-
sichtlicher ist die Berücksichtigung ausgewählter Eigenschaften, z. B. LineWidth, FigureColor,
direkt am einzelnen Objekt Line, Figure usw. Dies wird in den weiteren Abschnitten gezeigt.
Um nachträglich auf Grafik-Objekte zugreifen zu können, verwendet MATLAB spezielle Va-
riable, das Handles6 . In den beiden obersten Hierarchieebenen sind das ganze Zahlen – Root hat
das Handle 0, Figure die Handles 1, 2, 3,... – bei den übrigen Objekten reelle Zahlen. Zugehörige
Eigenschaften lassen sich somit mit set festlegen oder mit get erfragen. Eine Liste festgeschrie-
bener Eigenschaften (Properties) erhält man mit get(<handle>), mögliche Eigenschaftswerte
(Property Values) werden durch set(<handle>) angezeigt. Ist das Handle eines Objekts nicht
bekannt, kann sie mit findobj konkretisiert werden, siehe Abschn. 1.6.2.3.
Alle im Folgenden behandelten 2D- und 3D-Grafik-Beispiele sowie zusätzliche Experimente
aus Plot_Exp1.m, Plot_Exp2.m, sind im Programm Grafik_Elemente.m mit Zell-
Struktur in [52] zusammengefasst; es kann schrittweise abgearbeitet werden.
1.6.1 Grafikfenster (Figure), Erstellung und Verwaltung

Der Befehl figure erzeugt ein leeres Grafik-Fenster (kurz: Figure), wie in Bild 1.15 ohne Grafik,
mit zugehöriger Nummer. Die Nummer entspricht dem Object Handle, welcher die Eigenschaft
des Fensters beinhaltet. Alle folgenden Grafikbefehle beziehen sich stets auf das aktuelle Grafik-
Fenster.
Das Handle (nummer) der aktuellen Figure erhält man mit gcf. Die aktuelle Einstellung in der
Form: PropertyName, PropertyValue mit get ( gcf ) oder get ( nummer ) bzw. die PropertyValues
ausgewählter PropertyNames z. B. mit get ( gcf, ’Position’); für gcf kann das Handle gesetzt
werden. Z. B. lassen sich Eigenschaften mit
h0= figure(’Units’,’points’, ... % Einheiten, z. B. auch centimeters, pixels
’Position’,[100 100 300 100 ], ... % linke untere Bildecke, Breite, Höhe
’NumberTitle’,’off’, ... % Figure nummer nicht einblenden
’Name’,’name’, ... % name neuer Figure-Name
’MenuBar’,’none’) % Menü-Leiste ausblenden
6 Handle Graphics eingetragenes Warenzeichen von The MathWorks Inc.

ändern oder setzen und bei Bedarf mit set(h0, PropertyName, PropertyValue ), z. B. set(gcf,
’MenuBar’,’neuer_name’), nachträglich wieder ändern; mit get(gcf, PropertyName ) lässt
sich die Einstellung abfragen, z. B. get(h0,’Position’). Das Ansprechen bzw. aktualisieren
der Figure erfolgt mit figure(gcf) oder figure(h0).
Grafikfenster-Befehle
figure (nummer), ...(PropertyName,-Value) Erzeugen, Ansprechen einer Figure
subplot (zeile,spalte,zähler) Erzeugen eines Subplots
gcf (get handle to current figure) Aktuelle Figure-Handle
clf (clear current figure) Rücksetzen, löschen der Children
clf reset wie clf + figure properties zurückgesetzt
delete (figure(nummer)), delete (nummer) Figure, Handle mit nummer löschen
close (nummer) Figure nummer schließen
close all alle Figures schließen
drawnow Bildschirmaufbau
shg entspricht figure (gcf) Figure anzeigen (show graph window)
Beispiel: Nachträgliche Änderung der Fenstergröße (Figure):

p = get( gcf,’Position’ ); % aktuelle Größe
set( gcf,’Position’,[p(1:2) 0.75*p(3) p(4)] ); % Breite reduziert
Änderung der Plot-Fenster-Größe, siehe Abschn. 1.6.2, wenn oben gcf durch gca ersetzt wird.
Durch clf (clear current figure) kann der Inhalt der aktuellen Figure gelöscht werden. Mit
delet(figure(nummer)) oder delet(nummer) – gilt für jedes Handle – wird die Figure gelöscht,
mit close(nummer) geschlossen und mit close all werden alle geöffneten Figures geschlossen.
1.6.1.1 Subplot-Fenster, der subplot-Befehl

Eine Figure kann mit subplot(zeilen,spalten,zähler) in eine zeilen×spalten-Matrix von Subplot-
Fenster unterteilt werden. Mit der Variablen zähler wird zeilenweise von links oben durchnum-
meriert, z. B. für das zweite Bild
subplot(2,1,2) oder subplot(212) oder subplot 212
Verträgliche Kombinationen u. a. wie in:
sind möglich, wobei für subplot(1,2,1) auch subplot(2,2,[1 3]) bzw. für das Argument (2,1,2)
auch (2,2,3:4) stehen kann.
Abweichend von dieser Bildteilung kann auch die Position und die Subplot-Größe mit
hs = subplot (’Position’,[left bottom width height]) manuell festgeschrieben werden;
1.6 Grafik 47
optional mit Handle hs handhabbar.

Typischer Aufruf zum Anlegen einer Figure mit Subplots:
figure(nummer) % Erzeugt Figure mit der Kennung nummer
clf % Rücksetzen des handle der Figure
subplot(zeilen,spalten,zähler) % Erzeugt ein Subplot-Fenster
1.6.2 2D-Grafik
Standardmöglichkeiten zur grafischen Ausgabe von Daten werden zusammengestellt. Beispiele
erläutern die Handhabung, mit Plot_Exp1.m, Plot_Exp2.m und Grafik_Elemente.m
aus [52] kann am Rechner experimentiert werden.
1.6.2.1 Plot-Befehle
2D Plot-Befehle
plot ( x , y , plotstil , ...) Plot der Funktion y = f (xx), lineare Achsteilung
plot (x, [ y; z ] , [ plotstil_y, plotstil_z ] z. B. » plot(x,[y; y1],[’.’,’-’])
line ( x , y , ’PropertyName’,-Value, ... ) Plot, High-Level Aufruf, vgl. S. 57
line ( ’PropertyName’,PropertyValue, ... ) Plot, Low-Level Aufruf, vgl. S. 57
comet ( x , y , Komet-Länge ) Animation einer Trajektorie
stairs ( x , y , plotstil , ...) treppenförmige Grafik, lineare Achsteilung
stem ( x , y , ’filled’, plotstil , ...) Plot, diskrete Linien zu x j mit ◦-Marke, linear
spy ( matrix , plotstil ) Visualisierung, Sparse-Matrix-Besetzung
semilogx ( x , y , plotstil , ... ) Plot, x-Achse logarithmisch
semilogy ( x , y , plotstil , ... ) Plot, y-Achse logarithmisch
loglog ( x , y , plotstil , ... ) Plot, x, y-Achsen logarithmisch
fplot ( funktion, bereich ) Funktion-Plot, z. B. fplot(’xˆ2’,[0 2]);
hold on | off | all Vorhandenes Objekt halten, schließen
Wie alle MATLAB-Funktionen sind auch die Plot-Befehle vektor- bzw. matrixorientiert. Der plot-
Befehl
plot ([x1, x2, x3, .., xN],[y1, y2, y3, .., yN] , plotstil , ...)
bzw. vektoriell: plot (x,y , plotstil ,...),
mit gleicher Dimension von x, y, zeichnet die Punkte zu den reellen Wertepaaren xj, yj,
die standardmäßig durch eine Linie verbunden werden. Entfallen im Aufruf Abszissen- bzw
Ordinaten-Werte d. h. x oder y, z. B.:
plot ( x , plotstil ) , – entspricht plot ( 1:length(x), x , plotstil ) –,
dann werden die enthaltenen Komponenten über ihren Index aufgezeichnet. Ist x komplex, dann
wird plot(real(x), imag(x)) ausgeführt. Andere Interpretationen nach [7] in Abhängigkeit
von der Plot-Anweisung zeigt Bild 1.9 – kompl_plot.m in [52] –, mit den Datenfeldern:
x = linspace(0,10*pi,200); y = exp((1i-0.1)*x);
Der plotstil ist ein String, der im einfachsten Fall aus einem Buchstaben zur Farbenkennung
(Color) und einer Zeichenfolge für den Linien- und Markentyp (Line Style, Marker) in beliebiger
Reihenfolge besteht; z. B. wird mit
Bild 1.9: Plot-Möglichkeiten komplexer Datensätze
plot (x,y,’r-’) bzw. plot (x,y,’r-’,u,v,’-.b*’)

eine rote gestrichelte bzw. eine zusätzliche strichpunktierte, blaue Linie mit der *-Marke erzeugt;
vgl. Beispiel S. 49 sowie die Online-Hilfe:
⇒ help plot
Eine Auswahl für Color, Line Style, Marker ist in den folgenden Tabellen zusammengestellt:
Linien Marken
Farben
- durchgezogen ◦ Kreise
k schwarz r rot
- - gestrichelt * Sterne
b blau m magenta
: gepunktet + Kreuze
c cyan y gelb
. Punkte x x-Marke
g grün w weiß
-. strichpunktiert usw.
vgl.: [1 1 0] gelb usw.
Jeder folgende plot-Befehl löscht zunächst das vorhandene Objekt der aktuellen Figure bzw. der
Subplots. Um mehrere Graphen mit mehreren plot-Befehlen in ein Bild zu zeichnen, kann das
Löschen mit dem Befehl hold on nach/vor dem ersten plot-Aufruf unterbunden werden – die
Axes-Eigenschaften werden an die folgenden Plots vererbt. Mit hold off nach dem letzten plot-
Befehl wird dieser Zustand aufgehoben – die Axes-Eigenschaften sind Standard. Wir zeigen dies
sowie Erläuterung von: Line Styles, Colors, Markers im Beispiel unter Bild 1.10, siehe u. a. auch
D2p_0.m in [52].
Der benutzerfreundliche plot Befehl ist kein Kern-Objekt, wie Bild 1.8 zeigt, in die Function
geht u. a. zur Liniengenerierung der line Befehl als Kern-Objekt ein. Die Eigenschaften (Proper-
ties) sind mit Standardwerten belegt.
Eine Variante zur oberen Liniengestaltung mehrerer Grafen in einem Bild mit Hilfe eines
Cell-Arrays sowie zur Bildteilung des Grafikfensters wird u. a. im Programmcode des Einmassen-
Schwingers S. 50 gezeigt. Wie die Plot-Anweisungen in Bild 1.10 mit Hilfe des line Befehls zu
formulieren sind, wird auf S. 57 gezeigt.
1.6 Grafik 49
Programm-Code Grafik-Ausdruck
figure(1);
clf
t=0:pi/10:2*pi; % Zeitfolge
plot(t,sin(t),’-.r*’) % 1. Plot
hold on
plot(t,sin(t-pi/2),’-mo’) % 2. Plot
plot(t,sin(t-pi),’:bs’) % 3. Plot
hold off % NextPlot
axis tight % Extremwert- Anpassung
Bild 1.10: Beispiel zu: Line-Style, Color, Marker
1.6.2.2 Achsen und Beschriftung

Achs-Skalierung und Grafik-Beschriftung
axis ([x_min, x_max, y_min, y_max]) Manuelle Achsen-Skalierung, axis ist Vektor
L = axis Zuweisung der aktuellen Skalierung
axis ([L(1:3), y_max]) Umskalierung eines/mehrerer Achsmaße
axis ([-inf x_max y_min y_max]) mit inf folgt automatische Skalierung
axis on | off | auto | equal | square | tight Achs-Befehle: Ein- Ausblenden, Skalierung
xlim([x_min x_max]), ylim, (zlim) Achs-Skalierung 2D, (3D)
linkaxes(ax option ) Verknüpfung der Subplot-Skal. vgl. Beispiel
grid on | off Gitternetz ein-, ausblenden
gca (get handle to current axis) Aktuelle Achs-Handle
xlabel (string), ylabel (string) x-, y- Achsen-Beschriftung
title (string) Grafik-Überschrift
text (x_position, y_position, string) positionierten Text einbringen
legend (string_1, string_2, ... , position ) Linienlegende mit Positionsvereinbarung
\alpha | \omega | \Omega | _ | ˆ |.. TEX -Mode, griechische u. mathe. Zeichen
interpreter {tex} | latex | none Umschaltung des Textmodes, TEX, LATEX
Die Befehle der oberen Tabelle werden u. a. im unten ausgeführten Beispiel erläutert. Bemer-
kung zur Beschriftung: In den Stringausdrücken string sind auch griechische Buchstaben sowie
einige mathematische Darstellungen, z. B. 5 ˆ 2 → 52 , wie im Textverarbeitungssystem TEX bzw.
LATEX [36] möglich. Mit dem Textinterpreter, z. B. ’interpreter’,’latex’, erfolgt die
Auswahl. In der Symbol-Tabelle unter: Button Search: Text Properties→Link: TeX
Character Sequenze Table sind die zulässigen Zeichen zu finden. Einige Beispiele wer-
den im Demo-Programm LatexBeschr.m in [52] gezeigt.
Beispiel: Gesucht ist der Amplituden- und Phasenfrequenzgang eines gedämpften Einmassen-
Schwingers mit der Bewegungsgleichung und der Lösung x(t):
ẍ + 2ω0 Dẋ + ω02 x = q cos Ωt, wobei x(t) = C cos (Ωt −Ψ )
sowie den Parametern D Dämpfungsmaß, ω0 Eigenkreisfrequenz des ungedämpften Systems, q

bezogene Erregenamplitude, Ω Erregerkreisfrequenz sowie der Schwingungsamplitude C und
Phase Ψ
q 1 2Dη Ω
C = , Ψ = arctan , η = .
ω0 (1 − η )2 + 4D2 η 2
2 2 1 − η2 ω0
C und Ψ sind numerisch in Abhängigkeit von η auszuwerten und grafisch darzustellen.

Hinweis: Zusätzlich zur Achs- und Grafik-Beschriftung wird eine Möglichkeit zur manuellen
Achsteilung ( Tick-Marken ) mit zugehöriger Beschriftung eingeführt. Die aktuelle Achs-Einstel-
lung wird mit gca im set-Befehl übernommen und mit den Eigenschaften ytick, yticklabel eine
neue Unterteilung und Beschriftung der y-Achse (bzw. x-Achse) gesetzt. Darüber hinaus wird
eine zweifach auftretende Befehlsfolge einmalig als String func formuliert und später mit den
aktuellen Größen unter eval ausgewertet, vgl. Programm Freq_G.m in [52].
%---- Programm Freq_G.m

%---- Amplituden- und Phasen-Frequenzgang für unterschiedliche Dämpfungswerte
om_0=10.0; % Eigenkreisfreq. [rad/s]
q =1.0; % bezogene Erregerampl. [m/s^2]
eta=linspace(0.0,2,200); % bezogene Erregerfrequenz
D=[0.0125 0.025 0.075 0.15]; % Dämpfungswerte
%---- Stringausdruck für Achsmanipulation, später mit eval ausgewertet
func=’axis(xa); set(gca,xyt,skala); set(gca,xylab,skala)’;
%---- Ausgabedaten und Linestyle
for I=1:4, Dl{I}=sprintf(’%s %8.4f’,’D=’,D(I));end % Ausgabe-Cell-Array
farblin={’r--’;’g:’;’b-.’;’k’}; % Linestyle in Cell-Array
figure(’name’,’Amp/Ph’,’NumberTitle’,’off’) % Amplituden, Phase

clf;
for ii=1:length(D) % Schleife über Dämpfungswerte
C=q/om_0^2./sqrt((1.0-eta.^2).^2+4.0*D(ii)^2*eta.^2); % Amplitude
Psi=atan2(2.0*D(ii)*eta,1.0-eta.^2); % Phase
subplot(2,1,1) % Amplitudenfrequenzgang
plot(eta,C,farblin{ii}), hold on % Amplituden-Plot
if ii==length(D) % Beschriftung im letzten Durchlauf
ylabel(’Amplitude C [m]’) % Beschriftung y-Achse
title(’Amplitudengang’) % Bild-Titel
legend(Dl{1:4},2) % Legende, links angeordn.
grid, hold off % Raster
xa=[0 eta(end) 0 0.4]; % neue Achsdaten in func
skala=0:0.2:eta(end); % Skalenvektor
xyt=’xtick’; xylab=’xticklabel’; % aktuelle Änderung
eval(func); % Stringauswertung
end
subplot(2,1,2), hold on % Phasenfrequenzgang
....... entsprechend für die Phase % siehe Freq_G.m
end
1.6 Grafik 51
Bild 1.11: Beispiel: Amplituden- und Phasengang zum Einmassenschwinger
Beispiel, linkaxes Befehl: Um Grafen mehrere Subplots vergleichen zu können, wird eine
einheitliche Skalierung vorausgesetzt, dies erreichen wir mit dem linkaxes Befehl mit den Op-
tionen ’x’, ’y’, ’xy’ ’off’ zur Skalierung der jeweiligen Achsen x, y bzw. beider, wie im
folgenden Programmcode und dem Bild 1.12:
x1=-2*pi:0.1:2*pi; y1=0.5*sin(x1); % Subplot 1
x2=-4*pi:0.1:4*pi; y2=cos(x2); % Subplot 2
ax(1)=subplot(2,2,1);
plot(ax(1),x1,y1); % automatische Skalierung
title(ax(1),’Subplot 1’)
ax(2)=subplot(2,2,2);
plot(ax(2),x2,y2); axis tight % an Extremwerte angepasst
title(’Subplot 2’)
linkaxes([ax(2), ax(1)],’xy’) % Anpassung an Subplot 2
Bild 1.12: Beispiel zur Verknüpfung der Achsskalierung, hier x und y
Unterschiedliche Y-Skalierung: Sind Diagramme mit Datensätzen sehr unterschiedlicher

Extremwerte zu bilden, dann kann einerseits durch Skalierung vergleichbare Extremwerte, z. B.
für die Schwinggeschwindigkeit ẋ durch ẋ/Ω , wobei Ω die Erreger- oder die Eigen-Kreisfrequenz
sein kann, vergleichbare Größenordnungen geschaffen werden, andererseits lassen sich auch
mehrere Achsskalierungen einbringen. Die Kombination zweier Zeitverläufe x(t), ẋ(t) des Schwin-
gungssignals des letzten Beispiels zeigt Bild 1.13. Neben den Linien-Plots sind in Bild 1.13
Bild 1.13: Beispiel: Mehrachsenskalierung
zur Demostration zusätzlich die Stem-Plots (Stäbe, Stangen) der Amplituden dargestellt. Eine
Anwendung der Stem-Plots ist die Darstellung der F OURIER-Koeffizienten einer Analyse eines
Schwingungssignals, vgl. u. a. fftdemo_P.m in [52].
Teile des Progammcodes zu Bild 1.13 aus Freq_G.m, mit t, x, xp aus dem Code von S. 61,
geben wir an:
figure(’name’,’2YSkal’)
% ---- Linien-Plot
[ax,h1,h2] = plotyy(t,x,t,xp,’plot’); % Plotanweisung, 2 y-Achsen
set(get(ax(1),’Ylabel’),’String’,’Weg x’)% Achsbeschriftung
set(get(ax(2),’Ylabel’),’String’,’Geschwindigkeit xp’)
xlabel(’Zeit [s]’) % eine x-Achse
title(’Schwingungen, Weg und Geschwindigkeit’) % Titel
hold on % weitere Plots aufnehmen
% ---- stem Plot
[Ax,H1,H2] = plotyy(t(1:5:end),x(1:5:end),...
t(1:5:end),xp(1:5:end),’stem’);
set([h1 H1],’LineStyle’,’-’) % Linienart
set([h2 H2],’LineStyle’,’:’) % Linienart
set([ax Ax],’XLim’,[0 t(end)]) % x-Achsen-Skalierung
set(Ax,’Position’,get(ax(1),’Position’)) % gleiche Positionierung
hold off
Darüber hinaus kann eine zweite Abszisse im Bildkopf eingeführt werden. Neben der linearen
Unterteilung der Achsen können mit semilogx, semilogy, loglog, z. B. wie in
[ax,h1,h2]=plotyy(t,x,t,xp,@similogx,@semilogx,@plot);
– dabei gilt auch: ...,’semilogx’,’plot’); – diese auch logarithmisch unterteilt
werden. Wird das Handle @similogx nur einmal eingetragen, dann bezieht sich dies auf x, die
Achsunterteiling zu xp ist linear. MATLAB kennt weitere Diagrammtypen: bar, barh, bar3,
1.6 Grafik 53
barh3, hist, pie, pie3, für technische Darstellung sind wichtiger die Stufen-Plots stairs
und die 3D-Stab-Plots stem3.
1.6.2.3 Erläuterungen zum Handle Graphics

Das Handle Graphics erlaubt, wie schon angedeutet, Eigenschaften von Grafiken in MATLAB
über Standardbefehle hinaus direkt zu manipulieren, vgl. [7].
Jedes grafische Objekt besteht aus mehreren Komponenten, wie z. B. den Grafikfenstern (fi-
gure), den Koordinatenachsen (axes), einzelnen grafischen Objekten, z. B. Linien (line), Flächen
(surface) und Lichtquellen (light). Das Handle bietet nun die Möglichkeit, jedes dieser Objekte
einzeln anzusprechen.
Das zugehörige Handle eines zuletzt ausgeführten Standardbefehls, z. B.
>> t = 0:10;
>> plot(t,t.^2,’o-’)
>> text(3,60,’Beispiel: y(t) = t.*t’)
erhalten wir nachträglich mit
>> h = findobj % vgl. auch: all = findall(h)
h =
0
1.0000
170.0134
172.0134
171.0139
Die Werte in h sind Zeiger auf die Komponenten der Grafik – die Werte ändern sich bei jedem
Programmablauf. Die Zuordnung liefert der Befehl
>> get(h,’type’) % vgl. auch: get(all,’Type’)
ans =
’root’ % Bildschirm
’figure’ % Grafikfenster
’axes’ % Koordinatenachsen
’text’ % Texteingabe
’line’ % Linien, inklusive der Markierungen
D. h. mit der obigen findobj-Anweisung finden wir die Handles des Root-Objekts mit allen Kind-
Objekten, vgl. Bild 1.8.
Mit dem set-Befehl kann die Liste möglicher Eigenschaften, mit dem get-Befehl die einge-
stellten Eigenschaften angezeigt werden:
>> set(h(3)), set(h(5)), get(h(5)), ....
Wir erhalten recht umfangreiche Listen. Jede Eigenschaft der ausgegebenen Listen können
wir nun verändern, Voreinstellungen sind dabei in geschweifte Klammern gefasst. Welche Mög-
lichkeiten hinter jeder Eigenschaft steht, lässt sich mit dem set-Befehl zur Anzeige bringen. D. h.
für die Markierung (Marker) aus dem Objekt Line
>> set(h(5),’Marker’)
[ + | o | * | . | x | ... ... | < | pentagram | hexagram | {none} ]
Nun ersetzen wir die Kreismarken der oben erstellten Grafik durch größere Quadrate:
>> set(h(5),’Marker’, ’square’,’MarkerSize’, 16)
Das Gegenstück zur set- ist die get-Anweisung, mit der die eingestellten Eigenschaften abge-
fragt werden können, z. B.:
>> {get(h(5),’Marker’); get(h(5),’MarkerSize’)} % Cell Array
ans =
’square’
[ 16]
– {get(..} dient der gemeinsamen Ausgabe. Wenn man das Handle Graphics verwenden
will, empfiehlt es sich, immer gleich nach Erzeugen der Grafik einen Handle auf die Grafik zu
speichern.
Handles können nicht nur mit findobj im nachhinein, sondern unmittelbar zugewiesen werden:
>> figure(2)
>> h1 = plot(t,sqrt(t),’-.’,’Markersize’,16)
h1 =
344.0139
In diesem Fall gibt die Grafik-Anweisung als Funktionswert nur ein Handle auf das zusätzlich
erzeugte Objekt – also Linie – zurück, wie die Anweisung
>> get(h1,’Type’)
ans =
line
bestätigt. Alle Handles und deren Zuweisung des Root-Objektes mit allen Kind-Objekten erhal-
ten wir wieder mit findobj und get
>> H = findobj >> get(H,’type’)
ans = ans =
H =
0 ’root’
2.0000 ’figure’
1.0000 ’figure’
343.0134 ’axes’
170.0134 ’axes’
344.0139 ’line’
172.0134 ’text’
171.0139 ’line’
Spezieller: Alle Axes- und alle Line-Objekte mit der Markengröße 16 folgen mit:
>> findobj(’Type’,’axes’), Hm=findobj(’MarkerSize’,16)
Allgemein: h=findobj(<handle>, ’PropName’, PropValue’) beschränkt die Su-

che auf das Objekt <handle> und die darin enthaltenen Objekte.
Soll eine weitere Grafik ins zweite Grafikfenster eingebracht werden, können wir dies mit hold
on oder mit der axes-Eigenschaft Nextplot erreichen (Plot-Fenster bleibt offen). Alle aktuellen
Einstellungen werden mit get(H(4)), die speziellen Eigenschafts-Werte mit
1.6 Grafik 55
>> set(H(4),’Nextplot’)
[ new | add | {replace} | replacechildren ]
angezeigt, d. h. mit
>> set(H(4),’Nextplot’,’add’)
>> h2=plot(t,0.8*sqrt(t)); set(h2,’LineWidth’,2)
>> set(H(4),’Nextplot’,’replace’)
wird eine zusätzliche Grafik mit geänderter Linienstärke dargestellt und das Grafik-Fenster für
weitere Plots, wie mit hold off, geschlossen. Bei replacechildren wird das alte Grafik-
Objekt gelöscht, das neue eingebracht, wobei u. a. die Achsen aber erhalten bleiben – wichtig
für Animation, Abschn. 1.7.
Jedes grafische Objekt kann mit dem Befehl delete aus der Grafik gelöscht werden, z. B.
>> delete(h2)
Wenn hf ein Handle auf ein Grafikfenster (Typ "figure") ist, kann das zugehörige Fenster mit
close(hf) geschlossen werden, hier:
>> close(H(2))
Es gibt darüber hinaus einige globale Variablen, die (falls eine Grafik vorhanden ist) Handles
gewisser aktueller Objekte enthalten:
gcf = Handle des aktuellen Grafikfensters
gca = Handle der aktuellen Achsen
gco = Handle des aktuellen Grafikobjektes (Linie, Fläche usw.)
Beispiel:
figure(2) % Grafik-Fenster öffnen
plot(t,0.8*sqrt(t)); % Plot-Anweisung
get(gca) % Axes-Eigenschaften anzeigen
set(gcf,’Color’,[0.6 0.6 0.6]) % Farbe des Grafik-Fensters ändern
set(gca,’Nextplot’,’add’) % Folge-Plot ins gleiche Fenster
plot(t,0.6*sqrt(t)); % 2. Plot
set(gco,’LineWidth’,3) % Linienstärke ändern
set(gca,’Nextplot’,’replace’) % Plot-Fenster schließen (hold off)
Das Handle des aktuellen Grafik-Fensters erhält man mit gcf (Get Current Figure), die des
aktuellen Koordinatensystems (Axes) durch gca (Get Current Axis), die des aktuellen Objekts
durch gco (Get Current Objekt).
Die Eigenschaften der Objekte im Grafik-Fenster können in den neueren MATLAB-Versionen
sehr komfortabel mit dem Property Editor verändert werden, siehe Bild 1.16.
1.6.2.4 Ergänzende Grafik-Befehle

Neben dem Linienstil (Line Style), u. a. die Linienstärke (Line Width), lassen sich weitere Eigen-
schaften wie Farbe, Markengröße, Beschriftungsgröße, Schriftart usw. manuell einstellen. Die
Syntax derartiger Befehle, hier zunächst am plot Befehl gezeigt, haben die Struktur:
plot(x1,y1,LineSpec,. . .), bzw. plot(. . .,’PropertyName’,PropertyValue,. . .).
D. h. gleichzeitig mit der Grafik-Anweisung werden gewählte Eigenschaften in der Parameterlis-

te definiert. Jede Eigenschaft wird durch den Namen (PropertyName) und einen zugehörigen
Wert (PropertyValue) festgeschrieben.
Einige Linienspezifikationen (LineSpec) und die Standardfarben, mit denen Mischfarben
z. B. [ 0.49 1 0.63 ] abgeleitet werden können, sind in der folgender Tabelle zusammengestellt:
Linien-, Marker-Spezifikationen und Farben

PropertyName PropertyValue Color (Grund-, Mischfarben)
LineStyle { - } | - - | -. | : | none [110] y yellow
LineWidth { 0.5 }, 1, ... [101] m magenta
Color ’r’, ..., [ 0.5 0.2 0.4 ], .. [011] c cyan
Marker + | o | * | . | < | , ... [100] r red
MarkerSize ... , 2, ... [010] g green
MarkerFaceColor ’m’, ..., [ 0.5 0.1 0 ], ... [001] b blue
MarkerEdgeColor ’b’, ..., [ 1 1 0.5 ], ... [111] w white
FontWight light | {normal} | demi | bold [000] k black
FontSize ...| 5 |, ...| {10} |, ...| 12 |, ... [ 0.1 0.8 0.1 ] Mischfarbe
Handhabung einiger Linien- und Marker-Spezifikationen, wir geben drei Möglichkeiten an.
1. Der plot Befehl, einzelner Graf, siehe Bild 1.141 :
figure(2)
plot(t,sin(2*t),’-mo’,...
’LineWidth’,2,...
’MarkerEdgeColor’,’k’,...
’MarkerFaceColor’,[.49 1 .63],...
’MarkerSize’,12)
2. Der plot und set Befehl, mehrere Grafen:

Bei gleichzeitiger Modifikation mehrerer Grafen sind einerseits die Eigenschaften LineStyle-
Order und ColorOrder usw. und andererseits die bekannten Eigenschaften, wie Line-
Width, Color, im Zusammenhang mit Cell Arrays zu verwenden, was die folgenden Anwei-
sungen verdeutlichen:
h=plot(t,sin(t),t,sin(t-pi/2),t,sin(t-pi));
% oder: h=plot(t,[sin(t);sin(t-pi/2); sin(t-pi)]);
set(h,’LineWidth’,2,{’LineStyle’},{’--’;’:’;’-.’})
% oder: set(h,’LineWidth’,2), set(gca,’LineStyleOrder,’--|:|-.’)
set(h,{’Color’},{’r’;’g’;’b’})
% oder: set(gca,’ColorOrder’,[1 0 0; 0 0 1; .7 .7 .7])
Die Grafen einer der letzten Plot-Anweisungen, siehe auch D2p_1.m in [52], sind in Bild 1.142
wiedergegeben.
3. Der line Befehl, einzelner Graf:
Mit den oben angegeben Eigenschaften können nun die Plot-Anweisungen in Bild 1.10 durch
den line Befehl ersetzt werden. line ist Kind-Objekt zum Axes-Objekt (Parent). Im Gegensatz
zum plot Befehl bleibt beim line Befehl das Grafik-Fenster offen, hold on kann entfallen, vgl.
1.6 Grafik 57
Bild 1.14: Beispiele zur Linienspezifikation
auch Plot_Exp1.m in [52]. Ein folgender line Befehl löscht also nicht den vorhandenen Inhalt.
Dementsprechend lautet die Befehlsfolge des Beispiels aus Bild 1.10:
• High-Level-Befehlsfolge:
t=0:pi/10:2*pi; % Zeitfolge
line(t,sin(t),’Color’,’r’,’LineStyle’,’-.’,’Marker’,’*’)
line(t,sin(t-pi/2),’Color’,’m’,’LineStyle’,’--’,’Marker’,’o’)
line(t,sin(t-pi),’Color’,’b’,’LineStyle’,’:’,’Marker’,’s’)
• Low-Level Befehl: (strenge Reihenfolge ’PropertyName’, PropertyValue)

line(’XData’,t,’Ydata’,sin(t),’Color’,[ 1 0 0 ],...
’LineStyle’,’-.’,’Marker’,’*’) usw.
Einstellungen von Text-Eigenschaften:

Mit ’FontSize’,größe ist die Schriftgröße, mit ’FontWeight’,’stärke’ die Schriftstärke
und mit ’Color’,farbe die Beschriftungsfarbe, z. B.
>> text(10,0.8,’Test’,’Color’,’r’,’FontSize’,15)
einstellbar. Angewendet auf die Achsbeschriftung folgt
>> xlabel(’Zeit’,’FontSize’,16,’FontWeight’,’bold’)
Grafik in Grafik:
Weiterhin soll gezeigt werden, wie sich Beschriftungen außerhalb eines Grafik-Fensters anbrin-
gen lassen. Dies lässt sich auch als Grafik in einer Grafik – siehe Abschn. 8.6 – interpretieren,
wobei im Gegensatz zu hier mit ’Visible’ , ’on’ , ’Box’ , ’on’ die Achsen einzublenden sind.
figure(1), clf
h = axes(’Position’,[0 0 1 1],’Visible’,’off’); % Def. 1. Achssystem
axes(’Position’,[.35 .1 .6 .8]) % Def. 2. Achssystem
% ist aktiv
t = 0:900; % Zeitvektor
plot(t,0.25*exp(-0.005*t),’LineWidth’,2) % Plot der Funktion
% Textfeld erstellen und im ursprünglichen Fenster positionieren.
str(1) = {’Plot der Funktion:’}; % oder: str{1}=’Plot der Funktion’;
Bild 1.15: Text außerhalb der Grafik, bzw. Grafik in Grafik
str(2) = {’ y = A{\ite}^{-\alpha{\itt}}’};
str(3) = {’Parameter:’}; % str ist Cell Array
str(3) = {’ A = 0.25’};
str(4) = {’ \alpha = .005’};
str(5) = {’ t = 0:900’};
set(gcf,’CurrentAxes’,h) % 1. Achssyst. aktiv
text(.025,.5,str,’FontSize’,12) % Text einbringen
1.6.2.5 Interaktive Plot-Erstellung und -Tuning

Alternativ zur Erstellung und Bearbeitung von 2D- und 3D-Grafiken mit Plot-Befehlen bietet
MATLAB interaktive Möglichkeiten insbesondere zur Änderung/Ergänzung – Feintuning – er-
zeugter Grafiken über entsprechende Fenster mit speziellen Plot-Eigenschaften. Einzelne sind
mit dem Edit- und/oder View-Button in der Menü-Leiste des Figure-Fensters zu finden, alle wer-
den mit plottools on/off über das Command Window oder über den Button Show Plot Tools
and Dock Figure und Hide Plot Tools, wie in Bild 1.16, ein/aus-geblendet. Die Fenster-
Layouts sind gegenüber den Vorgängerversionen neu gestaltet, neue Features sind hinzugekom-
men. Die meisten Eigenschaften sind aber bereits in den Vorgängerversionen enthalten. Wir wol-
len stichwortartig eine Plot-Erzeugung und Gestaltung unter MATLAB 7.12 vornehmen. Dabei
soll in einem Subplot-Fenster die Ausgangsgrafik, in einem zweiten die neu gestaltete und ver-
feinerte Grafik angeordnet sein. Dies kann nur ein Einstieg in diese Methode sein. Eigene Expe-
rimente sollten den Umgang mit diesem Tool vertiefen.
Eine mögliche Vorgehensweise:
1. Erzeugung der Plot-Daten im Command Window und öffnen des Grafikfensters:

>> clear, t=(0:0.1:2)*pi; y=sin(t); y1=0.5*y; figure
2. Aufbau der Plot-Umgebung: Öffnen der Fenster Figure Palette 1; Plot Browser 2;
1.6 Grafik 59
Bild 1.16: Plot-Umgebung zur interaktiven Grafikgestaltung unter MATLAB 7.12
Property Editor 3 im View-Menü des Figure-Fensters oder mit dem Button Show
Plot Tools..., siehe Bild 1.16.
3. Grafikfenster einrichten: Im Fenster Figure Palette/New Subplot ist das Symbol
für 2D Subplot auszuwählen und / oder mit einem Klick auf das Matrixsymbol in dem sich
öffnenden Fenster mit dem Mauszeiger und linker Maustaste die gewünschte Struktur ein-
färben und die Taste wieder frei geben.
4. Grafik-Erstellung: In Figure Palette/Variables die drei Vektoren t, y, y1 aus-
wählen (linke Maustaste + Shift/Strg). Shortcut-Menü mit rechter Maustaste öffnen (Zeiger
auf ), Darstellung Plot auswählen oder den gekennzeichneten Block t, y y1 mit der
Maus in das gewünschte Subplot-Fenster ziehen. Es folgt die Grafikerstellung mit zugehö-
rigen Einträgen in dem Plot Browser. Hiermit können die einzelnen Grafen aktiviert
– es werden Marken eingeblendet – oder mit dem Häkchen ausgeblendet werden. Gleich-
zeitig werden im Property Editor die Anzeigen -Figure, -Axes, -Lineseries
und das Layout angepasst. Diese Vorgänge lassen sich auch im Grafik-Fenster durch Po-
sitionieren des Mauszeigers auf den Grafen sowie im inneren oder äußeren Fenster und
anschließendem Klick erreichen. Die eingeblendeten Eigenschaften lassen sich interaktiv
auf die Grafik übertragen. Alle Eigenschaften zur jeweiligen Einstellung werden mit dem
More Properties Button im Inspector 4 eingeblendet, in Bild 1.16 für den angewähl-
ten Grafen y – stark verkürzt – überdeckend dargestellt.
Um die Grafen ebenfalls im unteren Fenster darzustellen, wird dieses aktiviert und die obige
Vorgehensweise wiederholt.
5. Eigenleistung: Entsprechend Bild 1.16 ist diese Grafik zu ergänzen. Hinweis: Die Legende
wird über den Button Insert Legend, siehe Bild 1.16, bzw. Insert / Legend oder
mit Show Legend im Short-Cut-Menü (Mauszeiger im Plot-Feld/rechte Maustaste) einge-
blendet.
6. Code-Erzeugung: Es kann der Code bezüglich der Figure (gesamtes Bild) oder der Subplots
erzeugt werden. Den jeweiligen Code erhält man über das zugehörige Short-Cut-Menü mit
dem Menü-Punkt Show Code oder den File-Button/Generate File. Es wird u. a. die
Function createfigure(...) bzw. createaxes(...) erstellt und im Editor ange-
zeigt.
7. Dieser Code kann einerseits zum Studium der Grafik-Befehle, andererseits zur Integration
ins eigene M-File herangezogen werden, wie in plotum.m aus [52] gezeigt.
Ergänzende Informationen sind u. a. den Video-Demos unter: Help / Demos – auch unter You Tu-
be – zu entnehmen.
Vorhandene Grafiken können mit den Tools unter dem Button Insert auch unmittelbar er-
gänzt werden. Z. B. kann mit Insert/TextBox Text eingefügt und über das Shortcut Menü
anschließend zugehörige Eigenschaften berücksichtigt werden.
1.6.3 3D-Grafik
3D Plot-Befehle
plot3 ( x, y, z , plotstil ) 3D-Linien-Plot z. B. Parameterdarstellung einer Funkt.
comet3 ( x, y, z , komet-länge ) 3D-Animation einer Trajektorie
mesh ( x, y, z , farbe ) 3D-Gitter-Plot, Drahtmodell expl. Funkt.: z = f (x, y)
surf ( x, y, z , farbe ) 3D-Fläche-Plot, siehe auch surfl mit Ausleuchtung
surfc ( x, y, z , farbe ) wie surf + Höhenlinien
patch ( x, y , z , farbe ) 2D-, 3D-Fläche-Plot, vgl. auch fill, fill3
waterfall ( x, y, z ) 3D-Wasserfall-Plot
contour3 ( x, y, z , v ) 3D-Plot von Höhenlinien
contour ( x, y, z , v ) 2D-Plot von Höhenlinien
[X,Y]=meshgrid ( x, y ) Koordinatenmatrizen für Schnittpunkte in der x, y-Ebene
box on | off Box ein- bzw. ausblenden
view ( az, el ) Blickwinkel: Perspektive ändern, Azimut-, Elevation-∠
zlabel (string) z-Achsen-Beschriftung, + xlabel, ylabel
Die Darstellungsmöglichkeiten dreidimensionaler Zusammenhänge reichen von einfachen Li-

nien- bzw. Punkt-Plots bis hin zu ausgeleuchteten, realitätsnahen Objekten. Wir können nur auf
einen sehr kleinen Anwendungsbereich eingehen, wofür einige Befehle angegeben und erläutert
werden. Einen Befehlsüberblick und Details erhält man mit
⇒ help graph3d und help begriff
Darüber hinaus bietet die Online-Hilfe eine ausführliche Beschreibung (einschließlich vieler Bei-
spiele), insbesondere im Zusammenhang mit der Such-Option (search) im Help Browser z. B. für
die oben aufgeführten Befehle, einige werden hier näher erläutert:
• plot3: Es können Linien mit/ohne Marken in einem 3D-Raum dargestellt werden (vgl. plot).
Z. B. von Funktionen in Parameterdarstellung: x(t) = ϕ(t), y(t) = χ(t), z(t) = ψ(t) mit
1.6 Grafik 61
dem Kurven-Parameter t aus tmin ≤ t ≤ tmax . Beispiel – vgl. Plot_Exp.m in [52]:

>> t = linspace(-5, 5, 2001); % oder t=-5:0.005:5;
>> x = (1+t.^2).*sin(20*t);
>> y = (1+t.^2).*cos(20*t);
>> z = exp(t);
>> plot3(x, y, z,’.-r’)
• mesh: Gitterdarstellung einer expliziten Funktion z = f (x, y) zweier Variablen, z. B.
z = y cos 2 (2πx) wie im 1. Beispiel S. 63:
>> mesh(X, Y, Z); % C_farbe ≡ Z, vgl. Programmcode des 1. Beispiels
Die Matrizen X und Y ergeben sich aus dem Wertebereich von x, y, wobei in X zeilenweise
der Vektor x und in Y spaltenweise der y-Vektor mehrfach angeordnet ist. Diese werden
mit
>> [X,Y] = meshgrid(x, y)
erzeugt. Paarweise beschreiben die X-, Y-Elemente einen Punkt der x-, y-Basisebene, so
dass
>> Z = Y.* cos(2*pi*X).ˆ 2
die zugehörigen z-Werte ergibt. Wird – wie oben – keine Farbmatrix C_farbe vorgege-
ben, so ist C_farbe = Z. Die Farbstufung kann wie in surf u. a. durch colormap(name)
und/oder caxis beeinflusst werden.
Beispiel eines 3D-Linien-Plots: Die erzwungenen Schwingungen des Einmassen-Schwingers
nach Beispiel S. 50
x(t) = C cos (Ωt −Ψ ), ẋ(t) = −ΩC sin (Ωt −Ψ )
sind im Bewegungsraum (t, x, ẋ) darzustellen. Zusätzlich sind die Projektionen jeweils in die
(t, x)-, (t, ẋ)-Ebene sowie in die Phasenebene (x, ẋ) aufzunehmen, siehe Bild 1.17. Wir setzen im
Programm Freq_G.m von S. 50 fort:
% ---- Darstellung im Bewegungsraum, 3D-Plot
eta_0=1.0; % bezogene Frequenz
Omega=eta_0*om_0; % Erregerkreisfrequenz
t=linspace(0,4*pi/Omega) % Zeitvektor
C=q/om_0^2./sqrt((1.0-eta_0^2)^2+4.0*D(1)^2*eta_0^2); % Amplitude
Psi=atan2(2.0*D(1)*eta_0,1.0-eta_0^2); % Phase
x=C*cos(Omega*t-Psi); % Lösung x(t)
xp=-Omega*C*sin(Omega*t-Psi); % Lösung xp(t)
figure(’name’,’3D’)
plot3(t,x,xp,’r’,’linewidth’,3), hold on % Bewegungsraum
plot3(t,x,1.2*min(xp)*ones(size(t)),’k’) % Projektion in (t,xp)-Ebene
plot3(t,1.2*max(x)*ones(size(t)),xp,’k’) % Projektion in (t,x)-Ebene
plot3(t*0,x,xp,’b’) % Phasenebene xp(x)
axis([t(1), t(end),1.2*[min(x) max(x)], 1.2*[min(xp) max(xp)]])
box on % Rahmen eingeblendet
xlabel(’Zeit’); zlabel(’xp’); ylabel(’x’) % Achs-Beschriftung
view(28,42) % Blickwinkel
Beispiel: Mit dem mesh- und surf Befehl lassen sich auch Elementgrößen einer Matrix
visualisieren; z. B. für die Matrix M
Bild 1.17: Beispiel: Schwingungs-Darstellung im Bewegungsraum mit Projektionen in die Unterräume
>> mesh(M); oder >> surf(M ,’FaceColor’,’w’,’EdgeColor’,’k’ );

In Bild 1.18 sind die Massen- und Steifigkeitsmatrix eines Finite-Element-Modells eines beid-
seitig federnd gelagerten Balkens mit mittig besetzter Einzelmasse, die sich deutlich abhebt, mit
dem mesh Befehl ausgewertet.
Bild 1.18: Matrix-Visualisierung eines Finite-Element-Balkenmodells
Flächen-Plot: Des Weiteren geben wir eine Kurzbeschreibung einiger Darstellungsmöglich-

keiten für farbige Oberflächen-Grafik-Objekte, die sich insbesondere zur Animation eignen, an.
Dabei unterscheiden wir die High-Level-Syntax, bei der u. a. die Farbanlagen weitgehend automa-
tisiert sind und die Low-Level-Syntax, bei der die Eigenschaften stets durch Property Name,
Property Value paarweise festgeschrieben werden.
• patch: Grafikfunktionen zur Darstellung einer oder mehrerer 2D- und 3D-Polygonzügen.
Die umschlossenen Flächen werden farbig angelegt und ausgeleuchtet (Coloring, Lighting).
Anwendungen: Fachwerkstrukturen, Linienmodelle (Flugzeug, Automobil). Beispiele sind
1.6 Grafik 63
in Patch_Exp.m in [52] programmiert.

Syntax: (Eigenschaften unter search → patch im Help Browser)
- High-Level: patch(x_koord, y_koord, c_farbe), 2D-Plot
patch(X,Y,Z,C_farbe, -weitere Eigenschaften-) 3D-Plot,
X, Y, Z Matrizen der Koordinaten, C_farbe Matrix der Farbanlagen
- Low-Level: patch(’XData’,X,’YData’,Y,’ZData’,Z,’CData’,C_farbe)
Beispiel einer 2D-Dreiecksfläche, vgl. Patch_Exp.m und lin_ani_2.m in [52]:
>> patch([0 0.25 -0.25 0],[0 -0.5 -0.5 0],[0 0.7 0]);
Bemerkung: fill ist ebenfalls ein 2D- und fill3 ein 3D-Patch-Objekt.
• surf: Oberflächenobjekte zweidimensionaler Funktionen in Gitterstruktur (Drahtmodell)
mit farbigen Flächenelementen. Es werden die Punkte mit den Koordinaten der Matrizen
X, Y, Z grafisch dargestellt und die umschlossenen Flächenelemente farbig angelegt und
ggf. ausgeleuchtet, siehe auch surfl Befehl.
Syntax
- High-Level: surf(X, Y, Z, C_farbe)
- Low - Level: surf(’XData’, X, ’YData’, Y, ’ZData’,Z,’CData’,[],...
’FaceColor’,’red’, -weitere Eigenschaften-)
surf Daten X,Y,Z können in patch Daten Xp konvertiert werden, z. B.:
>> Xp = surf2patch(X,Y,Z); % Xp Structure
>> patch(Xp,’FaceColor’,[1 0.2 0.2],’EdgeColor’,’k’);
Jedes Element von C_farbe entspricht einem Farbwert, der als Index für eine Farbtabelle
verwendet wird. Der größte und kleinste Eintrag von C_farbe wird automatisch auf den obersten
bzw. untersten Tabelleneintrag skaliert. Die Skalierung der Farbe kann mit caxis(farbe_min,
farbe_max) festgelegt werden. Mit colormap neuefarbtabelle wird eine neue Farbtabelle ak-
tiviert. Für z. B. C_farbe=Z passt sich die Farbgebung an die Visualisierungsdaten an. Verfor-
mungs-, Spannungs-, Temperatur-Änderungen usw. werden sichtbar. Weitere Hinweise in den
folgenden Programmen sowie am Anschluss daran.
1. Beispiel: 3D-Darstellungen mit mesh, surf, waterfall, contour3; siehe [52]
% ---- D3p_1.m
x=0:0.025:1; y=-1:0.2:1;
[X, Y]=meshgrid(x,y); % Koordinatenmatrizen
Z=Y.*cos(2*pi*X).^2; % Z-Koordinate, vgl. griddata
figure(1), clf
subplot(221)
mesh(X,Y,Z) % 3D-Gitter-Plot
view(40,45)
grid off
subplot(222)
surf(X, Y, Z,’MeshStyle’,’row’)) % 3D-Flächen-Plot
view(-40,30); % Perspektive
box on % 3D-Box einblenden
subplot(223)
waterfall(X, Y, Z) % 3D-Wasserfall-Plot
view(-60,30);
subplot(224)
contour3(X,Y,Z) % 3D-Höhenlinien-Plot
Bild 1.19: Beispiele dreidimensionaler Grafikvarianten
2. Beispiel: 3D-Grafikgestaltung mit den Functions cylinder und surf; vgl. [52]
% ---- D3p_2.m
t = 0:pi/10:2*pi; % Zeitvektor
[X,Y,Z] = cylinder(0.5*t.*cos(t)); % Zylinderdaten
figure(1)
clf reset
subplot(2,2,1) % 1. Grafik
% colormap hot % Rot-/Gelb-Töne
% colormap cool % Blautöne
% colormap(hsv(128))
surfc(X,Y,Z,’MeshStyle’,’row’)
surf(X,Y,Z,0.6*ones(size(Z))) % Mit Farb-Matrix
caxis([0 1]);
colorbar % Farblegende einblenden
surf(X,Y,Z,’EdgeColor’,’interp’,’FaceColor’,[0.7 0.7 0.7])
surf(X,Y,Z,’FaceLighting’,’phong’,...
’EdgeColor’,’none’,’AmbientStrength’,0.25)
1.6 Grafik 65
caxis([-1 1.25]);
colorbar
light(’Position’,[-2,2,10]) % Lichtposition x, y, z
lighting phong
Bild 1.20: Beispiele zur dreidimensionalen Grafikgestaltung
Auf die Farbgebung und Ausleuchtung im 2. Beispiel S. 64 wollen wir noch eingehen. Hierzu
gehören die Farboperationen (Color Operations)
caxis | colormap | colorbar
Die Colormaps (siehe Kommentarzeilen im Programmcode sowie gray, flag, spring usw.)
legen eine Farbtabelle mit vorgegebenen Farbtönen – u. a. aus rot (R), grün (G), blau (B) – fest;
vgl. Colorbar (Farblegende) in Bild 1.20. Diesen einzelnen Farbtönen sind Farbwerte zugeordnet,
deren kleinster und größter Wert automatisch auf C_farbe (Farbmatrix) bezogen wird. Die
Extremwerte der Farbtabelle können mit
caxis(farbe_min, farbe_max)
neu skaliert werden, so dass nur ein Ausschnitt aus der Colormap zur Objekteinfärbung dient; vgl.
Programmcode und Bild 1.20 zu Beispiel 2. Dadurch wird im 1. Bild von Bild 1.20 die gesamte
Farbpalette auf die Objekt-Höhe (z-Werte) bezogen. Im 2. Bild ist die Farbtabelle durch [0, 1]
begrenzt und über C_farbe = 0.6 ein Gelbton ausgewählt. Im 3. Bild ist eine eigens kreierte
FaceColor umgesetzt, die Colormap bezieht sich nur auf das Gitternetz (EdgeColor). Im 4. Bild
wird ein Ausschnitt der neu skalierten Colormap verwendet, das Gitternetz ist ausgeblendet.
Ein weiterer optischer Effekt wird durch die Ausleuchtung (Lighting), wie im 4. Bild von
Bild 1.20 und in Patch_Exp.m aus [52], erreicht; z. B. mit:
camlight Lichtposition headlight, right, left

light Lichtrichtung light(’Position’,
[1 0 0] , . . .
’local’
hier: x-Richtung ’Style’, )
’infinite’
lightangle Lichtposition in lightangle(az,el)
sphärische Koordinaten
lighting Ausleuchtungsart flat, gouraud, phong, none
material Materialreflektion shiny, dull, metal
Darüber hinaus stehen viele Eigenschaften für Lichteffekte wie z. B.
AmbientLightColor | DiffuseStrength | FaceLighting | EdgeLighting
BackFaceLighting | FaceColor | edgeColor ....
zur Verfügung. Deren Beschreibungen sind dem Help Browser zu entnehmen. In den hier be-
handelten Beispielen, insbesondere im Zusammenhang mit der Animation von Objekten, sind
einige Befehle in den Programmcodes in [52] enthalten, so dass hiermit die Auswirkungen auf
die Grafiken unmittelbar am Rechner nachvollziehbar sind.
Sollen die Objekte transparent sein, dann benötigt man die Eigenschaften transparency mit
alpha | alphamap | alim
Z. B.
surf(X,Y,Z)
alpha(’color’) % color=C_farbe
siehe auch Patch_Exp.m in [52].
1.7 Animation von 2D- und 3D-Modellen

Der Informationsgehalt einer auf dem Bildschirm dargestellten Bewegung u. a. bezüglich der
Kinematik, z. B. bei komplexen Getrieben oder zur Klärung von Schwingungserscheinungen,
übertrifft vielfach den eines einfachen Linien-Plots zur Ergebnisdarstellung. Die Visualisierung
von Bewegungsabläufen, die Animation, ist heute, ermöglicht durch die stetig steigende Rechner-
leistung, ein wesentliches Hilfsmittel zur Veranschaulichung einfacher und komplexer Vorgänge.
Modell-Optimierungen lassen sich anschaulich und schnell durchführen. In dieser Einführung
werden wesentliche Elemente zur Animation unter MATLAB zusammenstellt, auf einfache Bei-
spiele angewendet und in späteren Kapiteln vertieft.
1.7.1 Modellerstellung
MATLAB stellt eine Vielzahl von Möglichkeiten zur Darstellung von 2D- und 3D-Grafikobjekten
zur Verfügung; einige sind in den vorangegangenen Abschnitten genannt. Darüber hinaus ver-
1.7 Animation von 2D- und 3D-Modellen 67
feinert die Farbanlage und die Ausleuchtung der Modelle die Animations-Grafik. Wir konnten
bisher nur einige Eigenschaften anführen. Weitere Ansatzpunkte liefern die Beispiel-Programme
lin_ani_1.m, lin_ani_2.m, zyl_1.m, zyl_3DH.m (zyl_3D.m)
DrehSchw.m, QuerSchw_1/2/.m Demo-Programme zu Kapitel 3
mit ihren zugehörigen Functions aus [52]. Die dort verwendeten Eigenschaften (Properties) las-
sen sich bequem mit der Online-Hilfe interpretieren und vervollständigen. Folgende Built-In
Functions eignen sich zur Animation:
2D-Modelle (Linien, Flächen): 3D-Modelle (Oberflächen):
plot | line | patch | fill patch | fill3 | surf | surfl
patch, fill für farbig angelegte Flächen
1.7.2 Animations-Grafik
MATLAB unterstützt mehrere Vorgehensweisen zur Generierung einer Animations-Grafik, einer
Bildfolge:
1. Erstellung von Bildsequenzen u. a. mit plot-, plot3-, surf-Befehl. Gegebenenfalls sind die
Einzel-Bilder in hold on, hold off einzuschließen. Dies entspricht der bisher vorgestellten
Grafik-Erstellung, siehe Abschn. 1.7.2.1.
2. EraseMode-Methode: kontinuierliches Löschen und Erstellen der Grafik-Objekte auf dem

Bildschirm mit unterschiedlichen Eigenschaften bezüglich des Lösch- und Schreibvorgan-
ges.
3. Filmerstellung (Movie): Speichern einer Folge von Grafik-Objekten und anschließendes

Abspielen des Films mit der Built-In Function movie.
Die EraseMode-Methode eignet sich insbesondere für lange Sequenzen einfacher Plots. Die Zeit
des Frame-Aufbaus und die Bildqualität hängen vom EraseMode
{normal} | none | xor | background
ab. Wir geben einige Eigenschaften an:
• {normal}: Berechnet und zeichnet jedes Grafik-Objekt neu, dadurch grafisch hochwerti-
ge aber langsame Wiedergabe.
• none: Überschreibt das vorhandene Grafik-Objekt; es wird alles übereinander gezeichnet.
Das Bild kann nicht gedruckt werden, da keinerlei Information gespeichert wird.
• xor: Zeichnet und löscht pixelweise die Bildänderungen unter Einbezug der Exklusiv-Oder-
Logik (xor). D. h. nur Veränderungen werden neu dargestellt, dies ergibt einen sehr schnel-
len Bildschirmaufbau allerdings mit Qualitätsverlusten insbesondere bezüglich der Farbe.
• background: Hintergrundobjekte werden überschrieben, sie verschwinden auf dem Bild-
schirm.
Für eine Animation sind im Allgemeinen nur die Modi normal und xor geeignet. Werden die
Grafik-Objekte aufwendiger, dann kann der Zeitschritt für die Berechnung und Darstellung sehr
groß werden; wir erhalten keinen flüssigen Bewegungsablauf. In diesem Fall werden Einzelbilder
(Frames) mit
F(k) = getframe k = 1, 2, . . .
erzeugt, auf dem Bildschirm ausgegeben und in dem Structure M gespeichert. Mit movie(F)
werden 12 Frames pro Sekunde, vorausgesetzt der Rechner ist schnell genug, auf dem Bildschirm
gebracht.
Syntax
1. movie(F , n, fps)
2. movie(h, F, n, fps, loc)
zu 1: movie(F) spielt den Film (Frames von F) einmal ab, bzw. mit Option n n mal ab. Ist n
negativ, so wird der Ablauf zunächst rückwärts, dann vorwärts abgespielt. Ist n ein Vektor, dann
steht das erste Element für n, die restlichen für die Bilder (Frames) im Film, vgl. Abschn. 1.7.2.1.
Die Option fps steht für Frames pro Sekunde, die Obergrenze ist rechnerabhängig.
zu 2: movie(fign, F, [ ], [ ], [ 0.1 0.1 0 0]): Film wird in fign=figure(...) ab-
gespielt mit der Position der unteren linken Ecke (0.1 0.1); die beiden letzten Positionen
sind ohne Bedeutung. Optionen n, fps wie unter 1.
1.7.2.1 Einführendes Beispiel

Auf der Basis eines Flächenmodells – Anregung aus [7] – zeigen wir die Erzeugung der Bildfolge
einerseits mit den Mitteln der Plot-Befehle und andererseits mit der EraseMode-Methode sowie
Varianten der Filmabspielung. Zugehörige Programmschritte entstammen: ani_einleitung.m
aus [52]
Die Daten des Flächenmodells für beide Vorgehensweisen folgt mit:
[X,Y] = meshgrid(-8:.5:8,-8:.5:8);
Z = 1-(X.^2+Y.^2);
axis([-10 10 -10 10 -140 140]) % Achs-Vorgabe, hier zu klein
set(gca,’nextplot’,’replacechildren’) % ’replacechildren’ Modus
ds=1.0/21; % Skalierungs-Faktor, siehe später
In der dritten Zeile werden die zu erwartenden maximalen Achsmaße vorgegeben, die wegen des
folgenden ’replacechildren’ Modus – vgl. Abschn. 1.6.2.3 – dann festgeschrieben sind,
d. h. sie sind nicht mehr von den Datenwerten abhängig.
Zunächst verfolgen wir die Bildfolge innerhalb einer for-Schleife mit dem surf-Befehl,
for k = 0:21 % Bildfolge erstellen
as=1+k*ds; % Skalierung der x-, y-Werte
surf(as*X,as*Y,cos(2*pi*(k-1)/20).*Z,Z); % Bild
drawnow , pause(0.2) % Bildanzeige, Zeit-Verzögerung
end
Auf dem Bildschirm erscheint die zeitliche Veränderung der Fläche. Aufgrund der zu kleinen
x-,y-Achswerte in der obigen axis-Anweisung ist das Bild unvollständig, wie Bild 1.21 zeigt.
Die Werte in axis müssen geändert werden. Statt der drawnow Anweisung ist natürlich auch
die Speicherung der Filmdaten, wie unten, möglich.
Die zweite Methode arbeitet mit dem EraseMode Modus. Zunächst ist das Ausgangs-Flächen-
modell einem Handle (hier: h) zuzuweisen. Mit den zwei folgenden Zeilen erhalten wir, wie
a: b: c:
Bild 1.21: Bilderfolge zur surf-Anweisung
gehabt, eine neue Achs-Skalierung und den Modus zur Festschreibung dieser. Es folgt die Ein-
stellung des EraseMode, hier: ’none’. Die Erstellung der Bildfolge unterscheidet sich in der
for-Schleife in der set-Anweisung. Es werden die neuen Datensätze, u. a. as*X, dem Handle h
zugewiesen. Mit getframe erfolgt schließlich die elementweise Zuweisung der Film-Daten.
h=surf(X,Y,Z,Z); % Handle der Flächendarstellung

axis([-20 20 -20 20 -140 140]) % neue Achs-Skalierung, festgeschr.
set(gca,’nextplot’,’replacechildren’) % ’replacechildren’ Modus
set(h,’EraseMode’,’none’) % Einstellung: EraseMode ’none’
for k = 1:21 % Erstellung der Bildfolge
as=1+k*ds; % Skalierung der x-, y-Achsen
set(h,’xdata’,as*X,’ydata’,as*Y,’zdata’,cos(2*pi*(k-1)/20).*Z);
F(k)=getframe; % Filmdaten
end
Der Modus ’EraseMode’,’normal’ ist voreingestellt, d. h. die vierte Zeile set(h,..)

kann entfallen. In diesem Fall unterscheidet sich die Vorgehensweise nicht von der ersten.
Der Film (F) lässt sich auf unterschiedliche Weise abspielen. Drei Varianten geben wir an:
movie(F) % Film abspielen, 12 Bilder/sec

movie(F,4,24) % 4 Wiederholungen, 24 Bilder/sec
% Abspielen der durch den Vektor (1 2 ... 1) vorgegebene Bildfolge
movie(F,[3 1 2 3 4 5 6 6 6 6 5 4 3 2 1], 8) % 3 Wiederh., 8 Bilder/sec
wobei die Kommentarzeilen die Eingangsparameter erläutern.

Wesentlicher für den Ingenieur/Techniker ist die Erstellung und Animation von Linien-, Flächen-
und Volumenmodellen mit technischem Hintergrund. Anhand einfacher Beispiele sollen Metho-
den hierfür aufgezeigt und die zur Animation notwendigen Schritte erläutert werden.
1.7.3 2D-Animation einfacher Linien-Modelle
Erste Schritte zur Erstellung einfacher 2D-Animations-Linienmodelle wollen wir beispielorien-

tiert erarbeiten. Dazu legen wir das in Bild skizzierte Fachwerk, welches um den Knoten 1 eine
Schwenkbewegung [−π/4, π/4] ausführen soll, zugrunde.
Zum Linienmodell gehört die Knotenfolge (Polygonzug) 3

6
2 → 3 → 4 → 2 → 1 → 4
6y
und damit die zugehörigen Koordinatenvektoren 4.2
x = (2.2, 2.2, 1.1, 2.2, 0.0, 1.1) Φ (t) 4

6
y = (0.0, 4.2, 1.0, 0.0, 0.0, 1.0) y
1
u -
? ?
der Knoten. Die Plot-Anweisung 1 2 x
1.1 -1.1-
h=plot(xd, yd, ....) oder h=line(xd, yd, ....)
mit x , y → xd, yd zeichnet das Fachwerk in der Anfangslage. Für die zeitliche Verdrehung um
1 setzen wir
Φ = Φmax sin (2 t), 0 ≤ t ≤ 8π
an. Die zugehörigen Knoten-Koordinaten im x,y-System folgen dann mit der Drehmatrix T , siehe
(2.14), zu

x cos Φ − sin Φ
xT = T , T = .
y sin Φ cos Φ
Damit ist die oben angegebene Plotanweisung bezüglich x T zu jedem Zeitschritt zu wiederholen.
Dies erreichen wir mit
set(h, ’Xdata’,x_T(1,:), ’Ydata’,x_T(2,:))
für eine gewählte Zeitfolge (t1 , t2 , ...), so dass ein Bewegungsablauf erzeugt wird. Die beiden
Methoden: EraseMode, Movie sind in den folgenden Programmsegmenten programmiert:
EraseMode; Programm: lin_ani_1.m aus [52]
% EraseMode {normal} | none | xor | background; Standard: normal

set(h,’Erasemode’,’normal’); % Erasemode gesetzt
numframes=1000; % Anzahl Zeitschritte
t=linspace(0,2*pi*4,numframes); % Zeitvektor
for count=1:numframes, % t-Schritte
Phi=pi/4*sin(2*t(count)); % Zeitsignal
T=[cos(Phi) sin(Phi); -sin(Phi) cos(Phi)];% Drehmatrix
x_T=T*[xd;yd]; % gedrehte Koord.
set(h,’xdata’,x_T(1,:),’ydata’,x_T(2,:)); % Datenübergabe
drawnow; % Bildschirmaufbau
end;
Movie; Programm: lin_ani_1.m aus [52]
nframes=50; % Anzahl Zeitschritte

t=linspace(0,pi,nframes); % Zeitvektor
for count=1:nframes,
........ vier Zeilen wie oben ........
F(count) = getframe; % Frame-Erst. + Ausg.
end;
pause(0.5) % Zeitverzögerung
movie(F,8); % Vorlauf+8 Durchl.
Weitere Elemente lassen sich in die Animations-Grafik integrieren. Wir stellen ein Lager im
Knoten 1 in Form eines Dreiecks dar:
fill([0 0.25 -0.25 0],[0 -0.5 -0.5 0],[0 0.7 0]);
wobei der letzte Vektor für die gewählte Farbe steht. fill kann auch durch patch ersetzt werden.
Zusätzlich kennzeichnen wir den Bereich der Schwenkbewegung durch ein unterlegtes Kreisseg-
ment. Hierzu dient wieder der fill oder patch Befehl:
phi=-pi/4:pi/20:pi/4; % Winkelbereich
fill([0 2.2*cos(phi) 0],[0 2.2*sin(phi) 0],’y’,’FaceAlpha’,0.5)
Die Eigenschaft FaceAlpha sorgt für die Transparenz des Kreissegments. Diese Anweisungen
müssen hinter der ersten Plot-Anweisung und vor der Zeitschleife stehen, vgl. lin_ani_1.m
aus [52]. In Bild 1.22 ist eine Momentaufnahme der Animation dargestellt.
Bild 1.22: Momentaufnahme der Animation mit dem einfachen Fachwerk
Übungsvorschlag: Die in Bild 1.23 skizzierte masselose Schraubenfeder wird an ihren Enden
durch die Zeitfunktionen
ul (t) = 10 + 5 sin (15 t) [LE], ur (t) = 20 cos (2 t) [LE]
ausgelenkt. Die Feder hat 5 Windungen (w = 5), in der entspannten Lage die Länge l0 = 52 [LE]
und den Windungsradius von R = 10 [LE]. Dabei steht LE für Längeneinheit, mm oder cm sind
realistisch. Durchmesseränderungen infolge der Längsverformungen sind zu vernachlässigen.
In einer Animation ist die Federdeformation zu veranschaulichen. Dazu ist in einem ersten
Schritt die Feder zum Zeitpunkt t = 0, wie in Bild 1.23 unten, per Plot-Anweisungen darzustellen,
im zweiten Schritt ist die zeitliche Verformung zu integrieren.
In [52] ist mit dem Programm feder_ani.m eine Lösung angegeben, in Pendel_q.m zu
Kapitel 5 ist die Feder in ein Animationsmodell eingebunden.
Bild 1.23: Zum Übungsvorschlag: Un- und verformte Feder mit Bezeichnungen
1.7.3.1 Erstellung komplexer Linien-Modelle
Für das einfache Fachwerk ließ sich ein geschlossener Polygonzug erzeugen, so dass die Plot-
Koordinaten einfach anzugeben waren. Ist dies nicht mehr möglich, dann liefert die Functi-
on gplot Generierungsmöglichkeiten aus einfach zu erstellender Information. gplot erstellt x , y -
Vektoren zur grafischen Darstellung eines Gitternetzes mit n Knoten nach grafentheoretischen
Gesichtspunkten. Hierzu müssen in einer B OOLEschen Matrix (z. B. A ) die Knotenverbingun-
gen des i-ten mit dem j-ten Knoten (ai, j ) einschließlich des Koordinatenursprungs (a1,1 ) und in
einer weiteren zweispaltigen Matrix die x, y-Koordinaten (Längenangaben) festgeschrieben wer-
den. Diese Beschreibung ist nicht eindeutig; es werden Verbindungen mehrfach gezeichnet, was
von der Struktur der Verbindungen abhängt. In A können Verbindungen oder Knoten mehrfach
benannt werden. Wir wollen dies auf das bereits behandelte Fachwerk anwenden. Es sind die
Matrix der Verbindungen und die der Knoten-Koordinaten zu erstellen.
Matrix A der Verbindungen i → j (eine Möglichkeit), i = j = 1 Koordinatenursprung:
⎡ ⎤
1 1 0 Koordinatenursprung Knoten 1, Knotenverbindung: 1 → 2
⎢ 0 0 0 ⎥ keine Verbindungen 2 → 2
A =⎢ ⎣ 0 1 0 ⎦
⎥
Knotenverbindung: 3 → 2
1 1 1 Knotenverbindungen: 4 → 1, 4 → 2, 4 → 3
Knoten-Koordinaten:
⎡ ⎤
0,0 0,0 Knoten 1
⎢ 2,2 0,0 ⎥ Knoten 2
xy = ⎢
⎣ 2,2 4,2
⎥
⎦ Knoten 3
1,1 1,0 Knoten 4
Die Plot-Daten werden nun mit

[x,y] = gplot(A,xy); % für die Ausgangslage
erzeugt und wie zuvor mit plot grafisch ausgegeben. Einzelheiten und weitere Lösungsansätze zu
dieser Vorgehensweise sind im Programm lin_ani_2.m in [52] nachzulesen.
1.7.4 Animation mit geometrischen 3D-Modellen

Die Modellierung und Animation in 3D-Darstellung sollen anhand zweier Modelle erarbeitet
werden. Dabei gehen wir einerseits von einer geometrischen Modellierung mit Linienelemen-
ten in Form von Polygonzügen und andererseits mit MATLAB-Basiselementen, wie Zylindern,
Kugeln usw., aus.
1.7.4.1 Zylindrisches Wellenelement

Zunächst betrachten wir ein zylindrisches Wellen- bzw. Rotormodell, welches eine vorgegebene
Drehbewegung ausführen soll. Rotoren und aufgesetzte Scheiben setzen sich in der Regel aus
einzelnen Zylinderelementen und den zugehörigen Stirnflächen zusammen, ein solches Element
wollen wir mit Linienelementen erstellen.
Zur Generierung legen wir das 3D-Koordinatensystem (xM , yM , zM ) in normaler Orientie-
rung nach MATLAB (vgl. XDir, YDir, ZDir) zugrunde, vgl. Bild 1.24. Die xM -Richtung soll
y
6zM , y xM , z 3 6 xk = R cos Θk
yM , x O
Breite
I * R yk = R sin Θk
3
+ 2 x

+ 1
Θk+1 Θk
Bild 1.24: Orientierung des 3D-Koordinatensystems und Breite der Mantelflächen
der Zylinderlängsachse und die yM -, zM -Achsen den Querachsen der Zylinderelemente zugeord-
net werden. Gedanklich führen wir eine Umbenennung der Achsen, wie in Bild 1.24, in (x, y, z)
durch. Wir betrachten die Erstellung eines Zylinders der Länge 2 , der im Abstand 1 auf der
z-Achse nach Bild 1.24 beginnt. Der Zylinder besteht aus dem äußeren Mantel sowie den bei-
den Stirnflächen, evtl. noch mit einer Bohrung für ein gleich großes Anschlusselement versehen.
Darüber hinaus soll eine optisch günstige Nullmarke zur Beobachtung von Drehschwingungen
festgelegt und grafische eingebracht werden. Im Folgenden beschreiben wir die Vorgehensweisen
für die drei Elemente: Mantelfläche, Stirnflächen, Null-Marke.
Mantelfläche des Zylinders

Der Zylindermantel wird aus N Rechteckflächen der Länge 2 und der Breite 2R sin (ΔΘ /2),
wobei R der Zylinder-Radius und ΔΘ das Winkelinkrement ist, erstellt. Die Orientierung der
Kreissegmente in der x, y-Ebene ist in Bild 1.24 festgeschrieben. Die Θ -Folge und die benötigten
Koordinaten generieren wir in MATLAB durch folgendes Programmsegment
R=10; l1=2; l2=12; % Zyl.-Parameter
N=20; % Unterteilungsgrad
theta=linspace(0,2*pi,N); % N-1 Winkelelemente
theta=theta+pi; % neue Null-Lage, wegen Optik
Rz=[R;R]; % Radien-Vektor
xz=Rz*cos(theta); % x-Koordinaten
yz=Rz*sin(theta); % y-Koordinaten
zz=[l1;l1+l2]*ones(1,size(xz,2)); % z-Koordinaten,[rechts; links]
Die grafische Darstellung erfolgt durch

cz=0.5; % Farbgebung
surf(zz,xz,yz,cz*ones(size(xz))); % Zylinder-Erzeugung+Farbe
wobei cz die einheitliche Zylinderfärbung festlegt. Bild 1.25 a zeigt das bisherige Ergebnis
10 10
5
5
0
0
−5
−5
−10
10 5
5
10 0 10
0
−5 −5
5 5
−10 −10
0 0
a: Zylindermantel b: Stirnflächen mit Null-Marke
Bild 1.25: Zylinderelemente
Stirnflächen
Die Stirnfläche setzt sich wie in Bild 1.26 aus approximierten Kreisausschnitten (Polygonzug)
zusammen, wobei wir von einem Anschlusselement bzw. Hohlzylinder mit dem inneren Radius
r ausgehen. Der Polygonzug 1, 2, 3, 4 nach Bild 1.26 beider Stirnflächen des Zylinders hat die
y
3s 6
* r
2 s R
4 s
s
1
x
Θk+1 Θk
Bild 1.26: Zur Erstellung der Stirnfläche
x-Koordinaten
xk1 = r cos Θk , xk2 = R cos Θk , xk3 = R cos Θk+1 , xk4 = r cos Θk+1
mit Θk+1 = Θk + ΔΘ , was wir – ergänzt um die y-Koordinaten – als dyadisches Produkt
⎡ ⎤ ⎡ ⎤
r r
⎢ R ⎥ ⎢ ⎥
x =⎢ ⎥ cos Θk , cos Θk+1 , y = ⎢ R ⎥ sin Θk , sin Θk+1
⎣ R ⎦ ⎣ R ⎦
r r
schreiben. N − 1 solcher Elemente ergeben die Stirnflächen nach Bild 1.25 b, die sich mit den
folgenden MATLAB Anweisungen erzeugen lassen:
r=2; % Innen-Radius
c=2; % Farbinformation
for k=1:N-1 % N-1 Sektoren
x=[r R R r]’*cos(theta(k:k+1)); % Stirnflächen-Sektoren
y=[r R R r]’*sin(theta(k:k+1));
surf(zz(1)*ones(size(x)),x,y,c*ones(size(x))); % Stirnfl. vorne
hold on
surf(zz(2)*ones(size(x)),x,y,c*ones(size(x))); % Stirnfl. hinten
end
Kennzeichnung der Null-Marke
Für die Null-Marke wählen wir eine einfache Rechteckfläche der Breite r mit hervorgehobener
Umrandung, vgl. Bild 1.25 b. Sie ist in der neuen Null-Lage an der Zylinderaußenwand positio-
niert, macht aber die Drehung nicht mit.
x1a=[R+r R R R+r]*cos(theta(1)); % Koordinaten

y1a=[R+r R R R+r]*sin(theta(1));
z1a=[zz(1) zz(1) zz(2) zz(2)];
fill3(z1a,x1a,y1a,’y’,’edgecolor’,’k’,’linewidth’,2);
10
−5
−10
10
5
0 10
−5 5
−10
0
Bild 1.27: Komplettes Zylinderelement

Animation von Drehbewegungen

Mittels Animation wollen wir einerseits Verdrehungen des Starrkörpers und andererseits Verfor-
mungen des Zylinders durch gegenseitiges Verdrehen der Zylinderstirnseiten verdeutlichen. Im
Hinblick auf Probleme der Schwingungstechnik führen wir für die Extremlagen der Verdrehun-
gen Verformungsvektoren (Eigenvektoren) ein. Sind mehrere Zustände zu simulieren, dann fas-
sen wir sie spaltenweise zu einer Matrix (Modalmatrix) zusammen. Für unser Vorhaben bedeutet
dies:

ϕ11 ϕ21 z. B. 0.25 0.25
V = = ,
ϕ12 ϕ22 0.25 −0.25
d. h. zur ersten Spalte gehört die Starrkörperbewegung mit ϕmax = 0.25 rad, zur zweiten Spalte
die gegenseitige Verdrehung der Zylinderstirnflächen mit ϕmax = 0.5 rad. Überlagern wir den
einzelnen Moden (Spalten von V ) das Zeitsignal
2π 2π
w(tk ) = a sin (k ), k = 0, 1, 2 . . . , kmax , tk = k , a Verstärkung,
kmax kmax
dann erhalten wir die Winkelfolge

ϕn1 k
Φ n (k) = a sin (2π ), n = 1, 2 .
ϕn2 kmax
Hiermit wird jedes zu bewegende Element des Zylinders beaufschlagt. Für die Bewegung der
Zylindermantelfläche bedeutet dies: Φ n (k) geht additiv in den Sektorvektor Θ jetzt aber getrennt
für beide Stirnseiten ein, wie im Programmsegment zur Mantelfläche:
% theta Sektoren-Vektor % bereits berechnet
V=[0.25 0.25 ;0.25 -0.25]; % Max.-Verformungen, zwei Moden
kmax=30; a=1; h=2*pi/kmax; % Schritte, Verst., Schrittw.
for k=0:kmax % Bewegungsschritte
w=a*sin(k*h); % Anregungssignal
ang=V(:,1)*w; % Winkelinkrement, Mode 1
costh1=cos(theta+ang(1)); % Abkürzungen
costh2=cos(theta+ang(2));
sinth1=sin(theta+ang(1));
sinth2=sin(theta+ang(2));
xz = [Rz(1)*costh1; Rz(2)*costh2]; % x-Koordinate

yz = [Rz(1)*sinth1; Rz(2)*sinth2]; % y-Koordinate
zz = [l1;l1+l2]*ones(1,size(xz,2));% z-Koordinate
%---- zeichne äußeren Zylinder
surf(zz,xz,yz,cz*ones(size(zz)));
if k==0, ax=axis; else axis(ax); end
F=getframe; % Bilderfolge
end
Für jede Position wird mit getframe ein Frame erzeugt und hier in F abgespeichert, so dass für
die Animation eine Bildfolge vorliegt, die mit: movie(F,Optionen) abgespielt werden kann.
Eine Momentaufnahme der gegenläufigen Bewegung ist in Bild 1.28 dargestellt. Die aufgeführ-
Bild 1.28: Animation mit gegenläufiger Verdrehung der Stirnseiten
ten Programmteile sind Bestandteil des Programmpakets [52] mit der Struktur nach Bild 1.29.
Es setzt sich aus dem Hauptprogramm zyl_3DH.m sowie der Function zyl_3D.m, in die
draw_zyl eingebettet ist, zusammen.
zyl_3DH.m zyl_3D.m
- - draw_zyl.m
Modalmatrix (Drehung) Zylinder-Initial.
Speicher-, Grafik- Grafik-
Zeitprofil
Eigenschaften Elemente
Animation
Hauptprogramm Function
Bild 1.29: Programmstruktur für Rotoranimation
1.7.4.2 3D-Modelle mit MATLAB-Basiselementen

In MATLAB bieten sich drei Functions einfacher Volumenobjekte, Zylinder, Kugel und Ellipsoid,
zur Modellierung an. Die zugehörigen Koordinatensätze werden in einfachster Form mit
[x,y,z] = cylinder; % Zylindermantelfläche, Länge/Radius 1
[x,y,z] = sphere; % Kugel, Radius 1
[x,y,z] = ellipsoid(xc,yc,zc,xr,yr,zr); % z.B. (0,0,0,1.5,1.2,1)
erstellt. Die jeweilige Volumendarstellung kann danach mit einer der Anweisungen
mesh(x,y,z) % Gitterdarstellung
surf(x,y,z) % Raumfläche
erfolgen. Diese Grundformen lassen sich durch anschließende Bearbeitung einzelner oder aller
Koordinatensätze modifizieren. So können mit dem cylinder-Objekt allgemeinere Rotationskör-
per erstellt werden. Dazu wird die Kontur des Ausgangsobjekts in Form der Radien in einem Pa-
rametervektor als Eingang formuliert. Die damit erhaltenen Elemente sind äquidistant auf der Ro-
tationsachse (z-Bereich [0,1]) aneinandergereiht. Durch Anpassung der x-,y-,z-Werte sind dann
die Koordinaten des gewünschten Modells zu erstellen. Dies kann mit den Modellen in Bild. 1.30
und den Programmschritten:
[x1,y1,z1]=cylinder([0.5 0.5],10); % Zylindermantel

[x2,y2,z2]=cylinder([0.5,0],10); % Kegel
[x3,y3,z3]=cylinder([1,0.5,0],10); % Kegelstumpf
z3([2,3],:) = 2.0; % Koord.-Korr., Länge 2
[x4,y4,z4]=cylinder([1,1,0.5,0.5,1],10); % Ring
z4([2,3],:)=2.0; % Koordinaten-Anpassung
z4([4,5],:)=0;
figure(1)
subplot(3,4,1)
mesh(x1,y1,z1,’EdgeColor’,’k’); % Zylindermantel
axis equal, axis off
subplot(3,4,2)
mesh(x2,y2,2*z2,’EdgeColor’,’k’); % Kegel
subplot(3,4,3)
mesh(x3,y3,z3,’EdgeColor’,’k’); % Kegelstumpf
subplot(3,4,4)
mesh(x4,y4,z4,’EdgeColor’,’k’); % Ring, Hohlwelle
nachempfunden werden, dabei enthalten die Elemente jeweils 10 Teilflächen.
Bild 1.30: Zylinder-Objekte: Zylinder, Kegel, Kegelstumpf, Ring
Der Koordinatenursprung liegt ursprünglich im Zentrum der Basisfläche, die z-Achse ist die
Rotationsachse. Die Rotationsachse kann durch Vertauschen der Koordinatensätze u. a. im mesh-
Aufruf auch beliebig zugeordnet werden. Zur Größenänderungen und/oder Verschiebungen wer-
den die Koordinatensätze additiv und/oder multiplikativ verändert, vgl. Kegel im obigen Pro-
gramm. Änderungen der Orientierungen lassen sich auch nachträglich mit der Function rotate
erreichen, die Grafikobjekte können damit um beliebige Winkel im Raum gedreht werden.
Anwendung: Pendel und gekoppeltes Parallelpendel

Auf der Basis der oben eingeführten geometrischen Objekte wollen wir anhand der in Bild 1.31 in
der x-,z-Ebene dargestellten 3D-Modelle die Programmierung besprechen – Anregungen aus [7].
Die Pendel-Längen seien L = 10 LE (Längen-Einheiten), die Endmassen haben einen Radius

rK = 1 LE, der Abstand zur Federanlenkung sei L f = 5 LE, der Pendellagerabstand beträgt 6 LE,
die dreidimensionale Federdarstellung soll 8 Windungen und einen Durchmesser von 2r f = 1
LE haben. Alle anderen Abmessungen sind frei wählbar. Der Koordinatenursprung befinde sich
in dem/einem Pendellager.
a: Einfach-Pendel b: Gekoppelte Parallelpendel
Bild 1.31: Zwei Pendel-Ausführung zur Modellierung mit Basisobjekten
Einfach-Pendel
Das Pendel-Modell besteht aus der Aufhängung, dem Lager-Element, dem Pendelstab mit der La-
geranbindung, dem Lagerzapfen und der Kugel als Pendel-Endmasse. Bis auf die Kugel wurden
nur Zylinderelemente verwendet.
Die Aufhängung des Pendels besteht aus aneiandergereihte Zylinder-Elemente mit dem Radi-
envektor [0.3 1 7 7] , dies führt auf:
[x,y,z] = cylinder([0.3 1 7 7]); % Zylinderelemente
al=0.2; % Lagerversatz
h0=surf(x,y,z+al); hold on % Grafik der Zylinderelemente
set(h0,’EdgeAlpha’,0,’FaceColor’,0.9*[1 1 1]); % Farbgebung
Der Lagerversatz al sorgt dafür, dass der Koordinatenursprung ins Pendellager fällt. Das
Lager stellen wir als Hohlzylinder der Länge 0.5 LE dar. Die Drehachse ist die y-Achse. Dement-
sprechend ist das Lager zu orientieren. Dies erreichen wir im unteren Programmsegment durch
Vertauschen und Verschieben der Koordinatensätze in der surf-Anweisung.
[x,y,z]=cylinder(0.3*[1 1 0.6 0.6 1]); % Ausgangsform des Lager
z([2,3],:)=0.5; % Zylinderlänge + Stirnfläche
z([4,5],:)=0; % fehlende Stirnfläche + Bohrung
hz=surf(y,z-0.25,x); % Lager in endgültiger Position
set(hz,’EdgeColor’,’k’,’FaceColor’,’k’); % Farbanlage
Im nächsten Schritt betrachten wir den Lager-Zapfen und das Pendel mit der Orientierung des
obigen Lagers:
colorp=[0.75 1. 1.]; % Pendelstabfarbe

% ---- Lager-Zapfen
rpl=0.18; % Lagerzapfen-Radius
ll=0.5; % Lager-Zapfenlänge
[x,y,z] = cylinder([0 rpl rpl 0]); % Lager-Zapfendaten
z([1,2],:)=0; z([3,4],:)=ll; % Elementlänge + Stirnflächen
hpl=surf(y, z-ll/2, x); % Darstellung + Orientierung
% ---- Pendel
rp=0.1; % Stabradius
rk=1; % Kugelradius, Pendelendmasse
L=[0 0 -10]; % Pendellänge, Kugelmittelpunkt
l = sqrt(L*L’); % Betrag der Stablänge
[x,y,z] = cylinder([rp rp]); % Rund-Stab der Länge 1
z = -(l-0.3)*z; % Stablänge ab Lagerrand
hp=surf(x, y, z-0.3); % Pendel-Stab, Ansatz am unteren
% Lagerrand (wegen Optik)
set([hp, hpl],’EdgeAlpha’,0,’FaceColor’,colorp);
Hervorzuheben ist die set-Anweisung, in der mehrere Handles vektoriell zusammengefasst
werden können. Um den Aufwand für eine Animation zu reduzieren, könnte der Zapfen entfallen.
Die Pendel-Endmasse soll als Kugel (Radius 1 LE) dargestellt werden. Dies führt auf:
color=[0 0.75 1.0]; % Farbe der Kugel
[x,y,z]=sphere; % Koordinaten der Kugel
hk=surf(L(1)+rk*x,L(2)+rk*y,L(3)+rk*z); % Kugelfläche
set(hk,’EdgeAlpha’,0.,’FaceColor’,color); % Farbanlage
Die Position und der gegebene Radius rk wird in der surf-Anweisung angepasst. Die Achs-
skalierungen können u. a durch den xlim-Befehl festgeschrieben werden. Für die Ausleuchtung
verwenden wir camlight und lighting gouraud sowie für die Ansicht view(0,0), nachzulesen in
E_Pendel.m in [52].
Die Animation, d. h. die Pendelung um die y−Achse, formulieren wir mit der Function: ro-
tate. Hiermit können Objekte (hier: hp, hpl, hk) bezüglich eines definierten Ursprungs (hier:
Drehung um die y-Achse [0 1 0]) um vorgegebene Winkel verdreht werden.
A=pi/36; n=240; % Amplitude, Winkelschritte
for k=1:n
phi=A*cos(k*pi/24); % Winkel-Dekrement
rotate([hp, hpl, hk],[0 1 0],...
phi*180/pi,[0 0 0]); % Rotation um y-Achse
drawnow % Bild-Darstellung
end;
Gekoppelte Parallelpendel
Grundsätzlich können die obigen Programmschritte direkt übernommen werden. Zweckmäßig
ist dabei die Einbindung in einzelne Functions – z. B. Feder –, wie in P_Pendel.m [52] er-
folgt. Die Pendelaufhängung, das Lagerelement sowie die Federanlenkung sind hier Zylinder.
Zwischen den beiden Pendeln besteht der Abstand von 6 LE. Die Kopplung erfolgt über eine
Schraubenfeder. Vorausgesetzt wird, dass deren Durchmesser (2 r f ) infolge Längs-Verformungen
konstant bleibt. Neu ist lediglich die 3D-Darstellung der Koppelfeder, wir geben sie deshalb an:
1.8 Computeralgebra unter MATLAB, die Symbolic Math Toolbox 81
function Feder(a, b, e, rf, LW)

% a Federende
% b zweites Federende
% e Lände des Federanfangs (Geradenelement)
% rf Federradius, hier konstant, unabhängig von Verformung
% LW Linienstärke, entspricht Drahtdurchmesser
PHI = 16*pi; % 8 Windungen, Winkel 2*pi*8
d = b-a; % akt. Lage, Federenden
l = sqrt(d*d’); % Federlänge
L = l-2*e; % Länge der Windungen
winkel = linspace(0,PHI,400); % Winkeldekrement
x = [0 e linspace(e,l-e,400) l-e l]+a(1); % x-Koordinatensatz
y = [0 0 rf*cos(winkel) 0 0]+a(2); % y-Koordinatensatz
z = [0 0 rf*sin(winkel) 0 0]+a(3); % z-Koordinatensatz
plot3(x,y,z,’-k’,’LineWidth’,LW); % Darstellung der Feder
1.8 Computeralgebra unter MATLAB, die Symbolic Math Toolbox
Die Symbolic Math Toolbox ermöglicht die symbolische, d. h. exakte Behandlung mathemati-
scher Probleme in der MATLAB-Umgebung. Wir unterscheiden arithmetische (numerische) Al-
gorithmen und algebraische (symbolische) Algorithmen. Der grundlegende Unterschied ist in
Tabelle 1.1 angedeutet. In der linken Hälfte ist der bekannte Ablauf einer numerischen Rech-
nung dargestellt. In der rechten Hälfte wird mit symbolischen Variablen, die zunächst vereinbart
werden müssen, gearbeitet.
Tabelle 1.1: Gegenüberstellung numerischer und symbolischer Ausdrücke
numerisches Rechnen symbolisches Rechnen

>> a = 2.5; b = 3.0; >> syms a b
>> c = (a + b)^3 >> c = (a + b)^3;
>> expand(c)
c = ans =
166.3750 a^3 + 3*a^2*b + 3*a*b^2 + b^3
Basis der Toolboxen ist ab der Version 2008b7 das Computeralgebrasystem MuPAD (Mul-
ti Processing Algebra Data Tool) mit der MuPAD Engine. Ursprünglich von der MuPAD-For-
schungsgruppe an der Universität Paderborn entwickelt. Heute ausschließlich Bestandteil der
Symbolic Math Toolbox.
7 vor 2008b das Computeralgebra-System Maple

Die Toolbox enthält die MuPAD-Sprache, die für symbolische,

mathematische Ausdrücke optimiert ist. Damit lassen sich die
vorhandenen Bibliotheken anwendungsspezifisch ausbauen.
Hierfür existiert ein eigener Editor. Alle Functions können aus
der MATLAB Command Zeile oder aus der MuPAD Notebook
Umgebung ausgeführt werden. Ein neues Notebook wird aus
MATLAB mit der Eingabe
>> mupad Beispiel im Notebook
oder aus dem Startmenü über Toolboxes/Symbolic Math/MuPAD geöffnet. Die Oberfläche
enthält ein Command Window und eine Command Bar mit vielen Operatoren mit Platzhaltern.
Eine Deklaration der symbolischen Variablen ist nicht nötig, wie der Ausschnitt des obigen Bei-
spiels zeigt.
Unser Schwerpunkt wird u. a. die symbolische Herleitung von Bewegungsgleichungen und
deren numerische Auswertung sein. Hierzu wollen wir hier einige Elemente der Symbolic Math
Toolbox, die für unsere Betrachtung wesentlich sind, kennen lernen. Einen Ausschnitt der ma-
thematischen Themen, denen die verfügbaren Functions zugeordnet werden, zeigt Tabelle 1.2.
Tabelle 1.2: Themen der Symbolic Math Toolbox
Zuordnung Operationen
Analysis Differenziation, Integration, Grenzwertbildung,
Summation, TAYLOR-Polynome
Lineare Algebra Determinante, Inverse, Eigenwerte,
Singulärwerte SVD, kanonische Formen
Lösen von Gleichungs- Symbolische und numerische Lösungen linearer
systemen algebraischer Gleichungen und Differenzialgleichungen
Spezielle mathematische Spezielle Funktionen der klassischen angewandten
Funktionen Mathematik, z. B. Cos-Integral
Variable Exaktheits-Arithmetik Numerische Auswertung mathematischer
Ausdrücke unterschiedlicher Genauigkeit
Transformationen Fourier-, Laplace-, z-Transformationen
mit zugehörigen inversen Transformationen
Einen ergänzenden Überblick geben die MATLAB-Demo-Beispiele. Sie werden mit der Com-
mand-Zeile >> symdemos im Help Browser einsehbar und lassen sich hieraus auch starten.
Die zugehörigen M-Files sym...demo.m stehen im MATLAB-Verzeichnis ...\toolbox\sym-
bolic.
1.8.1 Online-Hilfe
Einen Überblick bezüglich des vollständigen Function-Angebots - gegenüber Tabelle 1.2 - erhal-
ten wir mit
⇒ >> help symbolic oder >> helpwin symbolic oder >> doc symbolic
Die Symbolic Math Toolbox overloads viele numerische Functions von MATLAB, d. h. die sym-
bolische und die numerische Function hat den gleichen Function-Namen. Wenn solche existieren,
dann lautet der Online-Hilfe-Aufruf bezüglich der symbolischen Function help sym/function
Beispiel: >> help diff % numerische Version von diff
>> help sym/diff % symbolische Version von diff
Ob zu einer numerischen Version eine symbolische existiert, wird am Ende der Hilfe-Ausgabe,
z. B. für >> help diff durch
....... .......
Overloaded methods
help sym/diff.m
help char/diff.m
angezeigt; es existieren (je nach implementierten Toolboxen) hier zwei weitere diff Befehle und
zwar der Klasse (class) sym und char.
1.8.2 Symbolische Objekte

Den symbolischen Objekten ist der Datentyp sym zugeordnet. Ein sym Objekt ist eine Da-
tenstruktur, welche ein String des Symbols darstellt. Es existieren symbolische Objekte, die
symbolische Variable, Ausdrücke und Matrizen repräsentieren. Den Unterschied zum MATLAB-
Standarddatentyp double zeigen die beiden Beispiele
>> a = sqrt(2) >> a = sqrt(sym(2))
a = 1.4142 % class(a) → double a = 2ˆ(1/2) % class(a) → sym
Einerseits ist a eine numerische Variable vom Typ double und andererseits eine symbolische
Variable vom Typ sym, also ein exakter Ausdruck. Die symbolische Variable a wird u. a. durch
>> double(a) % Daten-Konvertierung sym → double
in eine numerische gewandelt, wie später noch ausführlich erläutert.
1.8.3 Vereinbarung symbolischer Variablen und Ausdrücke (Objekte)

Wie oben gesehen, müssen symbolische Objekte vereinbart werden:
>> a = sym(’a’), b = sym(’b’), c = sym(’c’), x = sym(’x’)
oder kurz
>> syms a b c x,
wobei angenommen wird, dass sie u. a. auch komplex seien. Die Deklarationen mit den Optionen
real, unreal, positive schränken den Wertebereich der symbolischen Variablen ein, z. B.
>> x=sym(’x’,’real’); w=sym(’w’,’positive’);
oder
>> syms x a real usw.
Durch die Eingabe von syms werden alle vereinbarten symbolischen Variablen angezeigt. Ein
symbolischer Ausdruck f lautet
>> f = sym(’ u*zˆ2 + v * z + w ’).
Die symbolischen Elemente einer Matrix bzw. Vektors generiert man wie folgt:
>> A=sym(’a’,[2,3]) >> A=sym(’a%d%d’,[2,3]) >> b=sym(’b_%d_%d’,[1,3])
dabei steht das erste Argument für den Elementnamen mit einer Darstellungsvereinbarung:
A = A = b =
[ a1_1, a1_2, a1_3] [ a11, a12, a13] [ b_1_1, b_1_2, b_1_3]
[ a2_1, a2_2, a2_3] [ a21, a22, a23]
Allgemein: Steht rechts vom Gleichheitszeichen eine symbolische Größe, dann ist auch die linke
Seite (ohne vorangegangene Vereinbarung) ein symbolisches Objekt, z. B.
>> g = 5 % class(g) double
>> a = sym(’a’); g = a % class (g) sym .
Das Auffinden aller symbolischer Variablen in einem Ausdruck f erfolgt mit
>> findsym(f)
Standardmäßig benutzt die Symbolic Math Toolbox eine exakte Symbolik-Arithmetik. Wer-
den numerische Variable mit der sym Function vereinbart, dann wird die rationale Arithmetik
aufgerufen und konvertiert eine Variable sowie eine Matrix vom Typ double in die symboli-
sche Form.
Beispiel: gegeben sei die Matrix A, gesucht ist die symbolische Form S
>> A = [ 1.1000 1.2000 % class double
2.1000 2.2000 ];
>> S = sym(A)
S = % class sym
[ 11/10, 6/5 ]
[ 21/10, 11/5 ]
Die Elemente von S werden durch rationale Zahlen, d. h. Brüche mit Integerzahlen (hier klein),
dargestellt. Existieren keine rationale Zahlen, so können sie durch Gleitkommazahlen (floating-
point) in symbolischer Form dargestellt werden. Die Matrix
>> E = [ exp(1) pi ; sqrt(2) rand]
liefert die numerische Form (class(E) double)
E =
2.7183e+000 3.1416e+000
1.4142e+000 2.3114e-001
und ihre symbolische Form
>> sym(E) entspricht >> sym(E,’r’)
ans =
[3060513257434037/1125899906842624, pi]
[ 2^(1/2), 2953193568373273/4503599627370496]
Optional kann durch ein zweites Argument im Aufruf von sym zwischen vier Darstellungen
unterschieden werden:
Arg. Darstellung Befehl Ergebnis

f Gleitkomma sym(1/3,’f’) 6004799503160661/18014398509481984
r Rational (Standard) sym(1/3,’r’) 1/3
d Dezimal sym(1/3,’d’) .33333333333333331482961625624739
e Rat. + Abweich. sym(1/3,’e’) 1/3-eps/12
Darüber hinaus steht unter MATLAB die Variable Precision Arithmetic (vpa), in der Regel zur
hochgenauen Berechnung symbolischer Ausdrücke, zur Verfügung. Es können symbolische Zah-
lenwerte im Gleitkommaformat mit vorgebbarer Stellenzahl dargestellt und bearbeitet werden;
z. B.: vpa(pi*7.38). Das Ergebnis erscheint standardmäßig mit 32 Stellen. Eine abweichende
Stellenzahl iz wird mit
digits(iz), z. B. >> digits(40)
berücksichtigt.
1.8.4 Substitution symbolischer und numerischer Größen, der subs Befehl

Substitution einer symbolischen Variable durch einen numerischen Wert oder durch eine ande-
re symbolische Variable oder Ausdruck erfolgt mit dem subs Befehl (vgl. auch Abschn. 1.8.9),
dieser ist sehr vielseitig. Beispiel: gegeben sei ein symbolischer Ausdruck h(x) in dem x = 2 zu
setzen ist
>> x=sym(’x’); h = 2 * xˆ2 - 3*x + 1 % h class sym
>> subs(h,2) oder >> subs(h,x,2) % class double ,
d. h. ersetze im Ausdruck h die Variable x durch 2. Da x die symbolische Standardvariable
(default) und darüber hinaus die einzige Variable ist, liefern beide Argumente in subs das glei-
che Ergebnis.
Definition der symbolischen Standardvariablen: Wird u. a. bei der Substitution keine Variable
im Argument von subs angegeben, dann ermittelt MATLAB die Standard-Variable nach folgen-
der Regel: Als Standard-Variable wird die Variable (Buchstabe) gewählt, die dem x am nächsten
im Alphabet steht. Sind zwei gleich weit entfernt, wird der hinter dem x stehende gewählt. Vor-
ausgesetzt die Variable besteht aus nur einem Buchstaben!
Mit dem findsym Befehl lassen sich die Standardvariablen in jedem Fall ermitteln. Beispiel:
>> syms s t, g = s + t; findsym(g,1) % 1-te Standard-Var.
Die meisten Befehle der Symbolic Math Toolbox ermöglichen ein Überschreiben der Standard-
variablen x. Beispiel:
>> f = ’aˆ2*xˆ2 + b*x + c’; % class char, oder
>> f = sym(’aˆ2*xˆ2 + b x + c’); % class sym, beides möglich
>> diff(f,’a’) % ∂ f / ∂ a, Standardvariable überschrieben
ans= 2*a*xˆ2
>> diff(f,’a’,2) % ∂ 2 f / ∂ a2 , zweite partielle Ableitung nach a
ans= 2*xˆ2
1.8.5 Beispiele aus der Analysis

In der folgenden Tabelle sind einige Function angegeben, dabei ist S ein symbolischer Ausdruck
und var eine symbolische Variable.
Analysis
diff(S ,var,n) n-te Ableitung nach var, ∂ n S/∂ varn
int(S ,var,a,b) Integr. von S bezüglich var in den Grenzen a, b
b
class(a, b) sym oder double; a S dvar
taylor(S ,n) M ACLAURIN-Polynom der Ordnung 5 bzw, n-1
taylor(S ,n,a) TAYLOR-Polynom (n-1)-ter Ordnung bezüglich a

’left’ ’left’
limit(S ,x,a, ) limx→a S, Richtung des einseit. Grenzw.
’right’ ’right’
jacobian(S,v) JACOBI-Matrix ∂ S/∂vv, S Skalar/Vektor, v Vektor
Anwendungsbeispiele:
>> syms x y % Vereinbarung der sym. Größen
>> diff(xˆ3) % Differenziation nach x
ans =
3*xˆ2
>> int(sin(x),0,pi/4) % Integration bezüglich x
ans =
-1/2*2ˆ(1/2)+1
>> s = int(exp(-xˆ4),0,1) % es gibt keine exakte Lösung
s =
(pi*2ˆ(1/2))/(4*gamma(3/4)) - igamma(1/4, 1)/4 % siehe; help gamma
>> sn = subs(s) % Konvertierung sym → double
sn =
8.4484e-001
>> int(int(xˆ2 + yˆ2,y,0,sin(x)),0,pi) % Doppel-Integral
ans =

piˆ2 - 32/9 % 0π 0sin x x2 + y2 dx dy
>> double(ans) % Konvertierung sym → double
ans =
6.3140e+000
>> taylor(exp(x)*sin(x),8) % Maclaurin-Polynom
ans =
- xˆ7/630 - xˆ6/90 - xˆ5/30 + xˆ3/3 + xˆ2 + x
>> limit(1/x,x,0,’left’) % Grenzwert
ans =
-inf
>> jacobian([exp(x*y) xˆ2*y],[x y]) % JACOBI-Matrix
ans =
[ y*exp(x*y), x*exp(x*y)]
[ 2*x*y, xˆ2]
1.8.6 Algebraische Gleichungssysteme, der solve Befehl

Der solve Befehl ist ein vielseitiger Gleichungslöser. Er ist anwendbar auf einzelne Gleichungen
sowie auf Gleichungssysteme, z. B.
>> solve(’a*x + b’) oder >> solve(’a*x + b = 0’)
ans =
-b/a
löst die Gleichung nach der Standardvariablen x auf. Ist nach einer anderen Größe aufzulösen,
so muss dies angegeben werden, z. B. nach a oder c
>> solve(’a*xˆ2 + b*x + c’,’a’) oder >> solve(’a*xˆ2 + b*x + c’,’c’)
. Hat eine Gleichung mehrere Lösungen, dann werden sie im Ausgabevektor aufgelistet:
>> s = solve(’a*xˆ2 + b*x + c’)
s =
-(b + (bˆ2 - 4*a*c)ˆ(1/2))/(2*a)
-(b - (bˆ2 - 4*a*c)ˆ(1/2))/(2*a),
Übersichtlichere Ausgabe:
>> pretty(s(1))
>> pretty(s(1))
2 1/2
b + (b - 4 a c)
- -------------------
2 a
Den numerische Wert für vorgegebene a, b, c erhalten wir mit

>> a = 5/16; b = 0.3; c = 1/4;
>> sn = subs(s)
sn =
-4.8000e-001 +7.5472e-001i
-4.8000e-001 -7.5472e-001i
Kann keine symbolische Lösung gefunden werden, wird selbstständig eine numerische mit
definierter Stellenzahl berechnet
>> s = solve(’x + 2 = exp(xˆ2)’)
s =
-0.58760882797611548391578866667983 % class sym
>> sn = double(s)
sn =
-5.8761e-001 % class double.
Die symbolische Größe s enthält standardmäßig 32 signifikante Stellen, sie lassen sich mit digits
ändern, z. B.
>> digits(40), s = solve(’x + 2 = exp(xˆ2)’)
s =
-0.5876088279761154839157886666798348798128
Beispiel für ein algebraisches Gleichungssystem mit mehreren Lösungen:

>> % Ausgabe der Lösungskomponenten >> [x,y] = solve(’xˆ2*yˆ2 - 2*x -1 =
0’,’xˆ2 - yˆ2 -1 = 0’)
x = y =
5^(1/2)/2 + 1/2 (5^(1/2)/2 + 1/2)^(1/2)
1/2 - 5^(1/2)/2 (1/2 - 5^(1/2)/2)^(1/2)
5^(1/2)/2 + 1/2 -(5^(1/2)/2 + 1/2)^(1/2)
1/2 - 5^(1/2)/2 -(1/2 - 5^(1/2)/2)^(1/2)
- 1/2 + (3^(1/2)*i)/2 (- 3/2 - (3^(1/2)*i)/2)^(1/2)
- 1/2 - (3^(1/2)*i)/2 (- 3/2 + (3^(1/2)*i)/2)^(1/2)
- 1/2 - (3^(1/2)*i)/2 -(- 3/2 + (3^(1/2)*i)/2)^(1/2)
- 1/2 + (3^(1/2)*i)/2 -(- 3/2 - (3^(1/2)*i)/2)^(1/2)
>> % Ausgabe als Structure XY, Ergebnis in den Feldern x bzw. y
>> XY = solve(’xˆ2*yˆ2 - 2*x -1 = 0’,’xˆ2 - yˆ2 -1 = 0’)
XY =
x: [8x1 sym] --> x = XY.x
y: [8x1 sym] --> y = XY.y
Beispiel für die Lösung eines linearen Gleichungssystems mit dem Backslash-Operator, vgl.
Abschn. 1.4.4. Die Koeffizientenmatrix ist eine H ILBERT-Matrix (vgl. help hilb):
>> As=sym(hilb(3)); >> bs=sum(As,2);
>> xs = (As\bs)’
xs = [ 1, 1, 1].
1.8.7 Gewöhnliche Differenzialgleichungen, der dsolve Befehl

Vorausgesetzt es existiert eine exakte, analytische Lösung einer Differenzialgleichung bzw. eines
Systems, so kann die Function dsolve
⇒ help dsolve
eine allgemeine oder spezielle, d. h. an Anfangswerte angepasste Lösung, finden. Die Syntax
lässt sich am einfachsten an Beispielen erläutern.
1. Differenzialgleichung 1. Ordnung: Gesucht sei die allgemeine Lösung von
ẏ + y = t et
>> y = dsolve(’Dy + y = t*exp(t)’) % ẏ → Dy, D Operator

y =
(exp(t)*(2*t - 1))/4 + C5/exp(t) % C5 Integrationskonstante
MATLAB erkennt die unabhängige Variable t als Standard-Variable. Tritt z. B. x als Parameter in
der Gleichung auf, dann müssen wir
>> y = dsolve(’Dy + y = x*t*exp(t)’,’t’)
schreiben.
2. Differenzialgleichung 2. Ordnung: Ein linearer Ein-Massen-Schwinger mit Dämpfung genügt

der Differenzialgleichung
ÿ + 2Dω0 ẏ + ω02 y = cos Ωt. (1.1)
Es sollen die Schwingungen y(t) für die Anfangswerte y(0) = 0, ẏ(0) = 0 zum Zeitpunkt t = 0
sowie für die Parametersätze
a) ω0 = 15 rad/s, Ω = 16 rad/s, D = 0,005
b) ω0 = 10 rad/s, Ω = 10 rad/s, D = 0,0
ermittelt werden. Wir schreiben das M-File bei_dgl.m in [52]:
1 clear, close all; clc

2 syms Om om0 t d % D ist Differenzialoperator, D -> d
3
4 %---- Beispiel a: lineares, gedämpftes System
5 y=dsolve(’D2y+2*d*om0*Dy+om0^2*y=cos(Om*t)’,’y(0)=0,Dy(0)=0’,’t’)
6 y=simple(y) % Vereinfachung der Ausdrücke
7 subexpr(y) % sucht nach gleichen Ausdrücken
8
9 pretty(y), latex(y) % Ausgabe
10 y=subs(y,{Om om0 d},{16 15 0.005}); % Param.-Substitution
11 ezplot(y,[0,8*pi],1) % Grafische Darstellung
12 %...............................................................
13 %---- Beispiel b: lineares ungedämpftes System, Resonanz
14 y=dsolve(’D2y+om0^2*y=cos(om0*t)’,’y(0)=0,Dy(0)=0’,’t’)
15 y=simple(y); % Ausdruck vereinfachen
16 yr=subs(y,{Om om0},{10 10}); % Parameter-Substitution
17
18 ezplot(yr,[0,6*pi],2) % grafische Darstellung
19 %---- Ermittlung der Geschwindigkeit für den Resonanz-Fall
20 %---- 1. Differenziation
21 yp=diff(yr,t) % zeitliche Ableitung
22 ezplot(yp,[0,6*pi],3) % grafische Darstellung
23 ylabel(’Geschwindigkeit m/s’)
24 %---- 2. Differenzialgleichungssystem
25 Y12=dsolve(’Dy1=y2, Dy2=-om0^2*y1+cos(om0*t)’,...
’y1(0)=0, y2(0)=0’,’t’)
26 om0=10;
27 Yp=subs(Y12.y2)
28 ezplot(Yp,[0,6*pi],4)
29 xlabel(’Zeit t/s’)
30 ylabel(’Geschwindigkeit m/s’)
Danach werden die Lösungen y(t) einer Differenzialgleichung 2. Ordnung (1.1) entsprechend
dem Operator D2 zu den Parametern nach a), b) ermittelt; vgl. Zeile 5 und 14. Im gedämpften
Fall a) ist die Lösung schon recht umfangreich. Unter Umständen lässt sie sich mit dem simple
Befehl wie in den Zeilen 6, 15 vereinfachen. Mehrfachanwendung simple(simple(..)) kann
weitere Vereinfachungen liefern! Darüber hinaus lassen sich mehrfach auftretende Ausdrücke
mit 7 subexpr(y) finden und damit die Lösung übersichtlicher dargestellen werden. Mit pretty
erfolgt eine Bildschirmausgabe, mit latex wird ein Ausdruck für das Textverarbeitungssystem
TEX erzeugt. In den Zeilen 10, 16 werden die symbolischen Parameter durch ihre numerischen
Werte ersetzt. Die Ausdrücke sind weiterhin vom Typ sym, da die symbolische Variable t noch
enthalten ist. Schließlich können mit der Plot-Function
ezplot(funktion,[t_anfang,t_end],figure_nr)
– oder wie bisher mit plot, wenn t substituiert wird – die Ergebnisse grafisch dargestellt werden;
vgl. Bild 1.32. Das Plot-Fenster lässt sich natürlich mit den bekannten Befehlen xlabel, legend,
title vervollständigen.
Der ungedämpfte Schwinger b) befindet sich in Resonanz, d. h. die Erregerkreisfrequenz Ω
stimmt mit der Eigenkreisfrequenz ω0 überein. Dementsprechend enthält die Lösung säkulare
Terme
1
y(t) = t sin ω0t, Ω = ω0 ,
2ω0
was auch der Zeitverlauf in Bild 1.322 widerspiegelt.
Soll darüber hinaus auch die Geschwindigkeit ẏ(t), z. B. für eine Darstellung in der Pha-
senebene, ermittelt werden, kann das Wegsignal y(t) nachträglich differenziert ( vgl. Zeile 21
diff(y,t)) werden oder man bearbeitet von Anfang an die äquivalenten Differenzialgleichun-
gen erste Ordnung
ẏ1 = y2 , y1 = y, y2 = ẏ
(1.2)
ẏ2 = −ω02 y1 + cos ω0t, y1 (0) = 0, y2 (0) = 0
wie ab Zeile 25.
0.06 1
Resonanz
0.04
Auslenkung y/m
Auslenkung y/m
0.5
0.02
0 0
−0.02
−0.5
−0.04
a) b)
−0.06 −1
0 10 20 0 5 10 15
Zeit t/s Zeit t/s
Bild 1.32: Weg-Zeit-Verläufe des gedämpften a) und ungedämpften b) Schwingers

1.8.8 Beispiel aus der linearen Algebra

In der Schwingungstechnik treten insbesondere im Zusammenhang mit Starrkörperbewegungen
von Strukturen Eigenwertprobleme mit mehrfachen Eigenwerten auf, die numerisch schwer zu
handhaben sind, siehe Kapitel 3. Wir wollen deshalb ausgehend von einer speziellen 3×3-Matrix
⎡ ⎤
6 12 19
A = ⎣ −9 −20 −33 ⎦
4 9 15
dieses Problem angehen. Um später die Ergebnisse beurteilen zu können, geben wir sie teilwei-
se vorab an. Die Matrix A besitzt einen einfachen Eigenwert λ1 und einen doppelten λ2,3 der
Vielfachheit ρ = 2. Der zugehörige Rangabfall bzw. Defekt d2,3 = 3 − rang(λ2,3E − A ) ist eins.
Demnach existiert zu λ2,3 nur ein (linear unabhängiger) Eigenvektor. Der fehlende, vgl. [9], kann
rekursive aus
(λ2,3E −A
A)vv3 = −vv2 , v 2 berechneter Eigenvektor (1.3)
ermittelt werden. Mit der kompletten Modalmatrix V = (vv1 , v 2 , v 3 ) folgt die J ORDAN-Matrix
⎡ ⎤
λ1 0 0
J = V −1A V = ⎣ 0 λ2 1 ⎦ . (1.4)
0 0 λ3
Um nun einmal die Unterschiede einerseits bezüglich einer numerischen und andererseits ei-
ner symbolischen Rechnung aufzuzeigen, werden wir beide Vorgehensweisen parallel behandeln.
Hierzu dient der unten aufgelistete Programm-Code sym_eig1.m aus [52]
1 %---- numerische Berechnung

2 A=[6 12 19; -9 -20 -33; 4 9 15] % Systemmatrix
3 n=length(A); % Dimension von A
4 %---- numerische Bearbeitung
5 rn=rank(A) % Rang-Ermittlung
6 DETn=det(A) % Determinante
7 disp(’ ’), disp(’Eigenvektoren Vn, Eigenwerte Dn, Kond.-Zahl sn’)
8 [Vn,Dn,sn]=condeig(A) % Eigenwertproblem mit Kond.-Zahl
9 Jn=inv(Vn)*A*Vn % Einheits- oder JORDAN-Matrix?
10 %---- symbolische Bearbeitung
11 syms x y z
12 A=sym(A) % symbolische Matrix A
13
14 r=rank(A) % Rang-Ermittlung
15 DET=det(A) % Determinante
16 %---- Defekt, Rangabfall zum doppelten Eigenw. 1
17 d=n-rank(A-eye(n))
18
19 [V,D]=eig(A) % Eigenwertproblem, symb.
20
21 %---- Reihenfolge der Eigenwerte [-1 1 1] sowie der Eigenvekt.

22 [Dx,I]=sort(subs(diag(D))); % Reihenfolge: Eigenwerte
23 if I(1) > 1 V=V(:,[2,1]); end % Reihenfolge: Eigenvektoren
24
25 Aeq=(eye(n)-A)*[x;y;z]+V(:,2); % lin. Gleichungen für Eigenvekt.
26 [x,y,z]=solve(Aeq(1),Aeq(2),Aeq(3)); % Lösung
27 xyz=[x;y;z]; % Lösungsvektor
28 sy=findsym(xyz); % symb. Variable im Ausdruck?
29 xyz=sym(subs(xyz,sy,1)) % Substitution sy -> 1
30 %---- Kontroll-Rechnung
31 Ve=[V,xyz] % vollständiger Eigenvektor
32 Je=inv(Ve)*A*Ve % JORDAN-Matrix
33
34 %---- direkte Berechnung aller Eigenvektoren
35 [VJ,J]=jordan(A) % J JORDAN-Matrix
Erläuterungen zum obigen Programmcode und den Ergebnissen: Ein übereinstimmendes Ergeb-
nis erhalten wir bezüglich des Ranges und der Determinanten von A ( Zeile 5, 6, 14, 15). Die
numerische Bestimmung der Eigenwerte (Dn), der Eigenvektoren (Vn) und der Konditionszahl
(sn) erfolgt in Zeile 8 mit dem Ergebnis
Vn =
-4.740998230350174e-001 -4.082482835849408e-001 4.082482973427853e-001
8.127425537743154e-001 8.164965830443175e-001 -8.164965788111345e-001
-3.386427307392985e-001 -4.082482931096022e-001 4.082482878181235e-001
Dn =
-9.999999999999840e-001 0 0
0 9.999999766694329e-001 0
0 0 1.000000023330555e+000
Danach existieren – wegen der numerischen Ungenauigkeit – drei voneinander verschiedene

Eigenwerte λ1 ≈ −1, λ2 ≈ 1, λ3 ≈ 1 und somit drei linear unabhängige Eigenvektoren. Allerdings
weist die Konditionszahl mit sn >> 1 (sn=1.3e+08) auf Mehrfacheigenwerte hin, so dass
das Ergebnis zu überprüfen wäre. Die Bedingung (1.4) liefert demnach keine J ORDAN -Matrix,
sondern eine Diagonalmatrix aus den Eigenwerten.
In Zeile 11 beginnen die symbolischen Operationen, der erste Schritt ist die Symbolisierung von
A mit der Typ-Konvertierung class(A) → sym. In Zeile 17 wird der Defekt d zu λ2,3 berechnet;
Ergebnis: d=1. Demzufolge liefert das Eigenwertproblem in Zeile 19 das Ergebnis
V = D =
[ 7/5, 1] [ -1, 0, 0]
[ -12/5, -2] [ 0, 1, 0]
[ 1, 1] [ 0, 0, 1]
D. h. zum doppelten Eigenwert 1 existiert nur ein Eigenvektor, der fehlende (vv3 ) muss aus (1.3)
mit singulärer Koeffizienten-Matrix (E E −A A) zu λ2,3 entsprechend den Zeilen 25 - 27 berechnet
werden. Das Ergebnis ist nicht eindeutig, es wird in Abhängigkeit einer der Lösungskomponen-
ten, hier z=z1, dargestellt. Die symbolische Variable wird mit dem findsym Befehl in Zeile 28
ermittelt. Wir setzen sie willkürlich zu eins (Zeile 29). Abschließend folgt mit (1.4) eine Kontroll-
Rechnung. Dazu ist die mit eig berechnete unvollständige Modalmatrix um v 3 zu ergänzen (Zeile
31) und damit (1.4) auszuführen. Die zugehörige J ORDAN-Matrix Je (Zeile 32) bestätigt die
Richtigkeit.
Alle Eigenwerte, die (1.4) erfüllen, können einfacher mit der Function jordan (Zeile 35) direkt
berechnet werden. In VJ stehen die Eigenvektoren und in J die zugehörige J ORDAN-Matrix. Auf-
grund unterschiedlicher Skalierung unterscheiden sich beide Ergebnisse optisch. Fazit: Derartige
Sonderfälle lassen sich nur mit Hilfe der Computeralgebra lösen. Praktisch, d. h. numerisch, exis-
tieren keine Mehrfacheigenwerte. Es sei denn, man korrigiert das numerische Ergebnis, wenn
man weiß, dass z. B. Nulleigenwerte mehrfach auftreten.
1.8.9 Übergang zur Numerik

Vielfach wird man symbolisch gewonnene Ausdrücke, z. B. Bewegungsgleichungen dynami-
scher Systeme, numerisch weiter bearbeiten. D. h. es muss insbesondere der Datentyp sym in
einen vom Typ double oder single konvertiert werden. Hierfür stehen die Functions
subs, eval, double, single
zur Verfügung. In jedem Fall muss der Ausdruck zahlenmäßig (symbolisch/numerisch) vorlie-
gen. Dies erfolgt in der Regel mit dem subs Befehl. Dabei liefert dieser direkt einen Datentyp
double bzw. single, wenn alle substituierten Größen vom Typ double bzw. single sind.
Ist jedoch ein symbolischer Wert, z. B. 1/3, enthalten, dann ist das Ergebnis e vom Typ sym.
Die Function:
eval(char(e)) oder eval(e) und double(e) oder single(e)
erzeugen schließlich den zugehörigen numerischen Wert vom Typ double bzw. single. Auch
ein wiederholter Aufruf subs(subs(e)) führt zum Ziel. Dieses ist im folgenden Programm
ue_num.m aus [52] für einige Varianten gezeigt.
syms a x t
f=a*x^2 + sin(t) + pi; % symbolischer Ausdruck
a1=sym(5); % symbolische Variable

t1=pi/4; % numerische Variable
x1=3/5; % numerische Variable
e1=subs(f,{a x t},{a1 x1 t1}) % class(e1) sym
e11=subs(e1) % class(e11) double
e12=eval(e1) % class(e12) double, oder
e121=eval(char(e1)) % class(e121) double
e13=double(e1) % class(e13) double
e14=single(e1) % class(e14) single
a1=5; % numerische Variable

e2=subs(f,[a x t],[a1 x1 t1]) % class(e2) double
a=sym(5); t=pi/4; x=3/5;

e3=subs(f) % class(e3) sym
e31=eval(e3) % class(31) double, oder
e311=eval(char(e3)) % class(e311) double
e32=double(e3) % class(e32) double
a=5;
e4=subs(f) % class(e4) double

e5=eval(f) % class(e5) double
Hinweis zu einer Matrizenmultiplikation in einem symbolischen Ausdruck:

>> syms A B
>> f = A * B; % symbolischer Ausdruck
>> g = subs(f,{A, B},{[1 2 ; 3 4],[4 3; 2 1]}) % Substitution
g= % Ergebnis aus Punktoperation
4 6
6 4
D. h. die Multiplikation wird elementweise g=A.*B ausgeführt, wobei class(g) double.
Abschließend betrachten wir das leicht modifizierte Beispiel aus [53] (siehe auch:
ue_num1.m in [52]), es zeigt anschaulich noch einmal die Substitution symbolischer und nu-
merischer Größen sowie den Übergang zu numerischen Ausdrücken:
% Beispiel zur Substitution mit Übergang zur Numerik
syms x y t g a % Vereinbarung symb. Variable
f=x + sin(x); % symb. Ausdruck
q=3*t^2 - t^t; % symb. Ausdruck
g=subs(f,x,q); % Substitution x -> q
h=subs(g,t,exp(y/a)) % Substitution t -> exp(y/a)
pretty(h) % übersichtliche Ausgabe
ergebnis=subs(h,{y,a},{7,9}) % numer. Ergebnis, class double
y=0:0.1:1; a=pi; % numerische Daten, y Vektor, a Skalar

hvec=vectorize(h) % h vektorisieren, -> Punktoper.
ergebn_1=eval(hvec)’ % Größen double -> ergebn_1 double
y=sym(y); a=sym(a); % Werte ’symbolisiert’

ergebn_2=eval(hvec)’ % y, a ersetzt -> ergebn_2 sym
%---- Übergang zur Numerik % in ergebn_2 symb ’Zahlenwerte’
ergebn_31=subs(ergebn_2) % darum hier ergebn_31 double
ergebn_32=double(ergebn_2) % ergebnis_32 double
2 Modellbildung
MATLAB und Simulink basieren auf einer mathematischen Modellierung eines zu untersuchen-
den Systems, die Tools SimScape, SimPowerSystems, SimMechanics, SimDriveline und Sim-
Hydraulics dagegen auf einer Modellierung physikalischer Modelle, siehe Kapitel 7. Wir wollen
uns in diesem Abschnitt mit mathematischen Modellierungs-Methoden beschäftigen. Dabei be-
schränken wir uns auf deterministische mechanische Modelle mit konzentrierten Parametern, die
sich durch gewöhnliche Differenzialgleichungen beschreiben lassen. Hierzu stellen wir die für
uns wesentlichen Grundlagen in einer hier benötigten Form kurz zusammen. Eine detailliertere
Darstellung insbesondere für Mehrkörpersysteme (MKS1 ) setzt umfangreiche Kenntnisse u. a.
der Kinematik und Kinetik voraus. Zur Vertiefung verweisen wir auf die einschlägige Literatur
[9], [15], [49], [54], [56] und insbesondere [67]. In [49], [67] werden einige hilfreiche praktische
Aspekte der Methoden dargestellt. U. a. sind in [56] Grundlagen zur Modellbildung starrer und
elastischer mechanischer Systeme für die Simulation und Regelung nachzulesen. Einen Über-
blick von Modellierungsmöglichkeiten mechatronischer Systeme findet man in [47]. Darüber
hinaus wird u. a. über Analogiebeziehungen von elektrischen und mechanischen Elementen ge-
zeigt, wie elektrische Systeme mit den hier vorgestellten Methoden bearbeitet werden können.
Für die Formulierung der Bewegungsgleichungen von Mehrkörpersystemen bestehen zwei
grundsätzliche Möglichkeiten:
• Bewegungsgleichungen in voneinander abhängigen Koordinaten: Aufstellen unter Verwen-

dung der impliziten Bindungen. Wir erhalten differenzial-algebraische Gleichungssysteme.
• Bewegungsgleichungen in den voneinander unabhängigen Minimalkoordinaten: Aufstel-
len unter Verwendung der expliziten Bindungen. Wir erhalten gewöhnliche Differenzialglei-
chungen.
Auf die Formulierung in voneinander abhängigen Koordinaten mit impliziten Bindungen gehen
wir in Kapitel 5 ein. Hier betrachten wir zunächst nur Formulierungen in Minimalkoordinaten,
die die holonomen-skleronomen oder -rheonomen Bindungen, vgl. [49], [56], [67] erfüllen.
Die klassischen Vorgehensweisen unterscheiden zwischen synthetischer und analytischer Me-
thode. Wir beschreiben die Unterschiede stichwortartig anhand zweier bekannter Vorgehenswei-
sen:
synthetisch: N EWTON - und E ULER - Methode

• Zerlegung (Freischneiden) des Systems in Einzelelemente, Schnittgrößen einführen
• Anwendung von Impuls- und Drallsatz
• Zusammensetzen des Systems u. a. durch Eliminieren der Schnittkräfte und -momente,
d. h. einarbeiten der expliziten Bindungen.
analytisch: L AGRANGE -Formalismus (2. Art)
1 MKS: besteht aus starren massebehafteten Körpern - z. B. Punktmasse, Widerstand - und masselosen Verbindungs-
elementen - z. B. Feder, elektrische Leitung -

DOI 10.1007/978-3-8348-8630-9_2,
96 2 Modellbildung
• Festlegung der generalisierten (verallgemeinerten) Koordinaten qk ; es sind f Minimal-

koordinaten, f Anzahl der Freiheitsgrade.
• Bestimmung der Gesamtenergien (kinetische und potentielle Energie, T, V ) aus der
Summe der Teilenergien Tk , Vk sowie der generalisierten Kräfte/Momente Qk der Ele-
mente k.
• Auswertung der L AGRANGEschen Gleichung (2.110).
Die synthetische Methode bietet den Vorteil, dass z. B. Kennlinien, die das Verhalten von mas-
selosen Elementen beschreiben, leicht eingearbeitet werden können; die im System wirkenden
Kräfte treten deutlich hervor. Nachteilig kann eine große Zahl von Variablen sein sowie die nicht
leicht zu ermittelnden Beschleunigungen. Vorteil der analytischen Methoden ist die schemati-
sche Vorgehensweise. Da alles auf Energien aufbaut werden Symmetrien offenbar, es werden
höchsten die ersten zeitlichen Ableitungen der Koordinaten benötigt. Für den Ingenieur ist oft
von Nachteil, dass Kräfte nicht unmittelbar anfallen.
Heute strebt man, unabhängig von der Vorgehensweise, formale rechnerorientierte Wege an.
Anforderungen an derartige Formalismen sind:
• formales, schematisches Vorgehen,
• kein Freischneiden, Zwangskräfte werden automatisch berücksichtigt,
• man erhält bei mechanischen Systemen eine einheitliche Normalform.
In den folgenden Abschnitten wollen wir zunächst kurz auf mögliche Strukturen der Bewegungs-
gleichungen eingehen, um daran anschließend benötigte Grundlagen und Methoden zur Formu-
lierung von Bewegungsgleichungen mechanischer Systeme zu erarbeiten. Parallel dazu wird
beispielorientiert gezeigt, wie sich damit auch komplexere kinematische Zusammenhänge und
schließlich Bewegungsgleichungen symbolisch mit Hilfe der Computeralgebra unter MATLAB
generieren lassen. Abschließend werden alle mathematischen Schritte im Beispiel noch einmal
zusammengefasst. Wesentliche Schritte für den Übergang zur Numerik sind im Abschn. 1.8.9
gezeigt. In einigen Projekten aus Kapitel 8 wird dies vertieft.
2.1 Bemerkungen zur Schreibweise

Bezüglich der mathematischen Schreibweise gehen wir von einer reellen Matrizenformulierung,
siehe u. a. [20], aus.
Beispiele:
• Spaltenvektor und Zeilenvektor (transponierter Spaltenvektor)
⎡ ⎤
x
r = ⎣ y ⎦ ∈ R3 , q T = q1 q2 · · · qn ∈ Rn (2.1)
z
• n × m-Matrix und deren Transponierte, n = m quadratische Matrix, ∈ Rn,m

⎡ ⎤ ⎡ ⎤
a1,1 a1,2 · · · a1,m a1,1 a2,1 · · · an,1
⎢ a2,1 a2,2 · · · a2,m ⎥ ⎢ a1,2 a2,2 · · · an,2 ⎥
⎢ ⎥ ⎢ ⎥
A =⎢ . .. .. .. ⎥ , B = AT = ⎢ . .. .. .. ⎥ (2.2)
⎣ .. . . . ⎦ ⎣ .. . . . ⎦
an,1 an,2 · · · an,m a1,m a2,m · · · an,m
oder kurz: A = (ai, j ), i = 1, 2, .., n, j = 1, 2, .., m

2.2 Strukturen der Bewegungsgleichungen 97
• JACOBI-Matrix J gebildet mit der m × 1-Vektorfunktion f (qq),

def ∂ f (q
q) ∂ f (qq) ∂ f (qq) ∂ f (qq)
J (qq) = = ··· ∈ Rm,n ,
∂qq ∂ q1 ∂ q2 ∂ qn
(2.3)
∂ fi
Jik = , i = 1, 2, . . . , m, k = 1, 2, . . . , n .
∂ qk
• Totale Ableitung der Vektorfunktion f (qq(t), t) zweier Veränderlicher nach dem Skalar t
d ∂ f d q (t) ∂ f ∂f
f (qq(t), t) = + = J q̇q(t) + . (2.4)
dt ∂qq(t) dt ∂t ∂t
2.2 Strukturen der Bewegungsgleichungen

Im Allgemeinen können wir die nichtlineare, gewöhnliche Differenzialgleichung in expliziter
oder in impliziter Vektor-Form anschreiben, z. B.
ẋx = g (xx, t), oder ḡg(ẋx, x , t) = 0 (2.5)
mit der unabhängigen Variablen t – hier der Zeit – sowie dem Vektor der abhängigen Variablen x
mit der zeitlichen Ableitung ẋx. Vielfach ist x der Zustandsvektor, z. B. x = [ q T , q̇qT ]T . Gehen wir
von den oben angesprochenen Methoden (z. B. N EWTON -E ULER-Formalismen), mit denen Be-
wegungsgleichungen dynamischer Mehrkörpersysteme mit f Freiheitsgraden aufgestellt werden,
aus, dann erhalten wir im Allgemeinen nichtlineare Differenzialgleichungen zweiter Ordnung in
Normalform:
M (qq, t) q̈q + f (qq, q̇q, f E , t) = 0 (2.6)
mit dem f -Vektor der verallgemeinerten Koordinaten q (t), der positiv definiten und symmetri-
schen f × f -Massenmatrix M = M T > 0 , dem f -Vektor f (qq, q̇q, f E , t) der gyroskopischen, dis-
sipativen, eingeprägten Kräfte und Momente u. a. aus Dämpfer, Feder, Gravitation, Magnetfeld
usw. sowie der explizit von der Zeit t abhängigen äußeren Erreger- bzw. Störfunktion f E (t). We-
sentlich ist, dass die Beschleunigung stets linear auftritt, so dass bei mechanischen Systemen
(2.5) immer auf die Form (2.6) gebracht werden kann.
In vielen praktischen Fällen hängen g , ḡg bzw. M , f nicht explizit von der Zeit ab, man spricht
u. a. von einer autonomen, im Gegensatz zur nichtautonomen Bewegungsgleichung, bei der die
Zeit explizit auftritt.
2.3 Grundlagen
2.3.1 Kinematik starrer Körper
Zur mathematischen Formulierung der Bewegungsgleichungen, z. B. eines Modells aus einem
oder mehreren starren Körpern ist die Beschreibung von Lage, Orientierung sowie deren zeitli-
chen Ableitungen, d. h. Geschwindigkeit und Beschleunigung, ohne Berücksichtigung der ein-
wirkenden Kräfte und Momente, von grundlegender Bedeutung. Diese Beziehungen lassen sich
98 2 Modellbildung
einerseits physikalisch anschaulich [49] oder andererseits rein formal [9] gewinnen. Da wir die
Ausdrücke symbolisch mittels Computeralgebra unter MATLAB auswerten wollen, erscheint der
formale Weg der geeignetere. Zunächst betrachten wir den einzelnen freien starren Körper nach
Bild 2.1: Koordinatensysteme
Bild 2.1 mit dem Bezugspunkt P sowie einem beliebige Punkt S. Wir legen zwei rechtwinkli-
ge (kartesische) Koordinatensysteme zugrunde: das Inertialsystem (I) mit dem Ursprung in O
und das körperfeste Koordinatensystem (K) mit dem Ursprung in P. Das Inertialsystem ist raum-
fest; die Basisvektoren (Einheitsvektoren) von (I) ändern, im Gegensatz zu denen von (K), ihre
Orientierung nicht.
Alle absoluten zeitlichen Ableitungen beziehen sich auf das Inertialsystem in dem Impuls-
und Drallsatz gelten. Der relative Abstand |rr PS | in (K) ist konstant, die Richtung ändert sich
während der Bewegung des Körpers gegenüber (I), wie in Bild 2.1 zu t1 angedeutet.
Den Ortsvektor r S schreiben wir zunächst im (I)-System an:
Ir S = I r P + I r PS , r = [ r1 , r2 , r3 ]T ∈ R3 , (2.7)
wobei der linke Index stets die verwendete Basis, der rechte die Relativität angibt, wobei wir 0
nicht schreiben, d. h. r 0P → r P . Die Verschiebung (Translation) des Bezugspunktes P gegenüber
kurz
(I) wird durch I r P , die Orientierung von I r PS durch eine Drehung festgeschrieben. Ist die Ab-
bildungsvorschrift der Drehung T IK , die K r PS in die Basis von (I) überführt, bekannt, dann gilt
auch
Ir S = I r P + T IK K r PS , T IK ∈ R3,3 ; (2.8)
T IK beschreibt also die Drehung von K r PS gegenüber (I):
I r PS = T IK K r PS . (2.9)
2.3.1.1 Drehtmatrix
Mit Hilfe der Drehmatrix (siehe auch Drehtensor in [67]) T können Tensoren und Vektoren in
das gewünschte Koordinatensystem transformiert werden; z. B. gilt:
• T IK : Transformation von (K) nach (I) → I r PS = T IK K r PS
2.3 Grundlagen 99
• T KI : Transformation von (I) nach (K) → K r PS = T KI I r PS , T KI = T IK

T .
T IK ist eine Orthogonalmatrix, d. h. die Transponierte ist gleich der Inversen

−1
T IK T IK = T IK
T
T IK = E , 3 × 3 − Einheitsmatrix E . (2.10)
Für eine Rücktransformation von (I) nach (K) gilt somit

−1
T KI = T IK = T IK
T
. (2.11)
Die Gesamttransformation T IK setzt sich aus drei Elementardrehungen in gewählter Reihenfolge
γ
Kz Kx

K r1 =

OCC 6I
z 6K z C
Kz 9
Kz , Kz
C M C
C r C
C 6
I 3 6K r3 Kx K r2
?C
Ky
C C
:

β
C I x, K x C Ky
C - - K r1 / ? CWC

α I r2 Iy
9

Ky , Ky

Ky
K x
Bild 2.2: Elementardrehungen
zusammen. Diese einmal gewählte Reihenfolge muss beibehalten werden; sie ist nicht vertausch-
bar. Die Elementardrehungen erlauben es, durch die vielfältigen Kombinationsmöglichkeiten für
jede technische Aufgabe, z. B. Kreiseltheorie, Flugmechanik, eine geeignete Drehmatrix aufzu-
bauen.
Wählt man beispielsweise die Drehungen um die Achsen in der Reihenfolge zu x − y − z ,
wie in Bild 2.2, so handelt es sich um die bekannten K ARDAN-Winkel, vgl. [9], [49]. Zur an-
schaulichen Deutung dieser Elementardrehungen, es sind ebene Drehungen, transformieren wir
schrittweise den Vektor
Ir = [ I r1 , I r2 , I r3 ]T −→ Kr = [ K r1 , K r2 , K r3 ]T .
Die Teiltransformationen der ebenen Drehung sind in Bild 2.2 dargestellt. Für die Elementar-
drehung α um die I x-Achse liest man die zugehörige Transformation
⎡ ⎤⎡ ⎤ ⎡ ⎤
1 0 0 I r1 K r1
⎣ 0 cos α sin α ⎦ ⎣ I r2 ⎦ = ⎣ K r2 ⎦ , → T α I r = K r (2.12)
0 − sin α cos α
I r3 K r3
ab. Führt man anschließend die Drehung β um die K y -Achse (Knotenlinie) durch, dann folgt
⎡ ⎤⎡ ⎤ ⎡ ⎤
cos β 0 − sin β K r1 K r1
⎣ 0 1 0 ⎦ ⎣ K r2 ⎦ = ⎣ K r2 ⎦ , → T β K r = K r (2.13)
sin β 0 cos β
K r3 K r3
100 2 Modellbildung
und entsprechend für die dritte Drehung γ um die K z -Achse:

⎡ ⎤ ⎡ ⎤ ⎡ ⎤
cos γ sin γ 0 K r1 K r1
⎣ − sin γ cos γ 0 ⎦ ⎣ K r2 ⎦ = ⎣ K r2 ⎦ , → T γ K r = K r . (2.14)
0 0 1
K r3 K r3
Die vollständige Drehtransformation setzt sich aus den drei obigen Elementardrehungen
! !
Kr = Tγ Tβ Tα I r = TKI I r , bzw. Ir = TαTTβTTγT K r = TIK K r , (2.15)
zusammen. Ausgeführt erhalten wir z. B. per Computeralgebra

⎡ ⎤
cos β cos γ − cos β sin γ sin β
T IK = ⎣ cos α sin γ + sin α sin β cos γ cos α cos γ − sin α sin β sin γ − sin α cos β ⎦ . (2.16)
sin α sin γ − cos α sin β cos γ sin α cos γ + cos α sin β sin γ cos α cos β
Nachteil: Es treten singuläre Drehwinkel, z. B. β = π2 , 3π

2 , · · · , auf. Sie entstehen dadurch, dass
in Bild 2.2 zwei Elementardrehungen zusammenfallen und somit ein Freiheitsgrad verloren geht.
Die Singularitäten lassen sich mit komplementären Drehwinkeln vermeiden, vgl. [56].
Andere Transformationen ergeben sich, wenn die Drehreihenfolge geändert wird. So gilt bei-
spielsweise für die E ULER-Winkel eine Reihenfolge um die z, x’, z”-Achsen der jeweils aus
der vorhergehenden Elementartransformation folgenden Koordinatensysteme; vgl. [9], [64]. Dar-
über hinaus kann die Orientierung eines dreidimensionalen Körpers durch Drehungen um drei
raumfeste, orthogonale Achsen2 , dem I-System, wie u. a. in der Raumfahrt, Robotik, Flug- und
Fahrzeugdynamik, erfolgen. Man spricht dann von der Roll-, Nick-, Gear-Winkeldefinition oder
RNG-Winkeln (Roll, Pitch, Yaw bzw. RPY-Winkeln). Dabei kann u. a. die z-Achse (Rollen) mit
der Fahrzeugrichtung, die y-Achse (Nicken) mit der Querrichtung und die x-Achse (Gieren) mit
der Hochachse zusammenfallen. Die Drehung erfolgt mit oder gegen der Uhrzeigerdrehung, was
bei der Anpassung der allgemein gültigen Elementardrehungen (2.12) - (2.14) zu berücksichtigen
ist.
Im Falle infinitesimal kleiner Drehungen können trigonometrische Funktionen in T lineari-
siert werden. Bei Berücksichtigung von lediglich Größen erster Ordnung spielt die Reihenfolge
der einzelnen Drehungen zur Ermittlung der Transformationsmatrix keine Rolle mehr. Infinitesi-
mal kleine Drehungen besitzen Vektoreigenschaften.
2.3.1.2 Geschwindigkeiten und Beschleunigungen

Im Allgemeinen ist es immer zweckmäßig, bei der Bestimmung der absoluten Größen zunächst
von einer Darstellung im Inertialsystem auszugehen und anschließend das Ergebnis in die ge-
wünschte Basis zu transformieren. Diesen Weg verfolgen wir hier konsequent.
Geschwindigkeiten: Die absolute Geschwindigkeit des Punktes S auf dem starren Körper erhält
man somit durch zeitliche Differenziation von (2.8)
d
I ṙr S = I ṙr P + Ṫ
TIK K r PS (∗)˙= (∗), K r PS = konst. (2.17)
dt
2 http://de.wikipedia.org/wiki/Roll-Nick-Gier-Winkel
2.3 Grundlagen 101
Wählen wir eine einheitliche Darstellung im Inertialsystem, so folgt mit (2.9)
I ṙr S = I ṙr P + Ṫ
TIK T KI I r PS . (2.18)
TIK T KI schiefsymmetrisch, d. h. es gilt

Dabei ist der Tensor Ṫ
TIK T KI = −(Ṫ
Ṫ TIK T KI )T = −T TKI .
TIK Ṫ (2.19)
ω bezeichnet und mit I ω = I [ωx , ωy , ωz ]T gebildet,

Dieser schiefsymmetrische Tensor wird mit ω̃
wobei ωx , ωy , ωz die Winkelgeschwindigkeitskomponenten des Körpers in der Basis I sind. Der
Tensor (2.19) hat die Struktur
⎡ ⎤
0 −ωz ωy
ωKI = ⎣ ωz
TIK T KI = I ω̃
Ṫ 0 −ωx ⎦ , I ω̃ ω TKI = −I ω̃
ω KI (2.20)
I
−ω y ω x 0 KI
und wird auch kurz Tildeoperator genannt. Alternativ kann das Kreuzprodukt in MATLAB mit
der Function cross gebildet werden. Damit lässt sich (2.18) rechnerorientiert formulieren
!
I ṙr S ω KI I r PS = I ṙr P + I ω × I r PS ,
= I ṙr P + I ω̃ (2.21)
womit gleichzeitig die Bedeutung des Tildeoperators angedeutet ist.

Zur Formulierung der Winkelgeschwindigkeiten definieren wir, in Analogie zu den Elementar-
drehungen, Elementarwinkelgeschwindigkeiten α̇, β̇ , γ̇. Mit ihnen wird eine Basis aufgespannt,
die weder orthogonal noch mit einem der beiden Koordinatensysteme (I) oder (K) zusammen-
fällt, vgl. [9]. Für eine Darstellung in einem der beiden rechtwinkligen Systeme (I), (K) sind
also die drei Elementarwinkelgeschwindigkeiten infolge der Drehungen um die x, y , z -Achsen
unterschiedlichen Transformationen zu unterwerfen. Im Falle der K ARDAN-Winkel gilt

K ω = {T Tγ Tβ (α̇ee1 ) } + [T
Tγ (β̇ee2 )] + (γ̇ e 3 ) (2.22)
mit e i als i-ten Einheitsvektor, z. B.: e T2 = (0, 1, 0). Gleichung (2.22) kann zu
⎡ ⎤
α̇
K ω = Tγ Tβ e 1 , Tγ e 2 , e 3 ⎣ β̇ ⎦ (2.23)
γ̇
zusammengefasst werden. Damit liegt eine Beschreibung im rechtwinkligen (K)-System vor.

Um auf eine Darstellung im (I)-System zu gelangen, wird (2.23) mit der Transformationsma-
trix (2.15) T IK = T αTT βTT γT durchmultipliziert, so dass
⎡ ⎤
α̇
Iω = T IK K ω = T α T β T γ T γ Tβ e 1 , Tγ e 2 , e 3 ⎣ β̇ ⎦
T T T
γ̇
⎡ ⎤ (2.24)
α̇
= e 1 , T αTe 2 , T αTT βTe 3 ⎣ β̇ ⎦
γ̇
102 2 Modellbildung
folgt. Bezeichnet man nun die absoluten Geschwindigkeiten mit v , so gilt für (2.21)
!
IvS ω KI I r PS = I v P + I ω × I r PS ;
= I v P + I ω̃ IvS = I ṙr S . (2.25)
Eine Darstellung im körperfesten System erhalten wir, wenn wir auf (2.25) die inverse Transfor-
mation T KI anwenden und (2.9) einsetzen:
T KI I ṙr S = T KI I ṙr P + T KI Ṫ
TIK K r PS → K ṙr S = K ṙr P + T KI Ṫ
TIK K r PS , (2.26)
hierin ist
T KI Ṫ ω IK
TIK = K ω̃ (2.27)
der schiefsymmetrische Tensor der Winkelgeschwindigkeiten K ω im körperfesten System mit

dem Aufbau nach (2.20). Erweiterung von (2.27) und Vergleich mit (2.20) liefert das Tensor-
transformationsgesetz für die Tildeoperatoren:
ω IK
K ω̃ = T KI Ṫ
TIK = T KI Ṫ ω KI T IK .
TIK T KI T IK = T KI I ω̃ (2.28)
Die Absolutgeschwindigkeit K v S von S lautet mit (2.26) im körperfesten Koordinatensystem
KvS ω IK K r PS .
= K v P + K ω̃ (2.29)
Beschleunigungen: Differenzieren wir (2.17) nach der Zeit, dann folgt die Absolutbeschleuni-
gung von S
I r̈r S = I r̈r P + T̈
TIK K r PS , K r PS = konst., (2.30)
bzw. bei einheitlicher Darstellung im (I)-System
I r̈r S = I r̈r P + T̈
TIK TKI I r PS . (2.31)
Gleichung (2.31) formen wir noch um:

d
r
r̈
I S = r
r̈
I P + T
Ṫ T
IK KI − T
Ṫ IK (T
T T
KI IK ) T
Ṫ KI I r PS
dt (2.32)

ω˙ + ω̃
= I r̈r P + I ω̃ ω ω̃
ω KI I r PS .
Schreiben wir für die absoluten Beschleunigungen r̈r = a , dann geht (2.32) über in
IaS ω˙ + ω̃
= I a P + I (ω̃ ω ω̃
ω )KI I r PS . (2.33)
Eine Darstellung im (K)-System folgt nach entsprechender Transformation aus (2.30)
T KI I r̈r S = T KI I r̈r P + T KI T̈
T K r PS
(2.34)
K a S = K a P + K (ω̃ ω˙ + ω̃
ω ω̃
ω )IK K r PS ,
2.3 Grundlagen 103
darin ist K a P die Absolutbeschleunigung des Bezugspunktes P dargestellt im (K)-System. Durch

Umformen von (2.34) erhalten wir eine zweite Darstellung von K a S :
KaS ω IK K v P + K ω̃
= K v̇vP + K ω̃ ω IK (K ω̃
ω˙ IK K r PS + K ω̃ ω IK K r PS )

= K v̇vP + K ω̃ ˙ ω IK (K v P + K ω̃
ω IK K r PS + (K ω̃ ω IK K r PS )) (2.35)
ω IK K v S .
= K v̇vS + K ω̃
Die Winkelbeschleunigung genügt

d
ω
I ω̇ = (I ω ) (2.36)
dt
und somit dem Transformationsgesetz
d d
ω = T KI
T KI I ω̇ (I ω ) = T KI (T TIK K ω )
dt dt
= T KI (T
TIK K ω̇ω + ṪTIK K ω ) (2.37)
ω + K ω̃
= K ω̇ ω IK K ω
T KI ω = K ω̇
I ω̇ ω.
ω IK K ω = 0 (Vektorprodukt mit sich selbst), so dass die absolute Winkelbeschleu-

Dabei ist K ω̃
nigung im (K)-System gleich der ersten zeitlichen Ableitung des im (K)-System dargestellten
Winkelgeschwindigkeitsvektors ist.
Damit sind die wichtigsten kinematischen Grundlagen für einen freien, starren Körper erar-
beitet und in eine, für die Computeralgebra, günstige Form gebracht. Fallen P und S zusammen,
d. h. r PS = 0, dann vereinfachen sich die Ausdrücke erheblich. Die Vorgehensweise ist unmittel-
bar u. a. auf mit Federn und Dämpfern gefesselte Körper, z. B. einen starren Rotor in Gleitlagern
oder elastischen Rotor, der als Mehrkörpersystem bzw. Finite-Element-Modell aus Teilrotoren
mit elastischen Kopplungen aufgebaut ist, anwendbar. D. h. anwendbar auf gebundene Systeme,
bei denen kein Freiheitsgradverlust infolge der Kopplung auftritt. Gehören zu einem Modell
mehrere starre Körper, dann sind die erarbeiteten Beziehungen für alle beteiligten Körper anzu-
schreiben, wobei die Bindungen zu beachten sind.
2.3.1.3 Kinematik von Mehrkörpersystemen

Ein mechanisches System wird im Allgemeinen aus mehreren starren Körpern zusammengesetzt
sein. Die einzelnen, im vorangegangenen Abschnitt lokal beschriebenen Körper, werden dafür un-
ter Berücksichtigung idealer Lagerungen (Bindungen), siehe [54], zu einem globalen Gesamtsys-
tem, einem gebundenen mechanischen System, zusammengefasst. Die Lagerungen sind als starr
und reibungsfrei vorausgesetzt. Nach [56] können sie u. a. nach der Art der Kräfte im Koppel-
element (Feder, Dämpfer, Kraftstellglied) und in holonome Bindungselemente (Gelenke, Stäbe,
Lagestellglieder) eingeteilt werden. Die ersten rufen eingeprägte Kräfte – bekannte Funktionen
der Zeit und der zunächst unbekannten Bewegungen – die letzten unbekannte Reaktionskräfte
hervor. Zusammenfassend besteht ein globales Gesamtsystem aus N starren Körpern die durch p
unabhängige Bindungen (Zwangsbedingungen) oder Lagerungen verknüpft werden. Die Zahl f
104 2 Modellbildung
der Lagefreiheitsgrade beträgt dann für eine räumliche bzw. ebene Bewegung nur noch
f = 6N − p, bzw. f = 3N − p . (2.38)
Die mathematische Beschreibung erfolgt durch f Differenzialgleichungen für die Bewegung und
p algebraische Gleichungen für die Reaktionskräfte.
Den Lagefreiheitsgraden werden f unabhängige Minimalkoordinaten (generalisierte, verall-
gemeinerte Koordinaten)
T
q = q1 , q2 , . . . , q f (2.39)
zugeordnet. Der Satz q , q̇q erfüllt die holonomen Zwangsbedingungen, siehe [56]. Damit lassen
sich dann die Ortsvektoren und deren zeitliche Ableitungen r (qq, t), ṙr (qq, q̇q, t) als Funktionen der
verallgemeinerten Koordinaten anschreiben. Die totale Ableitung nach t genügt
∂rr ∂rr
ṙr = q̇q + , r (qq, t), ṙr (qq, q̇q, t) (2.40)
∂qq ∂t
woraus durch partielle Differenziation ∂ ∗ /∂ q̇q die wichtige Beziehung
∂ ṙr ∂rr
= (2.41)
∂ q̇q ∂qq
abgeleitet werden kann.
In (2.39) sind Anteile der Translation und Rotation (z. B. K ARDAN-Winkel) enthalten. Orts-
vektor r und Winkelgeschwindigkeit ω eines holonomen Mehrkörpersystems sind einerseits ex-
plizit von der Zeit t abhängig oder andererseits unabhängig. Dies bedeutet für eine Zeitabhängig-
keit:
• Translation: Ortsvektor, Absolut-Geschwindigkeit, -Beschleunigung
Ir = I r (qq, t)
∂I r (qq, t) ∂I r (qq, t)
I ṙr (q
q, q̇q, t) = I v (qq, q̇q, t) = q̇q + = J T (qq, t) q̇q + v̄v(qq, t)
∂qq ∂t (2.42)
dv̄v(qq, t)
I a (q
q, q̇q, q̈q, t) = J T (qq, t)q̈q +J˙T (qq, t)q̇q + = J T (qq, t)q̈q + āa(qq, q̇q, t)
dt
mit
∂ (JJ T (qq, t) q̇q) ∂JJ T (qq, t)
J˙T (qq, t) = q̇q + , (2.43)
∂qq ∂t
dv̄v(qq, t) ∂ v̄v(qq, t) ∂ v̄v(qq, t)

= q̇q + (2.44)
dt ∂qq ∂t
und der bezugspunktabhängigen JACOBI-Matrix der Translation – Tensor 2. Stufe –

∂ I r (qq, t) ∂ I r (qq, t) ∂ I r (qq, t) ∂ I r (qq, t)
J T (qq) = = ... . (2.45)
∂qq ∂ q1 ∂ q2 ∂qf
2.3 Grundlagen 105
• Rotation: Winkelbeschleunigung
∂I ω (qq, q̇q, t) ∂I ω (qq, q̇q, t)

ω (qq, q̇q, q̈q, t)
I ω̇ = J R (qq, q̇q, t) q̈q + q̇q + (2.46)
∂qq ∂t
mit der JACOBI-Matrix der Rotation

∂ ω (qq, q̇q, t) ∂ I ω (qq, q̇q, t) ∂ I ω (qq, q̇q, t) ∂ I ω (qq, q̇q, t)
J R (qq, q̇q, t) = I = ... . (2.47)
∂ q̇q ∂ q̇1 ∂ q̇2 ∂qf
Aus (2.46) folgt unmittelbar
ω
∂ I ω̇ ∂ Iω
= (2.48)
∂ q̈q ∂ q̇q
Sind hingegen I r = r (qq) und I ω (qq, q̇q) nicht explizit zeitabhängig, dann entfallen in (2.42)-
(2.46) die partiellen Ableitungen nach t.
Damit müssen für gebundene Systeme die totalen Ableitungen d · /dt in den kinematischen
Beziehungen der vorangegangenen Abschnitte, z. B. für den Bezugspunkt P I ṙr P in (2.21), durch
(2.42), (2.46) ersetzt oder alternativ (2.42), (2.46) für den ausgewählten Bezugspunkt direkt an-
gesetzt werden.
Alle hier angegebenen Formulierungen, (2.42)-(2.47), eignen sich unmittelbar für eine sym-
bolische Umsetzung in MATLAB. Aus diesem Grund wurde in (2.43) – und auch später – kein
Tensor 3. Stufe ∂JJ T /∂qq eingeführt.
Beispiel 2.1: Doppelpendel mit räumlicher Bewegung
Bild 2.3: Doppelpendel mit Kardangelenk zwischen den Stäben
Das in Bild 2.3 skizzierte Doppelpendel bestehe aus den beiden homogenen zylin-
drischen Stäben der Längen 1 , 2 . In 0 bzw. P1 ist der Stab 1 angelenkt und kann
nur eine ebene Bewegung in der I y, I z-Ebene ausführen. In Q1 bzw. P2 befindet sich
zwischen den Stäben ein Kardangelenk, wodurch sich der Stab 2 entsprechend der Kar-
danwinkel α2 , β2 um die Achsen I x, K y 2 bewegen kann. Die Eigendrehung γ 2 um die
106 2 Modellbildung
K z2 -Achse ist blockiert, d. h. der Stab 2 kann sich nicht um seine Längsachse drehen.
Die kinematischen Beziehungen bezüglich Q1 und Q2 sind zu formulieren und sym-
bolisch mit Hilfe der Computeralgebra auszuwerten. Wesentlich dabei ist, dass sym-
bolische Differenziationen nur nach explizit auftretenden Variablen durchführbar sind.
Die totalen zeitlichen Ableitungen müssen deshalb, wie unter (2.42)-(2.47) eingeführt,
durch partielle Ableitungen nach den Variablen ersetzt werden.
Das System nach Bild 2.3 hat 3 Lagefreiheitsgrade. Als generalisierte Koordinaten
bieten sich nach Bild 2.3 an:
q = [ q1 , q2 , q3 ]T = [ α1 , α2 , β2 ]T . (2.49)
Stab 1: Die Bezugspunkte 0 und P1 fallen zusammen. Wir haben es mit einer ebenen
Bewegung um einen festen Drehpunkt zu tun. Im Einzelnen ergibt sich:
• Ortsvektor:
⎡ ⎤
0
q) = 1 ⎣ − sin α1 ⎦
I r Q1 (q (2.50)
cos α1
• Absolutgeschwindigkeit, siehe auch (2.42):
d ∂ I r Q1
I v Q1 (q
q, q̇q) = (I r Q1 ) = I ṙr Q1 = α̇1
dt ∂ α1
(2.51)
! ∂I r Q1 (qq)
= q̇q = J TQ1 (qq) q̇q
∂qq
• Absolutbeschleunigung, siehe auch (2.42):
d ∂ I r Q1 ∂ 2 I r Q1 2
I a Q1 (q
q, q̇q, q̈q) = I r̈r Q1 = (I v Q1 ) = α̈1 + α̇
dt ∂ α1 ∂ α12 1
(2.52)
! ∂ (JJ TQ1 (qq) q̇q)
= J TQ1 (qq) q̈q + q̇q
∂qq
• Winkelgeschwindigkeit:
Iω 1 = [ α̇1 , 0, 0 ]T (2.53)
• Winkelbeschleunigung , siehe auch (2.46):
ω 1 (q̈q) =
I ω̇ [ α̈1 , 0, 0 ]T
! ∂I ω 1 (q̇q) (2.54)
= q̈q = J R1 q̈q .
∂ q̇q
Hierin sind α1 , α̇1 , α̈1 bzw. q , q̇q, q̈q im Sinne der Computeralgebra symbolische
Variable; vgl. Abschn. 1.8.
2.3 Grundlagen 107
MATLAB Code: (aus kin_NE.m in [52], Kinematik-Teil)

syms l1 alpha_1 alpha_p1 alpha_pp1 % symbolische Größen
I_r_Q1 = l1*[0; -sin(alpha_1); cos(alpha_1)]; % Ortsvektor (2.50)
I_v_Q1 = diff(I_r_Q1,alpha_1)*alpha_p1; % Absolut-Geschw. (2.51)
I_a_Q1 = diff(I_r_Q1,alpha_1)*alpha_pp1 +... %
diff(I_r_Q1,alpha_1,2)*alpha_p1^2; % Absolut-Beschl. (2.52)
Stab 2: Der Ursprung des körperfesten Koordinatensystems auf (K2 ) legen wir in P2
nach Bild 2.3, so dass nach (2.8) für den Ortsvektor zu Q2
I r Q2 = I r P2 + T IK K r P2 Q2 , I r P2 = I r Q1 , K r P2 Q2 = [ 0, 0, 2 ]T (2.55)
gilt. Da keine Eigendrehung des Stabes 2 stattfindet, ist T γ 2 = E , womit sich die Dreh-
matrix nach (2.15) auf
T IK = T αT2 T βT2 (2.56)
reduziert. Die Absolutgeschwindigkeit von Q2 ergibt sich damit aus (2.25) oder (2.42)
I v Q2 (q
q, q̇q) = I vP2 ω KI2 I r P2 Q2 , I r P2 Q2 = TIK K r P2 Q2
+ I ω̃
! ∂ I r P2 (qq) ∂ I r P2 (qq)
= ω KI2 I r P2 Q2 ,
q̇q + I ω̃ = J TP2
∂qq ∂qq (2.57)
oder ∂I r Q2 (q
q)
= q̇q = J TQ2 q̇q,
∂qq
wobei I vP2 =I vQ1 nach (2.51) und I ω̃ ω KI2 mit

⎡ ⎤
α̇2
I ω 2 = e 1 , T α2 e 2 , T α2 T β2 e 3 ⎣ β̇2 ⎦ = I [ ωx , ωy , ωz ]2
T T T T
(2.58)
0
nach (2.24) zu
⎡ ⎤
0 0 ωy
ω KI2
I ω̃ = ⎣ 0 0 −ωx ⎦ (2.59)
I
−ωy ωx 0 KI 2
gebildet wird. Diesbezüglich wurde die Function tilde_op.m in [52] geschrieben,

mit der für jeden beliebigen Vektor der Tildeoperator symbolisch gebildet wird.
Die Beschleunigungen sind die zeitlichen Ableitungen von (2.57) und (2.58), d. h.
für die Absolutbeschleunigung nach (2.33) oder (2.42):
I a Q2 (q
q, q̇q, q̈q) = I a P2
+ I (ω̃ ω˙ 2 + ω̃ω 2ω̃
ω 2 )KI I r P2 Q2
! ∂ (JJ TQ2 (qq) q̇q) ∂ I r Q2 (2.60)
= J TQ2 (qq) q̈q + q̇q, J TQ2 =
∂qq ∂qq
108 2 Modellbildung
und für die Winkelbeschleunigung:
d I ω 2 (qq, q̇q) ∂ Iω 2 ∂ Iω 2
ω 2 (q̇q, q̈q) =
I ω̇ = q̈q + q̇q
dt ∂ q̇q ∂qq
(2.61)
1 ∂ Iω 2
= J R2 q̈q + q̇q
∂qq
mit den JACOBI-Matrizen bezüglich q und q̇q, vgl. (2.47).
MATLAB Code: (Auszug aus kin_NE.m [52], Kinematik-Teil), Fortsetzung
syms l2 alpha_2 beta_2 alpha_p2 beta_p2 alpha_pp2 beta_pp2
q = [alpha_1; alpha_2; beta_2]; % Minimalkoordinaten
q_p=[alpha_p1; alpha_p2; beta_p2]; % zeitl. Ableitung, Geschw.
q_pp=[alpha_pp1; alpha_pp2; beta_pp2]; % Beschleunigungen
%---- Drehmatrizen
T_a2 = [1 0 0; 0 cos(alpha_2) sin(alpha_2) % aus (2.12)
0 -sin(alpha_2) cos(alpha_2)]; % Elementardrehung alpha_2
T_b2 = [cos(beta_2) 0 -sin(beta_2); 0 1 0 % aus (2.13)
sin(beta_2) 0 cos(beta_2)]; % Elementardrehung beta_2
T_IK = T_a2.’*T_b2.’; % Drehmatrix (2.56)
%---- Ortsvektoren P2 -> Q2 % (2.55)
*[-0.15em] I_r_P2 = I_r_Q1;
K_r_P2Q2 = [0; 0; l2];
I_r_Q2 = I_r_P2 + T_IK * K_r_P2Q2;
J_T_Q2 = jacobian(I_r_Q2,q); % JAC.-M., Transl., Q2 (2.60)
J_T_P2 = jacobian(I_r_P2,q); % JAC.-M., Transl., P2 (2.57)
%---- Geschwindigkeitsvektoren S2
ab1 = [eye(3,1), T_a2(2,:).’, T_IK(:,3)]; % Abkürzung
I_om2 = ab1*[alpha_p2; beta_p2; 0]; % Winkelgeschw. (2.58)
I_v_Q2 = J_T_P2*q_p + ...
tilde_op(I_om2)*T_IK*K_r_P2Q2; % Abs.-Geschw. von Q2 (2.57)
% oder
% I_v_Q2 = J_T_Q2*q_p; % Abs.-Geschw. von Q2 (2.57)
%---- Beschleunigungen bezüglich Q2
J_R_2 = jacobian(I_om2,q_p); % JACOBI-M., Rotation (2.61)
I_om2_p = J_R_2*q_pp + jacobian(I_om2,q)*q_p; % Winkelbeschleunigung
I_om2_p = simple(simple(I_om2_p)); % (2.61)
I_a_Q2 = simple(simple(J_T_Q2*q_pp + ... % Abs.-Beschl. von Q2 (2.60)
jacobian(J_T_Q2*q_p,q)*q_p));
Für andere Bezugspunkte auf Stab 2, z. B. P2 , sind die zugehörigen Ortsvektoren und
damit die JACOBI-Matrizen aufzunehmen und wie oben die kinematischen Beziehun-
gen zu bilden. In kin_NE.m [52] sind zusätzliche und alternative Berechnungen der
kinematischen Beziehungen, die später zur Aufstellung der Bewegungsgleichungen
benötigt werden, angegeben.
2.3.2 Kinetik
Zur Herleitung der Bewegungsgleichungen, auf der Basis eines starren Körpers nach Bild 2.1,
mit Hilfe des Impuls- und Drallsatzes sowie der L AGRANGEschen Gleichung 2. Art, müssen zu-
2.3 Grundlagen 109
nächst die notwendigen Beziehungen zusammengestellt werden; vgl. [9], [29], [49], [64]. Dies
lässt sich auf Mehrkörpersysteme verallgemeinern, da hierbei von freigeschnittenen lokalen Kör-
pern ausgegangen wird.
2.3.2.1 Der Impulssatz, translatorische Bewegung
Ausgehend vom Impuls
p = m IvS (2.62)
mit der Masse m und der absoluten Geschwindigkeit v S des Schwerpunkts S (hier identisch mit
dem Massenmittelpunkt) in einer Inertialdarstellung erhalten wir für die Translationsbewegung
ṗp = f (S) , (2.63)
worin f (S) die Resultierende der auf den Schwerpunkt einwirkenden Kräfte ist. Diese Kräfte
setzen sich aus eingeprägten, d. h. arbeitleistenden Kräften f e und aus Zwangs- bzw. Reaktions-
Kräften f r infolge Bindungen, die keine Arbeit leisten, zusammen. Hierzu zählen u. a. auch
Gelenk- und Lagerkräfte. Mit (2.62) schreiben wir für m = konst. ausführlich
m I a S = I f (S) , IaS = I v̇vS , If = I fe + I fr . (2.64)
Es kann, im Zusammenhang mit dem Drallsatz, wünschenswert sein, (2.64) im körperfesten

Koordinatensystem (K) auszudrücken. Hierzu transformieren wir (2.64) mit T KI ins (K)-System
(S)
m KaS = Kf , (2.65)
wobei die Absolutbeschleunigung des Punktes S nach (2.34) bzw. (2.35) mit den zeitlichen Ab-
leitungen nach (2.42), (2.46) einzusetzen ist.
2.3.2.2 Der Drallsatz, rotatorische Bewegung
Die zeitliche Ableitung des auf den Schwerpunkt S bezogenen Dralls

(S)
IL = I I (S) I ω (2.66)
mit dem Trägheitstensor I I (S) und der Winkelgeschwindigkeit I ω ist gleich den resultierenden
Momenten m = m e + m r (entsprechend den Kräften) einschließlich den Zwangsmomenten m r
aus den Bindungen ausgedrückt im Inertialsystem:
L
I L̇ = I m (S) . (2.67)
Der als symmetrisch vorausgesetzte Trägheitstensor I I (S) ist in der Regel zeitabhängig im Ge-
gensatz zu K I (S) im körperfesten System, so dass eine Formulierung im (K)-System vielfach
einfacher ist. Die Transformationsvorschrift für den Trägheitstensor erhalten wir ausgehend vom
110 2 Modellbildung
Drall (2.66) im Inertialsystem zu
T KI I L (S) = K L (S) = T KI I I (S) T IK K ω = K I (S) K ω , (2.68)
woraus wir das Transformationsgesetz des Trägheitstensors

(S)
II = T IK K I (S) T KI (2.69)
ablesen. Wie schon erwähnt, ist K I (S) konstant. Fallen darüber hinaus die körperfesten Koordina-
ten mit den Hauptachsen des starren Körpers zusammen, hat K I (S) Diagonalgestalt.
Den Drallsatz bezüglich (I) können wir damit auswerten. Zunächst betrachten wir den Term
(S)
L :
I L̇
(S) d (S) d
L
I L̇ = II Iω = T IK K I (S) T KI I ω
dt dt
(S)
= II ω + Ṫ
I ω̇ TIK TKI I I (S) I ω + I I (S) TIK Ṫ
TKI I ω (2.70)
= I I (S) I ω̇ ω KI I I (S) I ω ,
ω + I ω̃
womit der Drallsatz bezüglich S angeschrieben werden kann

(S)
II ω
I ω̇ ω KI I I (S) I ω = I m (S) .
+ I ω̃ (2.71)
Um die Zeitabhängigkeit von I I (S) auszuschließen, verwendet man zweckmäßigerweise den

Drallsatz bezüglich des (K)-Systems. Wir erhalten nach Rechtsmultiplikation von (2.71) mit T KI
und einigen Umformungen
(S)
KI ω
K ω̇ ω IK K I (S) K ω = K m (S) .
+ K ω̃ (2.72)
Drall und Momente beziehen sich bisher auf S. Der Drallsatz hat danach im (I)- und (K)-System
denselben strukturellen Aufbau. Vielfach ist es zweckmäßiger, alle Größen auf P zu beziehen.
Hierzu sind u. a. die auf P bezogenen Momente zu ermitteln. Mit (2.65) finden wir
(P) (S)
Kf = Kf
(S)
(2.73)
Km = K m (P) − m K r̃r PSIK KaP + K ω˙ + ω̃
ω̃ ω ω̃
ω IK K r PS
mit dem schiefsymmetrischen Tensor K r̃r PSIK des Ortsvektors K r PS = [ K rx , K ry , K rz ]T

⎡ ⎤
0 −rz ry
K r̃r PSIK =: K r̃r PS = ⎣ rz 0 −rx ⎦ . (2.74)
K
−r y r x 0 IK
Berücksichtigen wir noch den S TEINERschen Verschiebungsanteil, so erhalten wir den auf P
bezogen Trägheitstensor
(P)
KI = K I (S) + m K r̃r PS K r̃r TPS . (2.75)
Setzen wir (2.73) und (2.75) in (2.72) ein

2.4 Newton-Euler-Methode 111

(P) (P)
KI − m K r̃r PS K r̃r TPS ω
K ω̇ ω IK
+ K ω̃ KI − m K r̃r PS K r̃r TPS Kω
(2.76)
ω˙ IK K r PS + m K r̃r PS
+ K r̃r PS m K a P + m K r̃r PS K ω̃ K ω ω̃
(ω̃ ω )IK K r PS = K m (P)
ω r = r̃r T ω , dann finden wir zunächst

und beachten u. a. ω̃
(P)
KI ω
K ω̇ ω IK K I (P) K ω + m K r̃r PS K aP
+ K ω̃
(2.77)
ω IK K r̃r PS ) K r̃r TPS K ω = K m (P) .
ω IK − K ω̃
+ m ( K r̃r PS K ω̃
Der letzte Term auf der linken Seite verschwindet. Um dies zu erkennen, schreiben wir ihn um
(vgl. Entwicklungsätze für Kreuzprodukte)
( K r̃r PS K ω̃ ω IK K r̃r PS ) K r̃r TPS K ω = −K r̃r

ω IK − K ω̃ PS K ω K r̃r PS K ω = 0 ;
dies ist das Kreuzprodukt des Vektors K r̃r PS K ω mit sich selbst. Damit lautet der Drallsatz für
einen beliebigen Bezugspunkt P im körperfesten (K)-System
(P)
KI ω
K ω̇ ω IK K I (P) K ω + m K r̃r PS K a P = K m (P) .
+ K ω̃ (2.78)
2.4 Newton-Euler-Methode
Anhand des Doppelpendels nach Bild 2.3 werden wir die Anwendung von Impuls- und Drallsatz
zeigen. Man spricht auch von der N EWTON -E ULER- Methode. Ihr liegen die freigeschnittenen
starren Körper, z. B. eines Mehrkörpersystems (MKS), hier Doppelpendel nach Bild 2.4, zugrun-
de.
Beispiel 2.2: Fortsetzung: Bewegungsgleichungen des Doppelpendels

Für das Doppelpendel in Bild 2.3 werden im Folgenden die Bewegungsgleichungen
nach der N EWTON -E ULER-Methode rechnergestützt bezüglich der symbolischen Aus-
drücke aufgestellt. Zusätzlich zu den bereits eingeführten Parametern (u. a. Bild 2.3)
sind die Massen m1 , m2 und die Trägheitsmomente bezüglich der körperfesten Haupt-
(S ) (S ) (S )
trägheitsachsen (Symmetrieachsen) K Ixx j , K Iyy j , K Izz j , j = 1, 2 gegeben.
Lösung:
Wie bereits festgeschrieben ist f =3 und der Vektor der generalisierten Koordinaten
(Minimalkoordinaten)
q = [ α1 , α2 , β2 ]T ,
wobei nach Bild 2.3 α1 die Drehung des Stabes 1 um den festen Drehpunkt 0 bzw. P1
und α2 , β2 die K ARDAN-Winkel des Stabes 2 in P2 , entsprechend den Drehungen um
die Inertialachse I x und die Knotenlinie K y 2 , sind.
112 2 Modellbildung
Die körperfesten Koordinatensysteme legen wir in die Drehpunkte 0 und P2 . Die zu

ermittelnden Teil-Bewegungsgleichungen bringen wir stets auf die Form
M j q̈q + f j (qq, q̇q) = s j ( fx , fy , fz ), j = 1, 2, 3 (2.79)
mit den Schnittkräften fx , fy , fz in Q1 bzw. P2 , vgl. Bild 2.4. Wir stellen die Elemente
Bild 2.4: Schnittbilder der Stäbe 1 und 2
der Bewegungsgleichungen zusammen und werten sie – fortsetzend zur Kinematik –

mit Hilfe der Computeralgebra aus. Dadurch sind viele kinematische Größen bereits
als bekannt vorauszusetzen. Da wir uns für die Drehpunkte P1 , P2 und nicht für die
Schwerpunkte S j als Bezugspunkte entschieden haben, ist der Drallsatz in der Version
(2.78) zugrunde zu legen.
Stab 1: Wegen K a P1 = 0 gilt nach (2.78)
(P1 )
KI ω1
K ω̇ ω 1IK K I (P1 ) K ω 1 = K m (P1 )
+ K ω̃ (2.80)
mit dem Trägheitstensor nach (2.75) bezogen auf P1

(P1 ) (S ) (S ) (S )
KI = diag K Ixx 1 , K Iyy 1 , K Izz 1 + m1 K r̃r P1 S1 K r̃r TP1 S1 , (2.81)
worin
K r P1 S1 = [ 0, 0, 1 /2 ]T . (2.82)
Winkel-Geschwindigkeit und -Beschleunigung stimmen hier im (I)- und (K)-System

überein:
Kω 1 = [ α̇1 , 0, 0 ]T ; ω1
K ω̇ = [ α̈1 , 0, 0 ]T (2.83)
ω 1IK folgt damit nach (2.20),

und entsprechen somit (2.53), (2.54). Der Tildeoperator K ω̃
womit der zweite Term auf der linken Seite in (2.80) verschwindet. Es bleibt die be-
kannte Bewegungsgleichung eines Stabpendels mit einem festen Drehpunkt. Letztend-
lich ist noch das Moment bezüglich P1 zu bilden:

⎡ ⎤ ⎡ ⎤
0 fx
(P1 ) (P1 ) (P1 ) ⎣ 0 ⎦ + K r̃r P Q T α ⎣ fy ⎦ (2.84)
Km = Kme + Kmr = K r̃r P1 S1 T α1 1 1 1
m1 g fz
mit K r P1 Q1 = 2 K r P1 S1 und der Drehmatrix T α1 nach (2.12) mit α → α1 . Die Teiler-

gebnisse passen wir an (2.79) an. Dazu beachten wir, dass in mechanischen Systemen
die Beschleunigung q̈q stets linear auftritt, so dass sich die Teil-Massenmatrix M 1 mit
(2.80) zu
ω1
∂ K ω̇ ω1
∂ K ω̇ ∂ Kω 1 !
M 1 = K I (P1 ) = K I (P1 ) J R1 , mit = = J R1 (2.85)
∂ q̈q ∂ q̈q ∂ q̇q
und die restlichen Terme aus (2.84) zu
(P1 ) (P1 )
f 1 (α1 ) = − K me , s1 = K mr (2.86)
ergeben.
MATLAB Code: (aus kin_NE.m, Kinetik-Teil), Fortsetzung

%---- Kinetik, Bewegungsgleichungen
%---- Stab 1
syms m1 g fx fy fz I_xx1 I_yy1 I_zz1 % symbolische Größen
K_om_p1=[alpha_pp1; 0; 0]; % Winkel-Beschl. (2.83)
K_r_P1S1 = [0; 0; l1/2]; % Ortsvektoren (2.82)
K_r_P1Q1 = [0; 0; l1];
T_a1=subs(T_a2,alpha_2,alpha_1); % Drehmatrix T_a2 bekannt
K_f_r=T_a1*[fx; fy; fz]; % Zwangskräfte aus (2.84)
K_f_e=T_a1*[0; 0; m1*g]; % eingeprägte Kr. aus (2.84)
K_m_P1_r=tilde_op(K_r_P1Q1)*K_f_r; % Zwangsmoment aus (2.84)
K_m_P1_e=tilde_op(K_r_P1S1)*K_f_e; % eingepr. Mom. aus (2.84)
%---- Trägheitstensor
K_I_P1=diag([I_xx1, I_yy1, I_zz1])+ ... (2.81)
m1*tilde_op(K_r_P1S1)*tilde_op(K_r_P1S1).’
M_1=K_I_P1*jacobian(K_om_p1,q_pp); % Teil-Massenmatrix (2.85)
f_1=-K_m_P1_e; % Vektorfunktion (2.86)
s_1=K_m_P1_r; % rechte Seite (2.86)
Stab 2: Die Teil-Bewegungsgleichung setzt sich, unabhängig vom Bezugspunkt, aus

einem Translations- und einem Drehanteil zusammen. Demzufolge sind Impuls- und
Drallsatz anzusetzen.
Impulssatz: Wir wählen den Bezugspunkt S2 , so dass nach (2.64)
m2 I a S2 (qq, q̇q, q̈q) = I f (S2 ) , If

(S2 )
= I f (P2 ) (2.87)
gilt. Darin berechnet sich I a S2 wie I a Q1 in (2.52) aus Beispiel 2.1 mit angepasster
JACOBI-Matrix J TS2 = ∂I r S2 / ∂qq. Die vom Bezugspunkt unabhängigen Kräfte ergeben
114 2 Modellbildung
sich zu:
⎡ ⎤ ⎡ ⎤
0 fx
(S2 ) (S2 )
If
(S2 )
= Ife + Ifr = ⎣ 0 ⎦ − ⎣ fy ⎦ . (2.88)
m2 g fz
Damit erhalten wir die Elemente der Teil-Bewegungsgleichung (2.79) der Translation
∂ I a S2 (S )
M 2 = m2 = m2 J TS2 , f 2 (qq, q̇q) = m2 (I a S2 − J TS2 q̈q), s 2 ( fx , fy , fz ) =I f r 2 .
∂ q̈q

syms m2 I_xx2 I_yy2 I_zz2
%---- Impulssatz
I_r_S2=I_r_P2+[0; 0; l2/2]; % Ortsvekt., Kinematik
J_T_S2=jacobian(I_r_S2,q); % JAC.-Matr. d. Transl.
I_a_Se=simple(simple(J_T_S2*q_pp+... % Beschl. bez. S2
jacobian(J_T_S2*q_p,q)*q_p)); % vgl. (2.52)
I_f_r2=-[fx; fy; fz]; % Zwangskraefte (2.88)
I_f_e2=[0; 0; m2*g]; % Gewichtskraefte (2.88)
% Elemente der Teil-Bewegungsgl. 2
M_2=m2*jacobian(I_a_S2,q_pp); % Massen-Matrix
f_2=simple(simple(m2*I_a_S2-M_2*q_pp))-I_f_e2; % Vektorfunkt.
s_2=I_f_r2 % rechte Seite
Drallsatz: Mit Bezugspunkt P2 gilt (2.78) in der Form

(P2 )
KI ω2
K ω̇ ω 2 IK K I (P2 ) K ω 2 + m2 K r̃r P2 S2 K a P2 = K m (P2 ) .
+ K ω̃ (2.89)
Winkel-Geschwindigkeit und -Beschleunigung sowie die Absolutbeschleunigung von

P2 folgen aus den Inertialgrößen des Kinematik-Teils, wenn wir sie mit T KI = T Tα2 T Tβ2
ins (K)-System transformieren. Der Trägheitstensor K I (P2 ) (2.81) ist bezüglich P2 mit
K r P2 S2 = [ 0, 0, 2 /2 ]T
anzuschreiben, vgl. (2.81). Wegen der Bezugspunktwahl enthält die rechte Seite von
(2.89) nur das eingeprägte Moment infolge des Gewichts
⎡ ⎤
0
(P2 ) (P2 )
Kme = K r̃r P2 S2 T KI ⎣ 0 ⎦ , Kmr = 0 → s3 = 0 . (2.90)
m2 g
MATLAB Code: (aus kin_NE.m [52], Kinetik-Teil), Fortsetzung

T_KI=T_IK.’; % Drehmatrix, Kinematik
K_om2=T_KI*I_om2; % Winkelgeschw. (K)
K_om2_p=T_KI*I_om2_p; % Winkelbeschl. (K)
K_a_P2=T_KI*I_a_P2; % Absolutbeschl. (K)
K_I_P2=diag([I_xx2, I_yy2, I_zz2]) + ... % Traegheitstensor
m2*tilde_op(K_r_P2S2)*tilde_op(K_r_P2S2).’ % wie (2.81)

K_m_P2_e = tilde_op(K_r_P2S2)*T_KI*[0; 0; m2*g];% Moment bez. P_2 (2.90)
bweg3=K_I_P2*K_om2_p + ...
tilde_op(K_om2)*K_I_P2*K_om2+m2*tilde_op(K_r_P2S2)*K_a_P2; (2.89)
M_3=simple(simple(jacobian(bweg3,q_pp))); % Teil-Massenmatrix
f_3=simple(simple(bweg3-M_3*q_pp))-K_m_P2_e; % Vektorfunktion
Stab 1 und 2: Die drei Teilbewegungsgleichungen stellen formal ein System von
neun Gleichungen für die unbekannten Kraft- und Momentengrößen sowie die Win-
kelgrößen dar. Um die Bewegungsgleichungen zu erhalten, sind die Schnittgrößen zu
eliminieren. Hierzu nutzen wir die Tatsache, dass diese keine Arbeit bzw. Leistung
erbringen, d. h. es muss gelten
J TR1 s 1 + J TTP s 2 + J TR2 s 3 = 0 , (2.91)

2
wobei mit (2.53), (2.51), d. h. I v P2 =I v Q1 und (2.58)
∂ Kω 1 ! ∂ I v P2 ∂ Kω 2
J R1 = ; J T2 = J TP2 = ; J R2 = (2.92)
∂ q̇q ∂ q̇q ∂ q̇q
die JACOBI-Matrizen der Rotation (JJ R ) und der Translation (JJ T ) bedeuten; eine dies-
bezüglich ausführliche Erläuterung ist u. a. in [49] angegeben. Dabei ist zu beachten,
dass J TP2 sich stets nach dem Bezugspunkt des zugehörigen Drallsatzes – hier P2 –
richtet. Die Bewegungsgleichung ergibt sich somit zu
M (qq)q̈q + f (qq, q̇q) = 0 (2.93)
mit
M = J TR1 M 1 + J TTP M 2 + J TR2 M 3 ; f = J TR1 f 1 + J TTP f 2 + J TR2 f 3 . (2.94)

2 2

%---- Elimination der Schnittgrößen
%---- JACOBI-Matrizen
I_om1=[alpha_p1; 0; 0]; % Winkelgeschw. (2.83)
J_R1=jacobian(I_om1,q_p); % JAC.-Rotation (2.92)
J_T2=simple(simple(jacobian(I_v_S2,q_p))); % JAC.-Translation (2.92)
J_R2=simple(simple(jacobian(I_om2,q_p))); % JAC.-Rotation (2.92)
%---- Elemente der Bewegungsgleichung
M=simple(simple(J_R1.’*M_1+J_T2.’*M_2+J_R2.’*M_3)) (2.79), (2.94)
f=simple(simple(J_R1.’*f_1+J_T2.’*f_2+J_R2.’*f_3)) (2.79), (2.94)
Vorteil der im Beispiel dargestellten Methode bezieht sich auf die Verfügbarkeit der Kraftbezie-
hungen. Sind die Bewegungsgleichungen gelöst, so lassen sich diese direkt ermitteln. Für eine
rechnerorientierte Vorgehensweise ist eine systematischere Aufbereitung, die weit verbreitete
N EWTON -E ULER-Methode in der Fassung von D’A LEMBERT, anzustreben; vgl. u. a. [9], [49],
[56]. Sie eignet sich insbesondere für komplexe Strukturen.
116 2 Modellbildung
2.4.1 Rechnerorientierte Vorgehensweise

Wir gehen davon aus, dass das Mehrkörpermodell aus N starren Körpern besteht und wie bisher
ein Satz von verallgemeinerten Koordinaten q , q̇q – sie erfüllen die holonomen Zwangsbedingun-
gen – bekannt ist.
Die zeitliche Ableitung des Impulses ṗp bzw. des Dralls L̇
L entspricht jeweils der linken Seite
von (2.64) oder (2.65) bzw. (2.78), welche (2.71), (2.72) enthält. Demnach ergibt sich für den
i-ten Körper mit dem Bezugspunkt Pi
ṗpi = mi r̈r Pi + mi (ω̃ ω iω̃

ω˙ i + ω̃ ω i )rr iP S
i i
(Pi ) (P ) (P )
(2.95)
Li
L̇ = mi r̃r Pi Si r̈r Pi + I i i ω̇ ωi Ii i ω i ,
ω i + ω̃
wahlweise in der Basis (I) oder (K). Führen wir die schon benutzten JACOBI-Matrizen
∂ r iPi ∂ ṙr iPi ∂ ω˙ i ωi

∂ω
J Ti = = , J Ri = = (2.96)
∂qq ∂ q̇q ∂ q̈q ∂ q̇q
ein, dann erhalten wir die kompakte Form der N EWTON -E ULER-Gleichung:
N T
∑ J Ti (ṗpi − f ei ) + J TRi L̇
Li − mei = 0, (2.97)
i=1
in der keine Zwangskräfte mehr auftreten. Wählen wir speziell die Si als Bezugspunkte, d. h.
Pi → Si und r iPi Si = 0 , dann vereinfacht sich (2.95)
ṗpi = mi r̈r Si
(Si ) (Si ) (Si )
(2.98)
Li
L̇ = Ii ω̇ ωi Ii
ω i + ω̃ ωi ,
womit (2.97) auszuwerten ist.

Für eine rechnerorientierte Vorgehensweise ist es zweckmäßig, zunächst (2.97) mit (2.98) in
die Standardform mechanischer Mehrkörpersysteme

M1 0 z̈z1 0 fe
J T
+ − =0 (2.99)
0 M2 żz2 z̃z2 M 2 z 2 me
zu überführen. Dabei gelten die Matrizen:

T T
J = J TT1 , J TT2 , · · · , J TTN , J TR1 , J TR2 , · · · , J TRN = J TT , J TR ; J ∈ R3N, f , (2.100)
M 1 = diag (m1E 3 , m2E 3 , · · · , mN E 3 ) ; M 1 ∈ R3N,3N , E 3 ∈ R3,3 (2.101)

M 2 = diag (II 1 , I 2 , · · · , I N ) ; M 2 ∈ R 3N,3N
, (2.102)
T
z 1 = r Ts1 , r Ts2 , · · · , r TsN ; z 1 ∈ R3N (2.103)
T
z 2 = ω T1 , ω T2 , · · · , ω TN ; z 2 ∈ R3N , (2.104)
z̃z2 = diag (ω̃ω 1 , ω̃ω 2 , · · · , ω̃

ω N ) ; z̃z2 ∈ R3N,3N , (2.105)
T
f e = f Te1 , f Te2 , · · · , f TeN ; f e ∈ R3N , (2.106)
T
m e = m Te1 , m Te2 , · · · , m TeN ; m e ∈ R3N . (2.107)
Die zeitliche Ableitung żz1 von (2.103) lässt sich in der Form
∂zz1 ∂ żz1 ∂zz1

żz1 = q̇q = J T q̇q → = ,
∂qq ∂ q̇q ∂qq
schreiben, so dass
żz1 = JT q̇q und z̈z1 = JT q̈q +J˙T q̇q ,

(2.108)
ω = JR q̇q und ω = JR q̈q +J˙R q̇q .
ω̇
Setzen wir dies in (2.99) ein, so folgt

T T ˙ 0 fe
J M J q̈q + J M J q̇q + J T
−J T
=0 (2.109)
z̃z2 (qq, q̇q) M 2 z 2 (qq, q̇q) me
mit der Blockdiagonalmatrix M = diag(M

M 1 , M 2 ) aus (2.99) und der regulären Massenmatrix
M = J TM J .
Beispiel 2.3: Fortsetzung: Rechnerorientierte Bewegungsgleichungen

Das Doppelpendel nach Bild 2.3 besteht aus N = 2 starren Körpern. Der eingeführ-
te Vektor q der verallgemeinerten Koordinaten gilt weiterhin. Darüber hinaus können
wir davon ausgehen, dass alle kinematischen Größen aus den bisherigen Betrachtun-
gen bekannt sind. Damit sind, ausgehend von den JACOBI -Matrizen J Ti , J Ri , die an-
gepassten Gleichungen (2.99) bis (2.107) sowie die Terme der Bewegungsgleichung
aus (2.109) symbolisch mit MATLAB auszuwerten. Dazu benutzen wir die Built-In
Function blkdiag.m zur Erstellung der Blockdiagonalmatrizen, u. a. von M 1 .
MATLAB Code: (aus kin_NEL.m)

%---- Traegheitstensoren im koerperfesten Koordinatensystem
K_I_S1=diag([I_xx1 I_yy1 I_zz1]); % Haupt-
K_I_S2=diag([I_xx2 I_yy2 I_zz2]); % achsen
%---- JACOBI-Matrizen der Translation
J_T1=jacobian(I_r_S1,q); % Basis der Kraefte
J_T2=jacobian(I_r_S2,q);
%---- JACOBI-Matrizen der Rotation
J_R1=jacobian(K_om1,q_p); % Basis der Momente
J_R2=jacobian(K_om2,q_p);
J=[J_T1;J_T2;J_R1;J_R2]; % Gesamt-JACOBI-M.
%---- zeitl. Ableitung der JACOBI-M. J
J_p=diff(J,alpha_1)*alpha_p1 + diff(J,alpha_2)*alpha_p2 ...
+ diff(J,beta_2)*beta_p2; % Term in (2.108)
118 2 Modellbildung
%---- eingepraegte Kraefte und Momente % (2.106), (2.107)

f_e=[0; 0; m1*g; 0; 0; m2*g]; % Kraefte, I-System
m_e=zeros(3*N,1); % Momentenvektor, N=2
%---- Elemente der Bewegungsgleichungen
M1=blkdiag(m1*eye(3), m2*eye(3)); % Massen-M., Transl. (2.101)
M2=blkdiag(K_I_S1, K_I_S2); % Massen-M., Rotat. (2.102)
M_star=blkdiag(M1,M2); % Gesamt-Massen-M. in (2.99)
disp(’System-Massenmatrix M’) % Ausgabe M(q)
M=simple(simple(J.’*M_star*J)) % System-Massen-M. in (2.109)
f_1=simple(simple(J.’*M_star*J_p*q_p)); % in (2.109)
Z2_tilde=blkdiag(tilde_op(K_om1), tilde_op(K_om2)); % (2.105)
Z2=[K_om1;K_om2]; % (2.104)
f_2=J.’*([zeros(length(M1),1);Z2_tilde*M2*Z2]-[f_e;m_e]); % in (2.109)
disp(’System-Vektorfunktion f’) % Ausgabe f(q,q_p)
f=simple(f_1+f_2) % System-Vektorfunkt. (2.109)
In Abschn. 8.5 ist eine diesbezüglich weitere Anwendung zu finden.
2.5 Lagrange’sche Gleichung 2. Art
Wiederum unter der Voraussetzung eines bekannten Satzes von Minimalkoordinaten (generali-
sierte Koordinaten) liefert die L AGRANGEsche Gleichung 2. Art mit den Definitionen (2.3) nach
Abschn. 2.1

d ∂T T ∂T T ∂V T
− + = Q nk (2.110)
d t ∂ q̇q ∂qq ∂qq
eine analytische Vorgehensweise zur Ermittlung der Bewegungsgleichungen holonomer Systeme

mit der kinetischen Energie T , den konservativen Kräften/Momenten Q k = −(∂V (qq)/∂qq)T , die
sich aus dem Potential V (potentielle Energie) ableiten lassen. Die nichtkonservativen Anteile
(nk) in (2.110) sind Projektionen auf die Achsen der generalisierten Koordinaten, d. h.

N
Q nk = ∑ Ti nki Ri nki
J T
f e + J T
m e (2.111)
i=1
mit den z. B. auf den Bezugspunkt P bezogenen eingeprägten Kräften/Momenten f enki /m menk , die
i
sich nicht aus einem Potential ableiten lassen sowie den bereits eingeführten JACOBI-Matrizen
der Translation JTi und der Rotation JRi . Die JTi beziehen sich in diesem Fall auf P und werden mit
der zugehörigen Absolutgeschwindigkeit v Pi gebildet: JTi = ∂vvPi /∂ q̇q. Reaktions-Kräfte/Momente
aus Bindungen treten nicht auf.
Um (2.110) symbolisch mit Hilfe der Computeralgebra auszuwerten, ersetzen wir die totale
Ableitung nach der Zeit t durch partielle Ableitungen (Hilfsmittel: totales Differenzial) nach den
generalisierten Koordinaten q , q̇q. Dadurch erhalten wir
T
∂ ∂T ∂ ∂T T ∂T T ∂V T ∂ ∂T T
q̈ +
q q̇ −
q + + = Qnk (2.112)
∂ q̇q ∂ q̇q ∂qq ∂ q̇q ∂qq ∂qq ∂t ∂ q̇q
2.5 Lagrange’sche Gleichung 2. Art 119
und mit den Abkürzungen

T
∂ ∂T ∂ ∂T T ∂T T ∂ ∂T T ∂V T
M (qq, t) = , k (qq, q̇q, t) = q̇q − + , p (qq, t) =
∂ q̇q ∂ q̇q ∂qq ∂ q̇q ∂qq ∂t ∂ q̇q ∂qq
die Bewegungsgleichung in der Form
M (qq, t)q̈q + k (qq, q̇q, t) + p (qq, t) = Q nk (qq, q̇q, t) . (2.113)
Legen wir wieder ein System aus N starren Körpern zugrunde, dann wird die kinetische Ener-
gie T , unabhängig von der Basis (I) oder (K), aus den Anteilen Ti des i-ten Körpers zunächst
bezüglich Si gebildet:
N
1 N T (Si )

T = ∑ Ti = ∑ i Si Si
m v T
v + ω I
i i ω i . (2.114)
i=1 2 i=1
D. h. wir können die Größen wahlweise in der Basis (I) oder/und (K) ausdrücken. Vielfach wird
man die Translationsenergie im (I)-System und die Rotations- oder Dreh-Energie (K I ist kon-
stant) im (K)-System anschreiben. Geht man von einer einheitlichen Darstellung im (I)-System
aus, dann ist I I durch (2.69) zu ersetzen.
Setzen wir (2.25) oder (2.29) in (2.114) ein und beachten den S TEINERschen Verschiebungs-
anteil im Trägheitstensor z. B. nach (2.75), so erhalten wir die kinetische Energie (2.114) für den
beliebigen Bezugspunkt Pi
N
1 1 (P )
T = ∑ 2
ω ir Pi Si + ω Ti I i i ω i .
miv TPi v Pi + miv TPi ω̃
2
(2.115)
i=1
Hierin wird deutlich, dass sich der Energieausdruck aus einem Translations-, einem Rotations-
und einem Mischanteil (mittlerer Term) zusammensetzt.
Typische Vertreter konservativer Kräfte ergeben sich aus dem Gravitationseinfluss

N
VG = − ∑ mi r TSi g , g Gravitationsvektor (2.116)
i=1
sowie aus Kopplungen mit linearen Federn mit den Federkonstanten k . Sind Δxxi die relativen,
lokalen Deformationen der am i-ten Körper angreifenden Federn und K i die zugehörige Steifig-
keitsmatrix, dann können wir schreiben:
1 N
VF = ∑ ΔxxTi K i Δxxi ,
2 i=1
Δxxi = Δxxi (qq) . (2.117)
Führen wir noch die JACOBI-Matrix

∂ Δxxi (qq)
JKi =
∂qq
120 2 Modellbildung
ein, so gilt
1 T N T ! 1
VF =
2
q ∑ JKi K i JKi q = q TK q ,
2
KT = K . (2.118)
i=1
Das Potential des Gesamtsystems setzt sich aus der Summe der Einzelpotentiale zusammen. Die
zugehörigen Kräfte/Momente Q k bilden sich zu
T T T
∂V ∂VG ∂VF N
Qk = − =− − = − ∑ mi JTTi g − K q . (2.119)
∂qq ∂qq ∂qq i=1
Fallen Pi , Si zusammen, dann vereinfachen sich die obigen Ausdrücke wieder. Hängen darüber
hinaus, wie vielfach bei Mehrkörperproblemen, Ortsvektoren r = r (qq) und damit die Geschwin-
digkeiten v = v (qq, q̇q) sowie ω = ω (qq, q̇q) nicht explizit von der Zeit t ab, dann kann, wie schon
bei der N EWTON -E ULER-Methode ausgeführt, auch hier der kinematische Zusammenhang des
MKS mit den JACOBI-Matrizen (2.96) hergestellt werden, d. h.
v Si (qq, q̇q) = JTi q̇q, ω i (qq, q̇q) = JRi q̇q (2.120)
für die jeweils gewählte Basis (I) oder (K). Dementsprechend sind natürlich JTi , JRi zu bilden:
∂ I v Si ∂ I r Si ∂ K v Si ∂ K r Si
(I) : JTi = = bzw. (K) : JTi = = (2.121)
∂ q̇q ∂qq ∂ q̇q ∂qq
ω i / ∂ q̇qi .
und in gleicher Weise für die Rotation J Ri = ∂ω
Setzen wir u. a. (2.120) in den Energieausdruck (2.114) ein, dann lautet die kinetische Energie
1 T
T = q̇q M q̇q (2.122)
2
mit der System-Massenmatrix

N
T (Si )
M = ∑ i Ti Ti Ri i Ri
m J T
J + J I J (2.123)
i=1
unter Berücksichtigung der gewählten Basis. Mit (2.122) können wir (2.110) unmittelbar auswer-
ten. Wir erhalten zunächst

d ∂ 1 T ∂V T
M (qq)q̈q + (MM (qq))q̇q − q̇q M (qq)q̇q + = Q nk (qq, q̇q, t) . (2.124)
dt ∂qq 2 ∂qq
Die beiden mittleren Terme auf der linken Seite, die Zentrifugal- und Coriolis-Anteile, formen
wir noch um
∂ 1 ∂
f (qq, q̇q) = (M
Mq̇q) q̇q − Mq̇q)T q̇q
(M
∂qq 2 ∂qq
(2.125)
1 T ∂
= M − M q̇q,
J J JM = (M
Mq̇q) .
2 ∂qq
2.5 Lagrange’sche Gleichung 2. Art 121
Die Bewegungsgleichung hat damit wieder die Struktur

T
∂V
M (qq)q̈q + f (qq, q̇q) = Q nk (qq, q̇q, t), f (qq, q̇q) = f (qq, q̇q) + (2.126)
∂qq
mit der Massenmatrix M nach (2.123) sowie der Vektorfunktion f mit (2.125).
In (2.110) treten bei der Auswertung redundante Terme [56] auf, die den Rechenaufwand
insbesondere bei großen Systemen erhöhen. Aus diesem Grund sind die L AGRANGEschen Glei-
chungen 2. Art für die praktische Aufstellung von Bewegungsgleichungen weniger von Bedeu-
tung.
Beispiel 2.4: Fortsetzung: Bewegungsgleichungen nach Lagrange

Zur Herleitung der Bewegungsgleichungen des Doppelpendels, Bild 2.3, mit dem L A -
GRANGE -Formalismus, bieten sich die beiden Formulierung (2.112) bzw. (2.126) an.
Die erste Betrachtung basiert auf der formalen Auswertung der partiellen Ableitungen
der aufbereiteten L AGRANGEschen Gleichung (2.112), sie ist allgemein gültig. Sie
wird auf das Dreifachpendel in Abschn. 8.5 angewendet. Wir wollen sie hier nicht wei-
ter verfolgen. Der zugehörige MATLAB Code ist im M-File Doppel_NElagra_1.m
nachzulesen [52].
Da die Ortsvektoren r Si = r Si (qq) hier nicht explizit von der Zeit abhängen, kann die
Auswertung von (2.126) erfolgen. Basis hierfür sind die JACOBI-Matrizen u. a. (2.121)
der Translation J T und die der Rotation J R . Hiermit ist die Massenmatrix (2.123) auf-
zubauen. Zur Erstellung der Vektorfunktion f der Zentrifugal- und Coriolis-Anteile
nach (2.125) können wir alternativ die JACOBI-Matrix J M direkt
∂
JM = (M
Mq̇q) (2.127)
∂qq
oder indirekt über die JACOBI-Matrizen bezüglich der Spalten von M
3
∂
JM = ∑ ∂qq (M
M (i, :)q̇i ) (2.128)
i=1
mit der MATLAB-Schreibweise der i-ten Spalte M (i, :) von M und der i-ten Kompo-
nente q̇i aus q̇q auswerten. Die erste Formulierung ist in unserem Fall geringfügig
schneller.
Die konservativen Kräfte der Gewichtseinflüsse ergeben sich nach (2.119) zu
Q k = −m1 J TT1 g − m2 J TT2 g , g = [0, 0, g]T (2.129)
mit der Erdbeschleunigung g.

Der vollständige Programm-Code ist in Doppel_NElagra_2.m [52] zu finden.
Ein wesentlicher Ausschnitt insbesondere bezüglich der Elemente der Bewegungsglei-
chung ist unten wiedergegeben. Die dort nicht erklärten Beziehungen entsprechen de-
nen der vorangegangenen Codes zur Kinematik sowie zur Erstellung der Bewegungs-
gleichungen nach N EWTON -E ULER des Doppelpendels.
122 2 Modellbildung
MATLAB Code: (aus Doppel_NElagra_2.m)
%---- JACOBI-Matrizen der Translation

J_T1=jacobian(I_r_S1,q); % Basis Translat. I
J_T2=jacobian(I_r_S2,q);
J_R1=jacobian(K_om1,q_p); % Basis Rotation K
J_R2=jacobian(K_om2,q_p);
%---- Elemente der Bewegungsgleichung M(q)*q_pp + f(q,q_p) = 0
%---- Massenmatrix
disp(’System-Massenmatrix M’) % Ausgabe M(q)
M=simple(simple(m1*J_T1.’*J_T1+m2*J_T2.’*J_T2 ... % direkte Berechnung
+J_R1.’*K_I_S1*J_R1+J_R2.’*K_I_S2*J_R2));% der Massen-Matrix (2.123)
%---- konservative Kräfte, Gewichtskräfte
Q_k=(m1*J_T1.’+m2*J_T2.’)*[0;0;g]; (2.129)
%---- Vektorfunktion f(q,q_p)
J_M=jacobian(M*q_p,q); % JACOBI-Matrix J_M (2.127)
disp(’System-Vektorfunktion f’) % Ausgabe f(q,q_p)
f=simple(simple((J_M-1/2*J_M.’)*q_p-Q_k)) % (2.126)
In Abschn. 8.5 wird ein weiteres Beispiel behandelt.
2.6 Linearisierung
Wir gehen davon aus, dass für das System (2.6) eine Lösung, die einerseits zeitabhängig, eine
Sollbewegung, oder andererseits konstant, eine Ruhelage, sein kann, bekannt ist. Sollen nun klei-
ne Störbewegungen y(t) um diese Referenzlage q0 (t) betrachtet werden, dann können wir die
lineare Bewegungsgleichung (lineare Variationsgleichung), die nur lineare Terme in y und den
zeitlichen Ableitungen enthält, angeben. Ausgehend von
q (t) = q 0 (t) + y (t), f E (t) := F 0 (t) + ΔF

F (t)
lässt sich die ursprüngliche Bewegungsgleichung (2.6) bezüglich der kleinen Größen
|yy(t)| << 1, |ΔF

F (t)| << 1
in eine TAYLOR -Reihe um q 0 (t) und F 0 (t) entwickeln, vgl. [49]. Wir erhalten für die einzelnen
Terme in (2.6)

f
M
∂M
M (qq0 + y , t) = M (qq0 , t) + ∑ ∂ qi 0
yi + . . .
i=1

∂ f
f (qq0 + y , q̇q0 + ẏy, F 0 + ΔF
F , t) = f (qq0 , q̇q0 , F 0 , t) + y+
∂qq 0

∂ f ∂ f
y
ẏ + ΔF
F + ...
∂ q̇q
0 ∂ fE
0
2.6 Linearisierung 123
Setzen wir diese Ausdrücke in (2.6) ein, so folgt eine Bewegungsgleichung für die Sollbewegung
M (qq0 , t) q̈q0 + f (qq0 , q̇q0 , F 0 , t) = 0 (2.130)
und eine für die gestörte Bewegung
M (qq0 , t) ÿy + P (qq0 , q̇q0 , F 0 , t)ẏy + Q (qq0 , q̇q0 , q̈q0 , F 0 , t)yy = h (ΔF
F , t), (2.131)
mit der symmetrischen Massenmatrix
M := M (qq0 , t) = M T (qq0 , t), (2.132)
der Matrix der geschwindigkeitsabhängigen Kräfte

∂ f
P (qq0 , q̇q0 , F 0 , t) = , (2.133)
∂ q̇q 0
der Matrix der Lage- und Fesselkräfte

Mq̈q
∂M ∂ f
Q (qq0 , q̇q0 , q̈q0 , F 0 , t) = + (2.134)
∂qq 0 ∂qq 0
sowie der äußeren Störung bzw. Erregung

∂ f
h (ΔF
F , t) = ΔF
F. (2.135)
∂ f E 0
Diese Beziehungen beschreiben die Bewegung eines Mehrkörpersystems aus diskreten, starren
Körpern. Sie setzt sich aus der Sollbewegung, die im Allgemeinen einer nichtlinearen (2.130),
und der Störbewegung (2.131), die einem linearen Differenzialgleichungssystem genügt, zusam-
men.
In vielen Fällen lässt sich die Sollbewegung berechnen. Hängt z. B. (2.5), (2.6) nicht explizit
von der Zeit t ab und es existiert für F 0 = f E = konst eine konstante Sollbewegung (Ruhelage,
Gleichgewichtslage oder Arbeitspunkt), dann erhalten wir q 0 = konst – nach (2.130) – aus dem
im Allgemeinen nichtlinearen algebraischen Gleichungssystem
f (qq0 , F 0 ) = 0 ,
welches z. B. näherungsweise mit dem N EWTON -R APHSON-Verfahren gelöst werden kann.

Die Bewegungsgleichung der gestörten Bewegung (2.131) ist nun eine zeitinvariante homo-
gene Differenzialgleichung
M ÿy + P (qq0 , F 0 )ẏy + Q (qq0 , F 0 )yy = 0 (2.136)
mit den konstanten Systemmatrizen M , P , Q . Dabei setzen sich P = D +G

G, Q = K +NN jeweils aus
einem symmetrischen D T = D , K T = K und schiefsymmetrischen G T = −G G, N T = −NN Anteil
zusammen. D ist die Dämpfungsmatrix, K die Steifigkeitsmatrix, G die gyroskopische Matrix
124 2 Modellbildung
und N die Matrix der nichtkonservativen Kräfte (−Ny Ny), vgl. Kapitel 3. Strebt die Lösung y (t)
Ny
asymptotisch gegen Null, dann ist die Gleichgewichtslage q 0 stabil, sonst instabil.
Ist hingegen die Sollbewegung q 0 (t) zeitabhängig, dann sind auch M , P , Q zeitabhängige
Matrizen. Es liegt eine lineare zeitvariante Differenzialgleichung vor. Auch hieraus lassen sich
u. a. lokale Stabilitätsaussagen bezüglich q 0 (t) gewinnen.
Beispiel 2.5: Fortsetzung: Linearisierung um Gleichgewichtslage

Die Linearisierung soll auf die nichtlinearen Bewegungsgleichungen des Doppelpen-
dels nach Bild 2.3
M (qq)q̈q + f (qq, q̇q) = 0 (2.137)
bezüglich der schwach stabilen Gleichgewichtslage

T
q 0 = α10 , α20 , β20 = [ 0, 0, 0 ]T (2.138)
angewendet werden. (2.138) ist Lösung von (2.137). Die gestörte Bewegung genügt
(2.131) mit den von null verschiedenen Matrizen in der Form
M 0 ÿy + Ky = 0 , M 0 = M (qq0 ), K = Q (qq0 ) . (2.139)
Die konstanten Systemmatrizen ergeben sich aus (2.132), (2.133), (2.134), deren sym-
bolische Auswertung ist Inhalt des folgenden Programmsegments.
MATLAB Code: (u. a. aus kin_NE.m in [52], Kinetik-Teil)
M0=subs(M,{alpha_1,alpha_2,beta_2},{0,0,0}) % Massenmatrix (2.136)
f0=subs(f,{alpha_1,alpha_2,beta_2, ... % Vektorf. f(0) aus (2.136)
alpha_p1,alpha_p2,beta_p2},{0,0,0,0,0,0})
P=subs(jacobian(f,q_p),{alpha_1, ... % geschw.-prop. Ant. (2.133)
alpha_2,beta_2,alpha_p1,alpha_p2,beta_p2},{0,0,0,0,0,0})
Q=subs(jacobian(f,q),{alpha_1, ... % ausl.-prop. Anteil (2.134)
!
alpha_2,beta_2,alpha_p1,alpha_p2,beta_p2},{0,0,0,0,0,0}) % q̈q0 = 0
K=1/2*(Q+Q.’); % Steifigkeitsmatrix (3.3)
N=1/2*(Q-Q.’); % nichtkonserv. K. (3.4)
Es ergeben sich die Systemmatrizen
⎡ (S ) ⎤
K Ixx + 4 m1 1 + 1 m2 2 1 2 m2
1 1 2 2 1
0
⎢ (S2 ) ⎥
M0 = ⎣ 2 1 2 m2
1
K Ixx + 4 2 m2
1 2
0 ⎦
(S2 )
K Iyy + 4 2 m2
1 2
0 0
⎡ ⎤
2 1 (m1 + 2m2 )g
1
0 0
K =⎣ 0 1

2 m2 g
2 0 ⎦
0 0 1
m
2 2 2 g
aus denen wir ablesen: Die Pendelbewegungen y1 , y2 , d. h. |α1 | << 1, |α2 | << 1, sind
über die Trägheitsterme gekoppelt, sie entsprechen denen eines ebenen Doppelpen-
dels. Die Bewegung y3 , d. h. |β2 | << 1, ist hiervon entkoppelt. Dies widerspricht dem
nichtlinearen Problem.
2.7 Anwendung der Modellerstellung 125
2.7 Anwendung der Modellerstellung

Oft sind die Modelle überschaubar, u. a. wie das 1/4-Fahrzeugmodell in Kapitel 4 sowie Ab-
schn. 8.6. In diesem Fall sind die Massen frei zu schneiden, die eingeprägten Kräfte/Momente
und Reaktionskräfte einzutragen, Impuls- oder/und Drallsatz für den ebenen Zustand anzuwen-
den und schließlich die Reaktionskräfte zu eliminieren.
Insbesondere bei überlagerten Bewegungen versagt oft die Vorstellung, eine systematische
Aufstellung der Bewegungsgleichungen – vgl. [54], [56], [67] und den balancierenden Roboter
aus 8.8 – ist deshalb sehr hilfreich. Ist die Bewegungsgleichung aufgestellt, so sollte jeder Term
interpretierbar sein. Gegebenenfalls ist die linearisierte Bewegungsgleichung heranzuziehen de-
ren Terme häufig besser einzuordnen sind.
Um dies zu vertiefen, wollen wir wesentliche Elemente der vorgestellten Modellierung auf
das einfache mechanische Modell aus Bild 2.5 anwenden. Der Schwerpunkt liegt dabei in der
mathematischen Modellierung, die Programmierung der symbolischen Ausdrücke beinhaltet im
Wesentlichen die Elemente zum Begleitbeispiel: Doppelpendel der vorangegangenen Abschnitte.
Wir verzichten deshalb auf die Diskussion einzelner Programmsegmente. Die komplette Umset-
zung ist in ImDrLa_1.m der Programmsammlung [52] nachzulesen.
Bild 2.5: Rotierende Scheibe mit geführter Punktmasse
Aufgabe: Die rotierende Scheibe (Ix , Iy , Iz ) sitzt auf einer drehelastischen (kw , dw ) aber biegestei-
fen Antriebswelle, die in ihrem Fußpunkt mit der mittleren, konstanten Winkelgeschwindigkeit
Ω dreht. Der daraus resultierenden Drehung Ωt ist die Störung Φ0 cos Ωt (Winkelschwankung)
überlagert. Durch den Stab auf der Scheibe wird ein Gleitstein (Punktmasse m) reibungsfrei ge-
führt und ist durch ein Feder-Dämpferelement (k, d) an die Scheibe angekoppelt. Die entspannte
Federlänge sei L0 . Mit den Parametern aus Bild 2.5 sind zu ermitteln:
• die nichtlineare Bewegungsgleichung mit Hilfe
– des Impuls- und Drallsatzes und der N EWTON-E ULER-Methode (2.97)
– der L AGRANGEschen Gleichung 2. Art (2.112)
• die bezüglich der Gleichgewichtslage des ungestörten Systems (Φ0 = 0) linearisierte Bewe-
gungsgleichung
126 2 Modellbildung
Lösung: Das Schwingungssystem hat f = 2 Freiheitsgrade – Drehung der Scheibe, Translation

der Punktmasse –, als generalisierte Koordinaten wählen wir zunächst:
q = [ γ, R ]T , γ = Ωt + ϕ , (2.140)
vgl. auch Bild 2.6. Neben dem Inertialsystem (I) wird das scheibenfeste, also mitdrehende,
Körper-Koordinatensystem (K) nach Bild 2.6 eingeführt. Die Drehung erfolgt um die I z-Achse,
so dass die korrespondierende Drehmatrix T γ = T KI (2.14) gilt.
Obwohl nach beiden Methoden (N EWTON-E ULER und L AGRANGE) die Zwangs- bzw. Reak-
tionskräfte (Schnittkräfte) nicht in die Betrachtung eingehen, führen wir sie dennoch teilweise
ein, vgl. Bild 2.6. Die N EWTON-E ULER-Methode wird zeigen, dass sie ausgeblendet werden,
d. h. sie leisten keine virtuelle Arbeit.
• N EWTON-E ULER-Methode: Zunächst betrachten wir die Kinematik des Gleitsteins m. Ausge-
hend von der Beschreibung im (K)-System erhalten wir mit den Bezeichnungen aus Bild 2.5 und
Bild 2.6 den Lagevektor im (I)-System
⎡ ⎤ ⎡ ⎤ ⎡ ⎤
x R−a cos γ − sin γ 0
q) = ⎣ y ⎦ = T IK ⎣ e ⎦ ,
I r S2 (q T IK = T TKI = ⎣ sin γ cos γ 0 ⎦ . (2.141)
I
z b 0 0 1
Da die Zeit in (2.141) nicht explizit auftritt, berechnet sich die Geschwindigkeit nach (2.42) zu

∂ I r S2 (qq) ∂ I r S2 (qq) ∂ I r S2 (qq)
I v S2 (q
q, q̇q) = q̇q = J T (qq) q̇q, J T (qq) = (2.142)
∂q ∂γ ∂R
mit der JACOBI-Matrix der Translation J T . Eine weitere zeitliche Ableitung ergibt nach (2.42)
die Beschleunigung
∂ (JJ T (qq)q̇q)
vS2 (qq, q̇q)
I v̇ = I a(qq, q̇q, q̈q) = I a(t) = J T (qq) q̈q(t) + q̇q . (2.143)
∂qq
Für die Drehung um die I z-Achse ist die Winkelgeschwindigkeit
I ω (q̇
q) = [ 0, 0, γ̇ ]T (2.144)
und die Winkelbeschleunigung

ω (q̇q)
dω ω (q̇q)
∂ω ∂ I ω (q̇q) ∂ I ω (q̇q)
ω (qq, q̈q)
I ω̇ = = q̈q = J R q̈q, JR = , (2.145)
dt ∂ q̇q ∂ γ̇ ∂ Ṙ
mit der JACOBI-Matrix der Rotation J R .

Da der Gleitstein (m) eine Punktmasse ist, folgt seine Bewegung aus dem Impulssatz (2.64)
I a (t) m =I f (S2 ) (2.146)
mit I a (t) nach (2.143) und den eingeprägten Kräften f e der Feder und des Dämpfers sowie der
Bild 2.6: Schnittbild, Kräfte und Koordinaten
Reaktiondkraft f N infolge der Führung FN

(S2 ) (S2 ) (S2 )
If = Ife + Ifr = T IK ( K f F + K f D ) + T IK K f N , (2.147)
wobei im (K)-System
T
KfF = [ −k(R − L0 ), 0, 0 ]T ; KfD = −d Ṙ, 0, 0 ; KfN = [ 0, −FN , 0 ]T (2.148)
die eingeprägten Kräfte K f F , K f D und die Zwangskraft K f N auf den Gleitstein bezogen sind.
Der Drehbewegung der Scheibe liegt der Drallsatz zugrunde. Es wird vorausgesetzt, dass
der Einfluss des Stabes auf die Massenträgheitsmomente der Scheibe vernachlässigbar ist, der
Trägheitstensor
I = diag(Ix , Ix , Iz ), Iy = Ix (2.149)
hat somit Diagonalgestalt und ist unabhängig vom Koordinatensystem (I), (K) konstant. Darüber
hinaus ist die Drehachse raumfest, so dass nach (2.71) der Drallsatz im (I)-System
ω = I m (0)
I I ω̇ (2.150)
folgt. Das auf 0 bezogene Moment I m (0) bilden wir mit den Tildeoperatoren – vgl. (2.74) –, die
mit
K r P1 = [ −a, e, b ]T ; K r S2 = [ R − a, e, b ]T (2.151)
zu bilden sind, so dass
(0) (0) (0)

Im = I m e + I m r = −T T IK K r̃r P1 ( K f F + K f D ) +
T (2.152)
+ 0, 0, −kw (γ − ΦF (t)) − dw (γ̇ − Φ̇F (t)) − T IK K r̃r S2 K f N
128 2 Modellbildung
für das eingeprägte Moment m e und das Zwangsmoment m r – letzter Term – im (I)-System.
Um die Bewegungsgleichungen für γ und R zu erhalten, muss FN eliminiert werden. Diesen
Schritt vollführen wir zweckmäßiger Weise mit Hilfe der JACOBI-Matrix der Translation J T aus
(2.142) und der der Rotation J R nach (2.145). Durch Linksmultiplikation der Teilbewegungen
(2.146), (2.150) jeweils mit J T , J R und anschließender Summation finden wir mit (2.97) die
implizite Bewegungsgleichung:

(S ) (0) (0)
ω −I m e
g (qq, q̇q, q̈q) = J TT I a (t)m − I f e 2 + J TR I I ω̇ = J TT I f r +JJ TR I m r , (2.153)

0
wobei mit (2.143) und (2.145) aus (2.153) folgt:

∂ (JJ T q̇q)
(S ) (0)
m J TT J T +JJ TR I J R q̈q + J TT m q̇q − J TT I f e 2 +JJ TR I m e =0, (2.154)
∂qq
oder kurz
M (qq)q̈q + f (qq, q̇q, t) = 0 . (2.155)
In (2.154) enthält der erste Term die 2×2-Massenmatrix M , der zweite die Coriolis-Kräfte/Momente
und der dritte die Feder-, Dämpfungs- und Anregungs-Kräfte/Momente.
• L AGRANGE-Methode
Für die Herleitung nach dem L AGRANGEschen Formalismus gehen wir bezüglich der Kinematik
einen etwas anderen Weg. Wir legen als generalisierte Koordinaten jetzt

ϕ
qϕ = (2.156)
R
zugrunde. In dieser Schreibweise hängt I r S2 (qqϕ , t) explizit von der Zeit t ab, was bei den zeit-
lichen Ableitungen zu berücksichtigen ist. In I r S2 (qq) nach (2.141) substituieren wir zunächst
γ → ϕ + Ωt, so dass I r S2 (qqϕ , t). Die Absolutgeschwindigkeit lautet in diesem Fall:
∂I r S2 (qqϕ , t) ∂I r S2 (qqϕ , t)
I v S2 (q
q, q̇q, t) = q̇qϕ + = J Tϕ (qqϕ , t) q̇qϕ + v̄v(qqϕ , t) . (2.157)
∂qqϕ ∂t
Das Ergebnis von (2.142) stimmt natürlich mit (2.157) überein.

In den L AGRANGE-Formalismus (2.112) gehen ein:
• kinetische Energie
1
T (qqϕ , q̇qϕ , t) = m I v TS2 I v S2 + I ω T I I ω (2.158)
2
• potentielle Energie
1
V (qqϕ ) = k(R − L0 )2 + kw (ϕ − Φ0 cos (Ωt))2 (2.159)
2
• generalisierte Kraft/Moment bezüglich Dämpfung und Anregung – vgl. (2.111) –

T IK K r̃r P1 K f D + [ 0, 0, −dw (ϕ̇ + Ω Φ0 sin (Ωt)) ]T (2.160)
Q nk (q̇qϕ , t) = J TTϕ T IK K f D +JJ TR −T
Alle Terme werden wieder symbolisch mit dem Rechner ausgewertet, so dass die Bewegungs-
gleichung mit den separierten Erregertermen
M (qqϕ )q̈qϕ + k (qqϕ , q̇qϕ ) + p (qqϕ , q̇qϕ ) = h (t) (2.161)
gebildet werden kann. Die Einzelterme ergeben sich mit dem Programm ImDrLa_1.m aus [52]
zu:

(R − a)2 + e2 m + Iz −me 2 m (Ω + ϕ̇) (R − a) Ṙ
M (qqϕ ) = , k (qqϕ , q̇qϕ ) =
−me m −m (Ω + ϕ̇)2 (R − a)

kw ϕ + dw ϕ̇ Φ0 (kw cos (Ωt) − dw Ω sin (Ωt))
p (qqϕ , q̇qϕ ) = , h (t) = .
k (R − L0 ) + d Ṙ 0
M ist keine Diagonalmatrix, d. h. es besteht eine Kopplung durch die Trägheitsterme, k ist der
nichtlineare Vektor der Coriolis- und Zentrifugalkräfte und koppelt ebenfalls die Bewegungen, p
enthält Feder- und Dämpferkräfte und h (t) die separierten Erregerterme.
• Linearisierung Für kleine Schwingungen der Scheibe ϕ sowie R der Masse m können wir
unter der Voraussetzung
q ϕ = q ϕ,0 +yy(t), h (t) = h 0 + h̃h(t), |yy(t)| << 1, |h̃h| << 1 (2.162)
mit (2.161) eine TAYLOR-Entwicklung bis zum linearen Term durchführen:
M (qqϕ,0 ) q̈qϕ,0 + k (qqϕ,0 , q̇qϕ,0 ) + p (qqϕ,0 , q̇qϕ,0 ) − h 0 +

∂MMq̈qϕ ∂ k (qqϕ , q̇qϕ ) + p (qqϕ , q̇qϕ )
ÿy + ẏy +
∂ q̈qϕ ∂ q̇qϕ (2.163)
0 0

∂ k (qqϕ , q̇qϕ ) + p (qqϕ , q̇qϕ )
y − h̃h(t) = 0 .
∂qqϕ
0
Der Mittelwert h 0 der Erregung h (t) ist null, so dass mit
h0 = 0, h̃h = [ kw Φ0 cos (Ωt) − dw Ω Φ0 sin (Ωt), 0]T
aus den ersten vier Termen von (2.163) die konstante Gleichgewichtslage q ϕ,0 (Ω ), q̇qϕ,0 = 0 ,
q̈qϕ,0 = 0 in Abhängigkeit von Ω aus
k (qqϕ,0 , 0 ) + p (qqϕ,0 , 0 ) = 0 (2.164)

130 2 Modellbildung
zu
⎡ ⎤
0
ϕ0
qϕ,0 = = ⎣ kL0 − amΩ 2 ⎦ (2.165)
R0
k − mΩ 2
folgt. Die restlichen Terme von (2.163) beschreiben die linearen Schwingungen
M0 ÿy + (G
G +D
D) ẏy + K y = h̃h(t) , (2.166)
wobei
• Massen-Matrix M 0 : aus M mit R → R0

(R0 − a)2 + e2 m + Iz −me
M0 =
−me m
• Kreisel- und Dämpfungsmatrix

0 2 mΩ (R0 − a) dw 0
G = , D =
−2 mΩ (R0 − a) 0 0 d
• Steifigkeitsmatrix und Anregungsvektor

kw 0 kw Φ0 cos (Ωt) − dw Ω Φ0 sin (Ωt)
K = , h̃h(t) = .
0 k − mΩ 2 0
M 0 und G hängen von der Gleichgewichtslage ab, G ist darüber hinaus schiefsymmetrisch. Däm-
pfungs- und Steifigkeitsmatrix D , K sind Diagonalmatrizen, wobei K für k < mΩ 2 negativ definit
ist und somit die Schwingung nach Kapitel 3 bzw. [43], [49] instabil ist. Wir setzen deshalb
k > mΩ 2 und nach (2.165) L0 > a mΩ 2 /k, so dass R0 > 0, voraus. Die freien und erzwungenen
Schwingungen von (2.166) lassen sich mit den Methoden des folgenden Kapitels berechnen.
Die Bewegungsgleichungen und deren Linearisierung können auf der Basis der Programmab-
drucke der letzten Abschnitte programmiert oder in [52], Programm: ImDrLa_1.m, eingesehen
werden.
Weitere Beispiele, in denen Bewegungsgleichungen aufgestellt werden, enthält Kapitel 8.
3 Lineare Schwingungsmodelle
In diesem Kapitel werden lineare Systeme, d. h. Systeme, die durch lineare gewöhnliche Diffe-
renzialgleichungen beschrieben werden, numerisch behandelt.
Allerdings ist kein reales System streng durch lineare Differenzialgleichungen beschreibbar.
Die Linearität ist eine Idealisierung, die in vielen Fällen der Wirklichkeit sehr nahe kommt. Vie-
le nichtlineare Systeme haben die Eigenschaft, dass Bewegungen in einer hinreichend kleinen
Umgebung u. a. einer Gleichgewichtslage durch eine linearisierte Bewegungsgleichung (2.131)
gut beschreibbar sind.
Hierfür existieren sehr leistungsstarke und zuverlässige numerische Methoden, mit denen sich
das dynamische Verhalten im Falle kleiner Bewegungen, Schwingungen um einen Arbeitspunkt,
einer Gleichgewichtslage oder einer Referenzlösung untersuchen lässt. Parameterstudien lassen
sich äußerst effizient durchführen, grafisch auswerten und per Animation verdeutlichen. Der Ent-
wurf eines Systems wird dadurch unterstützt und macht z. B. die Bewegungsabläufe verständli-
cher und durchsichtiger.
Unter MATLAB sind die benötigten numerischen Methoden verfügbar und führen bei optima-
ler Vektorisierung mit geringem Programmieraufwand zum Ziel. Wir zeigen dies anhand der
Eigenschwingungen, der freien und fremderregten bzw. erzwungenen Schwingungen mechani-
scher Modelle mit mehreren Freiheitsgraden, der Ein-Massen-Schwinger ist als Sonderfall ent-
halten. Die zugehörigen Hilfsmittel unter MATLAB werden vorgestellt und deren Aufbereitung
beispielorientiert erläutert. Besprochene sowie weiterführende Programme sind in [52] abgelegt.
Eigenschwingungen und freie Schwingungen u. a. mechanischer, elektrischer und mechatroni-
scher Systeme ohne zeitabhängige Fremderregung beschreiben das Schwingungsverhalten nach
anfänglicher Störung. Eine Eigenschwingung wird durch spezielle Anfangswerte, die die Eigen-
schwingungsform erfüllen, ausgelöst; das System schwingt mit der zugehörigen Eigenfrequenz.
Bei der freien Schwingung erfolgt die einmalige Schwingungsanregung durch allgemeine An-
fangswerte. Sie lassen sich z. B. bei mechanischen Systemen durch einen impulsartigen Hammer-
schlag an einem beliebigen Ort erzeugen. Dadurch werden in der Regel alle Eigenschwingungen
angestoßen. Das Frequenzband umfasst somit sämtliche Eigenfrequenzen.
In jedem Falle gewinnt man Aussagen bezüglich der Stabilität der Schwingungen sowie des
Einschwingverhaltens stabiler Modelle z. B. in einen stationären Zustand, bewertet durch die
Schnelligkeit und das Überschwingen, d. h. der Frequenzanteil und das Dämpfungsverhalten der
Schwingung, festgeschrieben durch die Eigenwerte, sind zu beurteilen. Dies schließt eine Bewer-
tung der Regelgüte aktiver linearer Systeme ein.
Darüber hinaus enthalten die Eigenschwingungen Informationen bezüglich periodisch erreg-
ter Systeme, wie z. B. unwuchterregter Turborotoren [18]. Aus den Eigenwerten und Eigenvekto-
ren lassen sich u. a. Resonanz- und Scheinresonanz-Frequenzen ableiten. Weiterhin ermöglichen
die Eigenschwingungsformen Aussagen bezüglich effektiver Lagerstellen sowie Stell- und Mess-
orte aktiver Systeme, so dass u. a. Spillover-Effekte vermieden werden können.
Dem gegenüber stehen die fremderregten Schwingungen. Sie treten auf, wenn am schwingen-
den System isolierte zeitabhängige äußere Kräfte/Momente angreifen. Tritt die Zeitabhängigkeit

DOI 10.1007/978-3-8348-8630-9_3,
132 3 Lineare Schwingungsmodelle
alleine in den Koeffizienten der Bewegungsgleichung (zeitvariante Systeme) auf, so wird von
parametererregten Schwingungen gesprochen, was hier nicht weiter verfolgt wird. Insbesondere
werden hier Systeme mit harmonischer bzw. periodischer Anregung betrachtet. Es interessieren
die Antworten in Form von Amplitude und Phasenlage gegenüber der Anregung; man spricht
auch von stationären Schwingungen. Damit lassen sich u. a. Bauteilbeanspruchungen berechnen
und das Einhalten von Einbauräumen überprüfen. Z. B. muss sichergestellt werden, dass Un-
wuchtschwingungen eines Turboläufers kein Anstreifen der Schaufeln oder/und des Rotors im
Dichtspalt u. a. an die Gehäusewandung verursacht.
Anregungsmechanismen, die zu instationären Schwingungen führen, werden später per Si-
mulation, d. h. der numerischen Integration der Bewegungsgleichungen, gewonnen, siehe u. a.
Abschn. 5.3.1. Die stationären Schwingungen des linearisierten Systems dienen dabei häufig als
Interpretations-Hilfe der Simulationsergebnisse.
Es können nur benötigte Grundlagen zu den Schwingungen angegeben werden. Die numeri-
sche Vorgehensweise, die Vektorisierung und die Programmierung stehen im Vordergrund. Ziel
soll es sein, Hilfsmittel und Anregungen für eine numerische Schwingungsanalyse bereitzustel-
len. Um einen unmittelbaren Bezug zur MATLAB-Formulierung zu haben, werden teilweise pa-
rallel zur analytischen Schreibweise die in MATLAB verwendeten Punktoperationen, u. a. | .* | .\
| .ˆ |, eingeführt. Dies unterstützt die Erstellung eines vektorisierten Codes. U. a. mit [18], [21],
[22], [44], [58] lässt sich die Thematik der Schwingungen vertiefen. In [28] werden die Probleme
auch mit MATLAB behandelt. Insbesondere wird dort auf Übertragungsfunktionen eingegangen.
3.1 Bewegungsgleichungen
Häufig führt die mathematische Formulierung insbesondere mechanischer Modelle1 direkt oder
indirekt über die Linearisierung nichtlinearer Bewegungsgleichungen, wie u. a. in Abschn. 2.6
und Abschn. 2.7 gezeigt, auf lineare Bewegungsgleichungen mit f Freiheitsgraden, vgl. (2.136),
und somit der Ordnung n = 2 f
Mÿy + Pẏy + Qy = h(t) (3.1)
mit den konstanten f × f -Matrizen M , P , Q , dem f ×1-Lage-Vektor y der generalisierten (verall-

gemeinerten) Koordinaten sowie seinen zeitlichen Ableitungen ẏy, ÿy. Der Vektor h (t) beschreibt
eine konstante und/oder eine explizit von der Zeit abhängige äußere Störung. In mechanischen
Modellen ist die Massenmatrix M stets symmetrisch M T = M und positiv definit – kurz M > 0
–, d. h. jede mit einem beliebigen Vektor, außer dem Nullvektor, gebildete quadratische Form,
z. B. ṽvTM ṽv ist positiv [58]. Sind P und Q unsymmetrisch, dann lassen sie sich stets in einen
symmetrischen und schiefsymmetrischen Anteil entsprechend
P = D +G
G; Q = K +N
N (3.2)
zerlegen. Die symmetrischen Anteile folgen aus:

1 1
K = QT ,
Q +Q K = K T; D = PT ,
P +P D = DT , (3.3)
2 2
1 Definition: Mechanisches Modell wird durch ein System von Differenzialgleichungen 2. Ordnung beschrieben
3.1 Bewegungsgleichungen 133
die schiefsymmetrischen Anteile aus:

1 1
G = PT ,
P −P G = −G
GT ; N = QT ,
Q −Q NT .
N = −N (3.4)
2 2
Damit gelten auch die Bewegungsgleichungen
M ÿy + (G
G + D )ẏy + (K
K + N )yy = h (t) (3.5)
mit
M = MT > 0 Massenmatrix, positiv definit M > 0 , M = M T stets erreichbar
G = −GGT Matrix der gyroskopischen Kräfte, schiefsymmetrisch
D =D T Dämpfungsmatrix, symmetrisch, nichtkonservativ
K = KT symmetrischer Anteil der Steifigkeitsmatrix; konservativ
N = −NNT Matrix der nichtkonservativen Kräfte, schiefsymmetrisch
h (t) Anregungsvektor (äußere Störung).
Nach den auftretenden Matrizen in einer Bewegungsgleichung wird das zugehörige mathemati-
sche Modell, z. B. MK- oder MDGK-System, benannt. Durch diese Klassifizierung gewinnt man
nicht nur erhebliche Vorteile für die mathematische und numerische Behandlung – Strukturen der
Lösungen sind bekannt –, sondern auch rein qualitative Rückschlüsse auf das Systemverhalten.
Dies ist insbesondere für Stabilitätsaussagen [43] und damit für die Beurteilung der gewonnenen
numerischen Ergebnisse wichtig und hilfreich.
Rotoren in Gleitlagern oder/und mit innerer Dämpfung führen auf (3.5). Jedoch können auch
spezielle Koordinatensysteme auf scheinbare nichtkonservative Kräfte (−Ny Ny
Ny) führen; z. B. bei
dem mathematischen Modell eines Rotorsystems mit unrunder Welle formuliert im mitdrehenden
Koordinatensystem. N ist somit eine Folge des gewählten Koordinatensystems.
Wegen der Linearität von (3.5) gilt das Überlagerungsprinzip. Die allgemeine Lösung y (t)
ist deshalb als Summe der allgemeinen Lösung y h (t) der zugehörigen homogenen Differenzi-
algleichung, sie enthält die Integrationskonstanten, und jeweils einer partikulären Lösung y p (t)
(hh(t)
= 0 ) der inhomogenen Gleichung darstellbar:
y (t) = y h (t) +yy p (t) . (3.6)
Die Integrationskonstanten werden durch Anpassen an die Anfangswerte bestimmt. Dies wird
für die allgemeine Lösung u. a. in Abschn. 8.2 gezeigt.
Führen wir den Zustandsvektor
T
x = y T , ẏyT (3.7)
der Zustände y , ẏy ein, dann geht (3.1) in die Zustandsgleichung
ẋx = Ax + b (t) (3.8)
über mit der n × n-System- bzw. Zustands-Matrix A und dem n × 1-Störvektor b

0 f,f E f,f T
A = , b(t) = 0T , hT (t) . (3.9)
−MM −1Q −M M −1P
Die allgemeine Lösung setzt sich wie in (3.6) zusammen:
x = x h (t) +xx p (t) . (3.10)
3.2 Eigenschwingungen und freie Schwingungen

Die Lösung der der Differenzialgleichung (3.1) bzw. (3.5) zugeordneten homogenen Differenzi-
algleichung (hh(t) ≡) entspricht einer Eigenschwingung bzw. freien Schwingung, die durch einen
speziellen bzw. beliebigen Anfangszustand angestoßen wird. Diese Eigenschwingungen und frei-
en Schwingungen sollen zunächst untersucht werden.
Da es sich bei dem betrachteten System um ein Schwingungssystem handelt, liegt ein Ansatz
für die Lösung des homogenen Teils von (3.5) in der Form

λ = δ +iω Eigenwert √
y h (t) = ṽv eλt ; , i = −1 (3.11)
ṽv = ṽv + i ṽv
R I Eigenvektor
nahe. Damit erfassen wir den grenzstabilen Fall (δ = 0), für den eine harmonische Lösung vermu-
tet werden kann, bzw. den asymptotisch stabilen (instabilen) Fall mit harmonischer Lösung mit
exponentiell abklingender (δ < 0) (aufklingender (δ > 0)) Amplitude sowie den aperiodischen
Grenzfall mit verschwindendem Imaginärteil (ω = 0).
Der an die Zustandsgleichung (3.8) mit b (t) ≡ 0 angepasste Lösungsansatz der homogenen
Lösung ist
T
x h = v eλt (mechanisches Modell: v = ṽvT , λ ṽvT ). (3.12)
Neben dem hier verwendeten geschwindigkeitsproportionalen Dämpfungsansatz gibt es Model-

le, z. B. der äußeren und inneren Dämpfung oder Strukturdämpfung, die durch Differenzialglei-
chungen ungerader Ordnung beschrieben werden. Das einfachste Modell besteht aus einer Hin-
tereinanderschaltung eines Federelements und eines geschwindigkeitsproportionalen Dämpfer-
elements (M AXWELL -Modell, vgl. Beispiel 5.1 und Abschn. 8.6). Darüber hinaus sind mecha-
nische Systeme häufig mit elektrischen, hydraulischen, pneumatischen und thermodynamischen
Systemen gekoppelt und ggf. noch mit einer Steuer- oder Regeleinheit ausgestattet. Derartige
Systeme lassen sich in den seltensten Fällen auf die Form (3.1) bringen, können aber stets in
(3.8) eingearbeitet werden, so dass (3.8) die allgemeinere Formulierung darstellt. Die Eigenvek-
toren haben dann natürlich nicht die in (3.12) angedeutete Struktur.
Wir werden zwischen den linearen allgemeinen Systemen, deren Dynamik letztlich einem
System von Differenzialgleichungen 1. Ordnung genügt, und den speziellen mechanischen Sys-
temen, die sich durch ein System von Differenzialgleichungen 2. Ordnung beschreiben lassen,
unterscheiden. Die Koordinaten x repräsentieren den Zustandsraum, die von y den Konfigurati-
onsraum.
3.2.1 Das Eigenwertproblem in MATLAB, allgemeine Betrachtung

Mit dem Ansatz (3.11) bzw. (3.12) erhält man, abhängig von der Struktur der Bewegungsglei-
chung, ein Eigenwertproblem (genauer Eigenwert-Eigenvektorproblem). Da wir dieses nume-
risch lösen wollen, ist von existierenden Codes für Eigenwertprobleme auszugehen. Es wird
3.2 Eigenschwingungen und freie Schwingungen 135
zwischen dem allgemeinen und dem speziellen, bzw. gewöhnlichen Eigenwertproblem
Av = λB
Bv , Av = λvv (3.13)
mit dem Eigenwert λ und dem (Rechts-) Eigenvektor v unterschieden, wobei wir in dieser all-
gemeinen Betrachtung die in MATLAB üblichen Bezeichnungen zunächst beibehalten. Gleichun-
gen (3.13)1 und (3.13)2 sind homogene algebraische Gleichungen, die nur für bestimmte Werte
λ nichttriviale Lösungen v
= 0 besitzen. Darüber hinaus ist v nur bis auf einen beliebigen Fak-
tor ermittelbar und wird deshalb geeignet normiert ausgegeben; vgl. Online-Hilfe. Für beide
Formen existieren Codes (Unterprogramme) in unterschiedlichen Programmiersprachen, wobei
vielfach durch entsprechende Transformationen vorab (3.13)2 erzeugt wird (z. B.: A := B−1A mit
B regulär). Um den Rechenaufwand zu reduzieren, sind in der Regel bei der Code-Auswahl die
Eigenschaften der Matrizen A, B, z. B. Symmetrie, zu berücksichtigen. Die MATLAB-Functions
eig eigs
nehmen einem diese Entscheidungen teilweise ab. Es werden die Eigenwerte und Vektoren von
(3.13)1,2 berechnet; vgl. Online-Hilfe:
⇒ help eig, help eigs
Während mit eig alle Eigenwerte und Eigenvektoren z. B. einer reellen oder komplexen symme-
trischen oder unsymmetrischen quadratischen Matrix A durch Umformungen – direkte Methode
– ermittelt werden, berechnet eigs alle oder wahlweise nur einige iterativ mit vorgegebenen Spe-
zifikationen. Die quadratische Matrix A kann in diesem Fall voll besetzt sein, alle Elemente
werden explizit vorgegeben, oder spärlich besetzt sein, nur von Null verschiedene Elemente wer-
den gespeichert und bearbeitet. A , B sind dann Sparse-Matrizen, vgl. S. 15. Symmetrische oder
unsymmetrische, reelle oder komplexe Sparse-Matrizen sind zulässig; siehe auch DrehSchw.m,
QuerSch_1,2.m in [52].
Liegt ein allgemeines Eigenwertproblem vor, dann muss B symmetrisch (B BT = B ) und positiv
definit (BB > 0 ) sein, weil in eigs zunächst ein spezielles Eigenwertproblem mittels C HOLESKY-
Zerlegung formuliert wird. Tabelle 3.1 zeigt typische MATLAB-Aufrufe zur Eigenwert- und Ei-
Tabelle 3.1: Typische Function-Aufrufe für eig und eigs
d = eig(A) bestimmt den Vektor d aller Eigenwerte, direkte Methode

[V,D] = eig(A) bestimmt die Matrizen der Eigenvektoren V und der Eigen-
werte D (Diagonalmatrix); spezielles Eigenwertpr. (3.13)2
[V,D] = eig(A,B) allgemeines Eigenwertproblem (3.13)1
d = eigs(A) bestimmt iterativ den Vektor d der k=6 größten Eigenwerte

d = eigs(A,B,k,sigma,opts) allgemeinste Form; B muss positiv definit sein,
k Anzahl der zu berechnenden Eigenwerte,
Spezifikationen: sigma, z. B. ’sm’ kleinsten Eigenwerte,
opts, u. a. Genauigkeit opts.tol, Ausgabe opts.disp.
[V,D ,flag ] = eigs(A,. . .) bestimmt die Matrizen der Eigenvektoren V und
der Eigenwerte D (Diagonalmatrix)
Konvergenzinformation: flag = 0 Konvergenz, sonst keine
genvektorberechnung. Die zugehörigen Online-Hilfen geben weitere Hinweise und Möglichkei-

ten, insbesondere auch bezüglich der Normierung der Eigenvektoren.
Im Folgenden werden anhand ausgewählter Strukturen von (3.5) mit h (t) ≡ 0 Methoden und
spezielle Eigenschaften der Schwingungen herausgearbeitet.
3.2.2 Numerische Behandlung der Eigenwertprobleme

Die Aufgabe, die sich uns stellt, ist mit der gegebenen Bewegungsgleichung eines der Eigen-
wertprobleme in (3.13) zu formulieren, d. h. die Matrizen A , B zuzuordnen. Die erforderlichen
Schritte werden an unterschiedlichen Bewegungsgleichungen, die in (3.5) enthalten sind, disku-
tiert. Dabei wird im Folgenden auf die Indizierung h, p von y , x , wie in (3.6) und (3.12), verzichtet,
d. h. wir schreiben stets y , x . Was gemeint ist, folgt aus dem Zusammenhang.
In den Projekten: Störgrößenkompensation von Fundamentschwingungen Abschn. 8.2,
Schwingungstilger mit viskoelastischem Anschlag Abschn. 8.3 und Zur Stabilität des Levitron-
Spielzeug-Kreisels in Abschn. 8.7 wird die Problematik angewendet bzw. vertieft. Zusätzliche In-
formationen bezüglich der Programmierung und insbesondere der Animation von Schwingungen
können den Programmen linear_InDrLa.m, DrehSchw.m sowie QuerSchw_1,2.m in
[52] entnommen werden. In DrehSchw.m werden Drehschwingungen in QuerSchw_1,2.m
Biegeschwingungen von Rotorsystemen berechnet und grafisch ausgewertet.
3.2.2.1 Das konservative System ohne gyroskopischen Einfluss

Ny
Treten keine nichtkonservativen Kräfte (−Ny
Ny) auf und sind Dämpfungseinfluss sowie gyrosko-
pischer Einfluss gering und damit vernachlässigbar oder auch gar nicht vorhanden, so liegt mit
D = G = N = 0 ein konservatives System, für das die Gesamtenergie während der Schwingung
konstant bleibt, mit der Bewegungsgleichung aus (3.5)
M ÿy + K y = 0 ; M = M T > 0; K = K T (3.14)
vor. Die Gleichung (3.14) beschreibt Eigenschwingungen und freie Schwingungen ungedämpfter
Systemen, vielfach Strukturschwingungen [22]. Die in Bild 3.1 skizzierte Schwingerkette mit
den zugehörigen Systemmatrizen
⎡ ⎤ ⎡ ⎤
m1 0 0 k01 + k12 −k12 0
M = ⎣ 0 m2 0 ⎦ , K = ⎣ −k12 k12 + k23 −k23 ⎦ (3.15)
0 0 m3 0 −k23 k23 + k03
ergibt (3.14) mit M > 0 , K > 0 ; M, K ∈ R3,3 .
Bild 3.1: Schwingerkette

Tabelle 3.2: Systemparameter
Parameter symmetrisch unsymmetrisch Einheit

m1 2 2 kg
m2 5 7 kg
m3 2 5 kg
k01 1000 1000 N/m
k12 750 2000 N/m
k23 750 2500 N/m
k03 1000 700 N/m
Das Eigenwertproblem und Stabilitätsaussagen: Die Eigenschwingungen genügen (3.11), al-

so
y = ṽv eλt ; λ Eigenwert; ṽv Eigenvektor, (3.16)
so dass das allgemeine Eigenwertproblem
−λ 2M ṽv = K ṽv (3.17)
folgt. Einerseits kann ṽv nur bis auf einen beliebigen Faktor bestimmt werden, andererseits ist nur
dann ṽv
= 0 , wenn die Koeffizienten-Determinante verschwindet:
|λ 2M + K | = 0 . (3.18)
Dies liefert die charakteristische Gleichung, sie ist ein Polynom f -ten Grades in λ 2 . Folglich gibt
es f Quadrate der Eigenwerte λ12 , λ22 , ..., λ f2 , die mit der Vielfachheit ρ j ≥ 1 auftreten können.
Unter der Voraussetzung M T = M > 0 und K T = K ist nach [9] der Defekt der Koeffizienten-
matrix (λ j2M + K ) gleich der Vielfachheit ρ j von λ j2 . D. h. es existieren genau f Quadrate der
Eigenwerte λ j2 , wenn man etwaige Mehrfachwurzeln entsprechend ihrer Vielfachheit zählt. Dar-
über hinaus existieren zu den λ j2 f linear unabhängige reelle Eigenvektoren ṽv j , sie sind in der
Regel nicht zueinander orthogonal.
Neben λ j ist auch −λ j Eigenwert von (3.18), d. h. die Lösung y (t) ist nur dann (schwach)
stabil bzw. grenzstabil, wenn alle λ j verschwindende Realteile haben. Aus (3.17) folgt
λ 2ṽvTM ṽv + ṽvTK ṽv = 0, (3.19)
wobei ṽvTM ṽv stets positiv reell und ṽvTK ṽv positiv oder negativ reell oder null ist. Die Eigenwerte
folgen damit aus (3.19) zu
ṽvTK ṽv
λ2 = − . (3.20)
ṽvTM ṽv
D. h. die Struktur der Eigenwerte und damit die Stabilität von y (t) wird durch ṽvTK ṽv festgeschrie-
ben. Wir unterscheiden:
ṽvTj K ṽv j > 0, für alle j pos. def. → λ j2 < 0, λ j,1,2 = ±iω j
ṽvTj K ṽv j = 0, für mindestens ein j sem. def. → λ j2 = 0, λ j,1,2 = 0 (3.21)
ṽvTj K ṽv j < 0, für mindestens ein j neg. def. → λ j2 > 0, λ j,1,2 = ±δ j
Das System ist somit grenzstabil (bzw. schwach stabil) oder instabil. Bei Null-Eigenwerten z. B.
der Vielfachheit 2, dies ist der Fall, wenn in (3.15) k01 = k03 = 0 – die Schwingerkette ist nicht
gefesselt –, dann treten Starrkörperbewegungen auf, die Lösung enthält säkulare Terme; siehe
auch DrehSchw.m in [52].
Sind M T = M > 0 und K T = K ≥ 0 , dann können wir statt (3.16) den reellen Ansatz
y = ṽv cos ωt; ω Eigenkreisfrequenz; ṽv Eigenvektor, (3.22)
wählen, so dass das allgemeine Eigenwertproblem
ω 2M ṽv = K ṽv; d. h. λ 2 = −ω 2 → λ = ±i ω (3.23)
zu lösen ist.
MATLAB-Formulierung: Ein Vergleich von (3.17) mit (3.23) zeigt, dass das Eigenwertproblem
vom jeweiligen Ansatz (3.16) bzw. (3.22) abhängt. In beiden Fällen liegt ein allgemeines Eigen-
wertproblem (3.13)1 vor, so dass entsprechend der MATLAB-Formulierung in (3.13)
2
λ
A → K ; B → ∓ M Berechnung von
ω2
zu beachten ist. Wir wählen den reellen Ansatz (3.23).
Zunächst geben wir unten die Programmierung des Eigenwertproblems mit eig an. Wegen bes-
serer Übersichtlichkeit und weil oft nur die niedrigsten Eigenfrequenzen interessieren, sind die
in d ausgegebenen Eigenkreisfrequenzen ω j mit der Sortier-Function sort in eine aufsteigende
Folge, gespeichert in es, zu bringen. Die Eigenvektoren sind anschließend mit dem Vektor der
Sortierindizes I wieder den Eigenwerten zuzuordnen. Danach können sie ggf., z. B. für eine bes-
sere grafische Darstellung, umskaliert werden, z. B. so, dass das betragsmäßig größte Element zu
eins wird. Programmsegment aus frei.m in [52]:
[v,d] = eig(K,M); % Eigenwertproblem
[es,I] = sort(sqrt(diag(d))); % Eigenkreisfr. in aufsteigender Folge
v = v(:,I); % Eigenvektoren neu zugeordnet
vn = v/diag(max(abs(v))); % Umskalierung der Eigenvektoren
... ...
Die Eigenschwingungen: Die Schwingungen der MK-Systeme M T = M > 0 , K T = K > 0 sind
grenzstabil; die Eigenschwingungen harmonisch. Die Eigenschwingungen bilden wir mit (3.22),
d. h. ωk , ṽvk reell:
y k = ṽvk cos ωk t . (3.24)
Hierin sind die Eigenschwingungsformen (Mode shapes) enthalten. Man skizziert von (3.24) den
Anfangszustand y k (0) = ṽvk (oder von ẏyk (0)), z. B. über den Lagen von mk wie in Bild 3.2, in dem
sich die Eigenschwingung zur Zeit t = 0 befindet, und erhält somit Aussagen über das Verhältnis
der Ausschläge (bzw. Geschwindigkeiten) zu allen Zeiten. D. h. lenkt man den Schwinger an-
fänglich entsprechend ṽvk aus – oder befindet er sich infolge harmonischer Anregung in Resonanz
–, dann schwingt er mit der zugehörigen Eigenschwingungsform mit der Eigenkreisfrequenz ωk ,
wie in Bild 3.3 oben für ω2 .
MATLAB-Grafiken der Eigenschwingungsformen: Die grafische Auswertung der Eigenschwin-

gungsformen in Bild 3.2 mit den Systemparametern nach Tabelle 3.2 erfolgt mit dem Programm-
segment aus frei.m in [52]:
figure(1) % Grafik-Fenster 1 öffnen

set(gcf,’DefaultLineLineWidth’,1) % alle Linienstärken geändert
for ef=1:3 % Ausgabe der 3 Eigenformen
subplot(3,2,(2*ef-1)) % Unterfenster mit 2 Spalten
plot(v(:,ef)) % ef-te Eigenform v oder vn
set(gca,’xtick’,[1:1:3]) % Tick-Marken, Massenposition
axis([1,3,-1,1]) % Achsenskalierung
if ef == 1
title(’Eigenschwingungsformen’); % Bildtitel
end
grid
end
Die internen Bildbeschriftungen lassen sich nach Abschn. 1.6.2.5 hinzufügen oder mit dem
text-Befehl einbringen. Weitere grafische Ausgaben der Eigenschwingungsformen sind wie in
DrehSchw.m/QuerSchw_1,2.m aus [52] zu erzeugen.
Bild 3.2: Eigenschwingungsformen der symmetrischen und unsymmetrischen Schwingerkette
Die freien Schwingungen: Die allgemeine Lösung von (3.14), d. h. die freie Schwingung, mit
den ermittelten Eigenkreisfrequenzen ωk und Eigenvektoren ṽvk stellt sich als Summe aller Eigen-
schwingungen dar:
f
y (t) = ∑ ṽvk (sk sin ωkt + ck cos ωkt) = (ṼV s ). ∗ sin ω t + (ṼV c ). ∗ cos ω t, (3.25)
k=1
mit

V = ṽv1 , ṽv2 , . . . , ṽv f
Ṽ Modalmatrix
T
ω = ω1 , ω2 , . . . , ω f Vektor der Eigenkreisfrequenzen
T
c = c1 , c2 , . . . , c f Vektoren der Inte-
T
s = s1 , s2 , . . . , s f grationskonstanten,
wobei wir Mehrfacheigenwerte [9], wie im Fall einer Starrkörperbewegung, ausschließen. Sie
bereiten numerische Schwierigkeiten, vgl. Abschn. 1.8.8, und bedürfen einer speziellen Betrach-
tung. Die Lösung enthält säkulare Terme.
Die Integrationskonstanten sk und ck bzw. s , c ermitteln sich mit 2 f vorgegebenen Anfangs-
werten y (0) = y 0 und ẏy(0) = v 0 , z. B. zum Zeitpunkt t = 0. Dies führt auf die entkoppelten
algebraischen inhomogenen Gleichungssysteme für c und s
y 0 = Ṽ
V c, v 0 = (Ṽ ω.
V s ). ∗ω (3.26)
Die Zeitverläufe der freien Schwingungen folgen direkt aus (3.25). Für eine MATLAB-Formulier-
ung gehen wir von dem Zeilenvektor t T der diskreten Zeitpunkte tk , k = 1,2, . . . aus und schrei-
ben
y (tt T ) = Ṽ ω t T ) + diag(cc) cos (ω

V (diag(ss) sin (ω ω t T )) (3.27)
mit den f × f -Diagonalmatrizen bezüglich s , c . Die Dimension der Rechteck-Matrix y (tt T ) hängt
von f und dem Diskretisierungsgrad von t ab.
MATLAB-Formulierung und numerische Ergebnisse: Damit können wir (3.26) und (3.27) der
freien Schwingungen und deren grafische Darstellung programmieren, vgl. frei.m in [52]:
y0=[1.; 0.; -1.]; v0=zeros(3,1); % Anfangswerte
% Integrationskonstanten
c = v\y0; s = es.\(v\v0); % cos-, sin-Anteil (3.26)
te = 4*pi/es(1); % Zeitendpunkt, z. B.
t = linspace(0,te); % Zeitvektor, 100 Werte
y= v*(diag(s)*sin(es*t)+diag(c)*cos (es*t)); % Schwingung nach (3.27)
figure(2) % grafische Darstellung
set(gcf,’DefaultLineLineWidth’,1) % Linienstärke geändert
subplot(211)
plot(t,y(1,:),t,y(2,:),’-’,...
t,y(3,:),’o’,’MarkerSize’,2)
L=axis; xlim([L(1) te]) % Achsenskalierung
title(’Freie Schwingungen ... % Bildüberschrift
für spezielle Anfangswerte’)
xlabel(’Zeit t [s]’); ylabel (’y1, y2, y3’) % Achs-Beschriftung
legend(’y1’,’y2’,’y3’,-1) % Linienkennung
grid
Im Bild 3.3 sind die freien Schwingungen y j (t) der symmetrischen Schwingerkette – vgl.
Tabelle 3.2 – für zwei Anfangswertzustände dargestellt. Im oberen Bild 3.3o entsprechen die
Anfangsauslenkungen denen der zweiten Eigenschwingungsform aus Bild 3.2, so dass die beiden
äußeren Massen gegenphasig, also mit einer Phasenverschiebung von π schwingen, während die
mittlere Masse in Ruhe bleibt. Die Schwingungsfrequenz ergibt sich aus ω2 zu f2 = 2π/ω2 .
Dieser spezielle Schwingungszustand folgt auch unmittelbar aus (3.25) mit
y (0) = y 0 = α ṽv2 , ẏy(0) = v 0 = 0 , α reell,
so dass sich aus (3.26)

−1
c = αṼ
V ṽv2 = α[0 1 0]T und s = 0
ergeben und schließlich aus (3.25)
y (t) = α ṽv2 cos ω2t.
Im unteren Bild 3.3 unten sind die freien Schwingungen für allgemeinere Anfangswerte darge-
stellt, es werden alle drei Eigenschwingungsformen angestoßen.
Bild 3.3: Freie Schwingungen der Schwingerkette
3.2.2.2 Das konservative System mit gyroskopischem Einfluss

Der ungedämpfte linearisierte Schwinger aus Abschn. 2.7 ist ein MGK-System und wird mit der
vorgestellten Vorgehensweise im Programm linear_ImDrLa.m in [52] untersucht. Darüber
hinaus wird im Projekt zum Levitron-Kreisel in [52] die Stabilisierung infolge des Kreiselein-
G(Ω )) in Abhängigkeit von der Winkelgeschwindigkeit Ω grafisch herausgearbeitet.
flusses (G
Der gyroskopische Effekt tritt stets in mit Ω rotierenden Komponenten auf, so dass u. a. die
Eigenwerte und Eigenvektoren Ω -abhängig sind, z. B. λk = λk (Ω ); vgl. QuerSchw_1,2.m,
Zentrifuge.m in [52].
Die Struktur der Eigenwerte: Ausgehend von der Bewegungsgleichung
M ÿy + Gẏy + K y = 0 ; M = M T > 0, K = K T ; G = −G

GT (3.28)
folgt mit
y = ṽv eλt (3.29)
das Eigenwertproblem
(λ 2M + λG
G + K )ṽv = 0 (3.30)
als Matrizenpolynom 2-ter Ordnung und aus der Determinate der Koeffizientenmatrix die cha-
rakteristische Gleichung
|λ 2M + λG
G + K| = 0 . (3.31)
Da das zugehörige adjungierte Problem (λ 2M + λG G + K )T zwar unterschiedliche Eigenvekto-

ren aber gleiche Eigenwerte besitzt, muss gelten
|λ 2M + λG
G + K | = |λ 2M − λG
G + K | = 0, (3.32)
so dass wieder λk und −λk Eigenwerte von (3.30) sind. D. h. y (t) ist nur dann grenzstabil, wenn
alle λk verschwindende Realteile haben.
√
Sei ṽv = ṽvR − i ṽvI , i = −1 der zu ṽv = ṽvR + i ṽvI konjugiert komplexe Eigenvektor, dann
erhalten wir aus (3.30) durch Linksmultiplikation mit ṽvT
λ 2ṽv M ṽv + λ ṽv Gṽv + ṽv K ṽv = 0,

T T T
(3.33)
woraus wir den Eigenwert

2
−ṽv Gṽv ± ṽv Gṽv − 4 ṽv M ṽv ṽv K ṽv
T T T T
λ= (3.34)
2ṽv M ṽv
T
gewinnen. Das Vorzeichen vor der Wurzel muss (3.30) erfüllen. Für die einzelnen Terme in (3.34)
können wir die Aussagen treffen:
T
ṽv M ṽv = ṽvR − i ṽvI M ṽvR + i ṽvI
T T
T T
(3.35)
= ṽvR M ṽvR + ṽvI M ṽvI positiv reell
⎧
⎨ positiv reell
T RT IT
ṽv K ṽv = ṽv K ṽvR + ṽv K ṽvI 0 (3.36)
⎩
negativ reell
T
ṽv Gṽv = ṽvR − i ṽvI G ṽvR + i ṽvI
T T
T T
(3.37)
= i ṽvR GṽvI − ṽvI GṽvR rein imaginär,
T T
wobei wegen G = −G GT die Terme ṽvR GṽvR = 0 und ṽvI GṽvI = 0 verschwinden müssen. Daraus
folgt, dass die Eigenwerte λ in (3.34) für positiv definites K (ṽv K ṽv > 0) stets rein imaginär sind,
T
was mit der obigen Aussage: λk , −λk Eigenwerte von (3.30) auf
√
λk,k+1 = ±iωk , i = −1
führt.
Ist K negativ definit, d. h. ṽvk K ṽvk < 0 für mindestens ein k, und der Radikand in (3.34) positiv,
T
dann wird (3.34) erfüllt durch
λk,..,k+3 = ±(δk ± iωk ) instabil,
bzw. bei genügend großem Drall
λk,k+1 = ±iωk grenzstabil.
D. h. der Kreiseleinfluss stabilisiert das System; vgl. Stabilitätssätze von T HOMSON und TAIT
sowie von P. C. M ÜLLER in [43] und Projekt Levitron-Kreisel in [52].
Im Fall ṽvT vk = 0 gibt es Starrkörpermoden mit λk = 0 bzw. K ṽvk = 0 nach (3.30).
k K ṽ
Eigenwertproblem aus der Zustandsgleichung: Das zugehörige Eigenwertproblem ist wegen

(3.13) mit der Zustandsdarstellung von (3.8) zu bilden, es folgt die homogene Zustandsgleichung

0 E T
ẋx = −1 −1 x oder kurz ẋx = Ax Ax, x = y T , ẏyT (3.38)
−MM K −M M G
mit der n × n-Zustandsmatrix A . Der Ansatz (3.12) liefert direkt das spezielle Eigenwertproblem
λE
E v = Av
Av, ( für mech. Systeme nach (3.1): v = (ṽvT , λ ṽvT )T ), (3.39)
so dass der Zustandsvektor x mit dem Eigenvektor v korreliert, E ist die Einheitsmatrix.
Die Ordnung des Eigenwertproblems (3.39) hat sich gegenüber (3.17) verdoppelt. Wie gezeigt,
existieren für K > 0 n komplexe Eigenwerte, die paarweise konjugiert λk = +iωk , λk+1 = −i ωk
sind. D. h. ungedämpfte gyroskopische Systeme sind mit M = M T , K = K T > 0 , unabhängig von
G stets grenzstabil. Sie können aber auch für K < 0 grenzstabil sein, wenn der Drall genügend
groß, d. h. G geeignet. Wegen G (Ω ) gilt λ (Ω ).
MATLAB-Formulierung des Eigenwertproblems für zuvor vereinbarte Systemmatrizen M , G ,

K – vgl. linear_ImDrLa.m in [52]:
f = length(M); % Freiheitsgrad. des Syst.

A = [zeros(f) eye(f) % Zustandsmatrix A (3.38)
-M\[K G]];
[v,d] = eig(A); % Eigenvekt. (v), Eigenwerte (d)
[es,I] = sort(imag(diag(d)*i)’); % nur Sortierindex I wichtig
es = diag(d(I,I)); % aufsteigende Vektor-Folge (ω j )
ve = v(:,I); % Zuordnung der Eigenvektoren
% (...*i)’ liefert konj. kompl. Anteil
% konj. kompl. Paare bleiben in es zusammen
Die Eigenschwingung zu λk = +iωk , λk+1 = −i ωk ist
x k (t) = v k eiωk t +vvk+1 e−iωk t = v k eiωk t +vvk e−iωk t (3.40)
und die zugehörige Eigenschwingungsform
x k (0) = v k +vvk = 2ℜ(vvk ), v k konjugiert kompl. zu v k , (3.41)
die 2 ist für die grafische Darstellung bedeutungslos. Weitere Möglichkeiten zur Darstellung der
Eigenschwingungsformen sind mit QuerSchw_1,2.m aus [52] zu erzeugen.
Bearbeitet man das Eigenwertproblem mit eigs, dann kann es gegenüber (3.38) numerisch
stabiler sein, wenn von einer Zustandsgleichung der Form
Bẋx = Ax (3.42)
mit den vollbesetzten Matrizen oder Sparse-Matrizen

E 0 0 E
B = ; A = ; BT = B > 0 (3.43)
0 M −KK −G G
ausgegangen wird.
MATLAB -Aufruf: [v,d] = eigs(A,B,’sm’,opts);
Im Gegensatz zu (3.38), wo die Inverse von M eingeht, wird in (3.42) mit der C HOLESKY -
Zerlegung von B gearbeitet, um zunächst ein spezielles Eigenwertproblem zu formulieren. Dies
ist numerisch vorteilhafter, wirkt sich aber wegen der doppelten Dimension von B gegenüber M
nachteilig auf die Rechenzeit aus. Weitere Zustandsformen lassen sich erzeugen, vgl. [29].
Die freien Schwingungen: Die freien Schwingungen können im Reellen und im Komplexen
formuliert werden. MATLAB-orientierter und auf allgemeine Systeme übertragbar ist eine For-
mulierung im Komplexen, wobei wir Mehrfacheigenwerte ausschließen. Mit dem Ansatz (3.12)
folgt die allgemeine Lösung als Linearkombination der Eigenlösungen
n
x (t) = ∑ ckv k eλkt , (3.44)
k=1
wobei die Koeffizienten ck von Anfangswerten abhängen. Mit Hilfe der Modalmatrix
V = [vv1 , v 2 , . . . , v n ]
und den komplexen Größen
eλ t := [eλ1t , . . . , eλnt ]T ; c = [c1 , c2 , . . . , cn ]T
kann (3.44) in Matrizenform geschrieben werden:
x (t) = V diag(cc) eλ t = V diag(eλ j t ) c . (3.45)
Mit dem reellen Anfangswertvektor x (0) = x 0 zum Zeitpunkt t = 0 folgt unmittelbar das alge-
braische Gleichungssystem für c :
V c = x0 , MATLAB: c = V\x0; oder linsolve(V,x0); (3.46)
Die Zeitschriebe x (t) werden wieder mit dem zeitdiskreten Zeilenvektor t T (t=0:dt:te )
gebildet, so dass (3.45) MATLAB-orientiert lautet:
x (tt T ) = V diag(cc) eλ t ,
T
diag(cc) n × n − Matrix, λt T dyadisches Produkt. (3.47)
Jede Zeile x i (tt T ) entspricht einem zeitdiskretisierten Graphen; demnach ist x (tt T ) eine Rechteck-
matrix.
MATLAB Code der freien Schwingungen für gegebene Anfangswerte x0, siehe auch
linear_ImDrLa.m in [52]:
c = v\x0; % Integrationskonstanten (3.46)
te = 8.0*pi/imag(es(1)); % Endzeit, gewählt 8π/ωmin
t = linspace(0,te); % 100 diskrete Zeitpunkte
x = real(v*diag(c)*exp(diag(d)* t)); % freie Schwingung x (tt T ) (3.47)
plot(t,x(1,:),’-.r’, t,x(2,:),’b’) % Plot der ersten Komp. von x
Infolge Rundungsfehler enthält x kleine Imaginäranteile, die mit real unterdrückt werden.
Ist man nur an der Diskussion der Auslenkung y(t) interessiert oder ist der Ausgang von (3.38)
eine Linearkombination yM (t) der Zustandsvariablen, kann es zweckmäßig sein, die algebraische
Ausgangsgleichung (Messgleichung)
y M (t) = C xx(t) (3.48)
hinzuzufügen. y M ist der m-dimensionale Ausgangsvektor, C die Ausgangsmatrix passender Di-

mension. Für die Eigenschwingungen und Eigenschwingungsformen gilt:
y Mk (t) = Cv k eλk t
t=0
−→ y Mk (0) = Cv k . (3.49)
Formulierung mit der Fundamentalmatrix: Mit (3.45) und (3.46) folgt die weit verbreitete
Formulierung der freien Schwingungen:
x (t) = V diag(eλ j t )V
V −1x 0 = V eΛt V −1 x 0 = Φ (t) x 0 , Λ = diag(eλ j t ), (3.50)
mit der Fundamentalmatrix [9]

−1
Φ (t) = V diag(eλ j t )V
V −1 = e V ΛV t = e At , MATLAB: expm(A*t). (3.51)
Sie ist für eine numerische Auswertung im Allgemeinen wenig geeignet. Wir geben dennoch
eine Berechnung der homogenen Lösung in [0, te] für den Anfangszustand x (0) = x 0 an:
t = linspace(0, te, 250); % Zeitvektor
for ii=1:length(t) % ii-ter Zeitschritt
x(:,ii) = expm(A*t(ii))*x0; % Lösung nach (3.50)
end
Diese Betrachtungsweise wird bei den erzwungenen Schwingungen im Abschn. 3.3.2.5 noch
einmal aufgegriffen.
3.2.2.3 Das gedämpfte gyroskopische System

Die zum MDGK-System gehörende Bewegungsgleichung erhalten wir unmittelbar aus (3.38),
wenn wir in der Systemmatrix A die Matrix G durch D + G ersetzen. Das linearisierte Schwin-
gungsmodell aus Abschn. 2.7 bezüglich der homogenen Gleichung von (2.166) ist ein MDGK-
System.
Für das Eigenwertproblem gilt dann wieder (3.39); MDK-Systeme sind hierin enthalten. Die
Dämpfung ist geschwindigkeitsproportional. In vielen Fällen ist dies eine vertretbare Näherung.
Die Dämpfungskoeffizienten sind Erfahrungswerte oder stammen aus Experimenten. Gelegent-
lich setzt man die Dämpfungsmatrix proportional zur Steifigkeits- oder/und Massenmatrix an:
D = αM
M + βK
K, R AYLEIGH-Dämpfung , (3.52)
wobei α, β geschickt zu wählen sind.

Die Dämpfung kann eine innere (Material- oder Strukturdämpfung) oder äußere (umgebenes
Medium, Lagerdämpfung) sein. Aufgrund der Dämpfung liegen im Allgemeinen K konjugiert
komplexe Eigenwertpaare
λk = −δk + iωk , λk+1 = −δk − iωk , k = 1, 3, 5, · · · , K (schwache Dämpfung)
sowie R = 2(n − K) reelle Eigenwerte der Form
λr = −δr , r = 2K + 1, 2K + 2, . . . , 2n
und die zugehörigen Eigenvektoren mit gleicher Struktur vor. Die Schwingungen sind somit
asymptotisch stabil, wenn alle Realteile δ größer Null sind, im Fall eines δ gleich Null grenz-
stabil und im Fall eines δ kleiner Null instabil.
Stabilitätsabschätzung liefert der Satz von T HOMSON -TAIT-C HETAEV (1961) [9], [43]:
Für M = M T > 0 , D = DT > 0

(3.53)
entscheidet K = K T unabhängig von G über die Stabilität.
Ist K = K T > 0 , dann ist das System unabhängig von G asymptotisch stabil. Ein statisch instabi-
les System, K < 0 , kann demnach beim Vorhandensein von Dämpfung nicht durch Kreiselkräfte
stabilisiert werden. D. h. auch die Definitheitseigenschaften von D sind von Bedeutung: Wenn D
D > 0 ), dann ist jede beliebige Bewegung mit Energieverlust, d. h. mit Dämpfung,
positiv definit (D
D ≥ 0 ) werden nicht alle Koordinaten direkt gedämpft,

verbunden. Wenn D positiv semidefinit (D
die Dämpfung kann aber trotzdem auf alle anderen Koordinaten durchdringen, man spricht von
durchdringender Dämpfung. Dies lässt sich mit Hilfe der Steuerbarkeitsbedingungen nachwei-
sen; vgl. [9].
Die Schwingungen und Dämpfungsmaße: Die komplexe Formulierung der freien Schwingun-
gen einschließlich der Anpassung an die Anfangswerte kann aus dem Abschnitt 3.2.2.2 des
MGK-Systems übernommen werden.
Zur Beurteilung der Systemdämpfung benutzt man neben den Abklingkonstanten δk – auch als
Eigendämpfung bezeichnet – weitere Größen, die sich ebenfalls auf die einzelnen Eigenschwin-
gungen x k = v k eλk t beziehen, wobei wir nur schwach gedämpfte Schwingungen mit δk < ωk
betrachten. Es seien hier die Definitionen des L EHRschen oder modalen Dämpfungsmaßes
δk δk
Dk = ! , bzw. für |δk | << ωk Dk ≈ (3.54)
ωk2 + δk2 ωk
und die des logarithmischen Dekrements
2πDk 2πδk
ϑk = ! = . (3.55)
1 − D2k ωk
genannt.
MATLAB-Umsetzung: Vorausgesetzt die Eigenwerte λ sind wegen G (Ω ) von der Winkelge-
schwindigkeit Ω rotierender Komponenten abhängig, so lassen sich die Eigenkreisfrequenzen
ωk (Ω ) und die Abklingkonstanten δk (Ω ) für k = 1, 2, · · · , K zu = 1, 2, · · · , L Ω -Werten in
den L × K-Matrizen om und dk abspeichern. Die Programmierung von (3.54), (3.55) folgt in:
Dk=dk./sqrt(om.ˆ2 + dk ) % Lehrsches Dämpfungsmaß (3.54)
theta=2*pi*Dk./sqrt(1-Dk.ˆ2); % logarithmisches Dekrem. (3.55)
figure, plot(Om, Dk(:,1:2)) % Grafik, Dk über Ω
Vgl. auch linear_ImDrLa.m, Zentrifuge.m in [52]; insbesondere die zugehörigen grafi-
schen Auswertungen.
3.2.2.4 Das allgemeine nichtkonservative System

Die Bewegungsgleichung des MDGKN-Systems entspricht der von (3.5). Das Eigenwertproblem
folgt aus (3.39), wenn wir in der Systemmatrix A die Matrix G durch D + G und K durch K + N
ersetzen. Die Aussagen über Anzahl und Form der Eigenwerte und -Vektoren gelten auch hier.
Stabilitätssätze, die bereits Aussagen aufgrund des Gleichungsaufbaus liefern, existieren hier
nicht. Die Stabilitätsaussagen müssen mit Hilfe der Realteile der Eigenwerte getroffen werden.
Im Einzelnen gelten die Aussagen [9]:
Die Lösung x ≡ 0 eines linearen zeitinvarianten Systems ẋx = Ax
Ax, x (t0 ) = x 0 , ist genau dann
1. asymptotisch stabil, wenn alle Eigenwerte λk von A negative Realteile haben, ℜ(λk ) < 0
k = 1, 2, . . . , n,
2. stabil, wenn A keine Eigenwerte mit positivem Realteil, aber solche mit verschwindendem
Realteil besitzt, ℜ(λk ) = 0, und bei mehrfachen Eigenwerten der Rangabfall der Matrix
(λEE −A A) gleich der Vielfachheit dieser Eigenwerte ist,
3. instabil, wenn mindestens ein Eigenwert λk von A einen positiven Realteil hat, ℜ(λk ) > 0,
oder die Rangbedingung nach 2. für mehrfache Eigenwerte nicht erfüllt ist.
Für die Lösung gilt wieder (3.44), (3.45) unter den dort eingeführten Voraussetzungen. Alle
Sonderfälle sind u. a. in [9] nachzulesen.
3.3 Erzwungene Schwingungen

Die Stabilität der Schwingung wird durch die Eigenwerte der zugehörigen homogenen Differenzi-
algleichung festgeschrieben. Ist das System asymptotisch stabil, dann klingen im stationären Be-
trieb die anfänglich angestoßenen Eigenbewegungen ab und es bleiben die erzwungenen Schwin-
gungen. Man spricht auch von dem eingeschwungenen bzw. stationären Zustand.
Erzwungene Schwingungen sind die Folge von Fremderregung, auch äußere Anregung bzw.
Erregung oder Störfunktion genannt. Die Fremderregung tritt immer als isolierte Zeitfunktion
auf. Nach (3.1) lautet die Bewegungsgleichung für ein System mit f Freiheitsgraden:
M ÿy + Pẏy + Qy = h (t), P = D +G

G, Q = K +N
N, M , P , Q konstant. (3.56)
Bezüglich der rechten Seite unterscheidet man z. B. Krafterregung, Fußpunkterregung und Un-
wuchterregung. Die Bewegungen y können translatorischer wie rotatorischer Art sein. Bezüglich
der Erregerstruktur h (t) unterscheiden wir:
• Erregervektor beliebig: gesonderte Betrachtung, heute vielfach numerische Integration.

• Erregervektor fastperiodisch
s c
h (t) = h 0 + ∑k (ĥhk sin Ωk t + ĥhk cos Ωk t); Ωm
= Ωn .
Dabei sind die Ωk irgendwelche Frequenzen. Lassen sich die Ωk als Linearkombinationen
von endlich vielen Basisfrequenzen Ωk anschreiben, z. B.
Ωk = k Ω1 + Ω2 + m Ω3 , k, , m ganz,
so spricht man von quasiperiodischer Erregung.
• Erregervektor periodisch, z. B. aus einer F OURIER-Entwicklung:
h (t +T ) = h (t), Ωk = mn Ω ; Ω Basiskreisfrequenz, m, n ganz, T kleinste Periodendauer.
Aufgrund des Superpositionsprinzips können die Schwingungen fastperiodischer, quasiperiodi-

scher und periodischer Anregung stets aus Teillösungen harmonischer Erregung zusammenge-
setzt werden, so dass wir zur Erläuterung der Vorgehensweise nur mit dem harmonischen Erre-
gervektor
s c
Φ)
h (t) = h 0 + ĥh sin Ωt + ĥh cos Ωt = h 0 + ĥh. ∗ cos (eeΩt −Φ (3.57)
zu arbeiten brauchen, wobei Φ = (Φ1 , . . . , Φ f )T der Nullphasenwinkel-Vektor (hier: Nacheil-

winkel), e = (1, 1, . . . )T der Eins-Vektor sowie .∗ eine elementweise Multiplikation, eine Punk-
toperation ist. Die Lösungsanteile y pk von (3.56) mit (3.57), d. h. infolge konstanter h 0 und har-
monischer Terme
yp = ∑ y pk (3.58)
k=1,2
3.3 Erzwungene Schwingungen 149
für (3.1), werden hier ermittelt, wobei wir wieder statt y p stets kurz y schreiben. Die allgemeine
Lösung folgt schließlich aus der Überlagerung aller Teillösungen wie in (3.6) bzw. (3.10). Sie
ist an Anfangswerte anzupassen, wie in Abschn. 8.2 sowie in anpass.pdf und in erzw.m,
linear_ImDrLa.m aus [52] gezeigt.
Systemparameter
Masse 1 m1 = 100 kg
Masse 2 m2 = 5 kg
Steifigkeit k01 = 105 N/m
Steifigkeit k12 = 104 N/m
Dämpfung d01 = 10 Ns/m
Dämpfung d12 = 1 Ns/m
Erdbeschleunigung g = 9,83 m/s2
s
Erreger- ĥh = [20, 0]T N
c
Amplituden ĥh = [50, 0]T N
Bild 3.4: Beispiel: Zwei-Massen-Schwingerkette
Alle vorgestellten Methoden werden auf die Zwei-Massen-Schwingerkette aus Bild 3.4 ange-
wendet und programmiert. Wichtige Programmsegmente sind abgedruckt, der vollständige Code
erzw.m mit der grafischen Auswertung in der Function: plot_erzw.m ist in [52] abgelegt.
Bemerkung zum Schwinger: In der Lage y1 = 0, y2 = 0 sind die Federn entspannt, an beiden
Massen greift eine harmonische Erregung an. Die Bewegungsgleichung entspricht (3.56) mit
G = N = 0 und h (t) nach (3.57) sowie

m1 0 k01 −k12 d01 −d12 m1 g
M = ; K = ; D = ; h =
0
,
0 m2 −k12 k12 −d12 d12 m2 g
s,c
den Erregeramplituden ĥh und Parametern aus der Tabelle neben Bild 3.4.
3.3.1 Konstante Erregung

Da bezüglich (3.56) mit (3.57) auch das Superpositionsprinzip gilt, soll die konstante Erregung
h 0 für sich betrachtet werden. Die Bewegungsgleichung lautet:
M ÿy + Pẏy + Qy = h 0 , speziell: h 0 = [ m1 g, m2 g ]T = konst. (3.59)
Der Lösungsansatz vom Typ der rechten Seite
y (t → ∞) = y ∞ = konst., ∞ kennzeichnet die eingeschwungene Lage (3.60)
führt auf das algebraische inhomogene Gleichungssystem
Q y∞ = h0, Q regulär MATLAB: y_inf = Q\h0 (3.61)
für y ∞ , der statischen Ruhelage, Gleichgewichtslage oder bei allgemeiner periodischer Anregung
den Mittelwert der Schwingung.
3.3.2 Harmonisch angeregte mechanische Systeme
Für den harmonischen Erregerterm in (3.57) bieten sich mehrere Formulierungen an, die sich im
Lösungsweg und der Interpretation der Lösung unterscheiden. Einige sollen vorgestellt werden.
3.3.2.1 Reelle Formulierung der Erregung
Die Bewegungsgleichung (3.62) steht einerseits für eine Schwingung um y ≡ 0 andererseits für
eine um die Gleichgewichtslage y ∞ nach (3.61), denn mit y := y ∞ +yy folgt aus (3.56) mit (3.57):
s c
M ÿy + Pẏy + Qy = ĥh sin Ωt + ĥh cos Ωt . (3.62)
Der Lösungsansatz
y (t) = ŷys sin Ωt + ŷyc cos Ωt (3.63)
kann entsprechend (3.57) auch als cos- (oder sin-) Funktion mit dem Phasenwinkel-Vektor Φ
Φ ),
y (t) = ŷy. ∗ cos (eeΩt ±Φ e = [1, 1, . . . , 1, 1]T Eins-Vektor, (3.64)
hier in MATLAB -orientierter Form, geschrieben werden, wobei (+ , −) für einen Phasenvoreil-
bzw Phasennacheilwinkel steht. Aus (3.64) folgt mit dem Additionstheorem
y (t) = ŷy. ∗ (cos Ωt cos Φ ∓ sin Ωt sin Φ ) .
Ein Vergleich mit (3.63) ergibt dann
ŷyc = ŷy. ∗ cos Φ ; ŷys = ∓ŷy. ∗ sin Φ
und schließlich folgt der Amplituden-Vektor

ŷy = ŷys . ∗ ŷys + ŷyc . ∗ ŷyc = ŷys .ˆ 2 + ŷyc .ˆ 2 (3.65)
sowie der Vektor der Nullphasenwinkel ( (−) Voreil-, (+) Nacheilwinkel )
Φ = arctan(∓ ŷys ./ŷyc ). (3.66)
Setzen wir (3.63) in (3.62) ein und gleichen die linear unabhängigen sin - und cos -Terme ab, so
finden wir das algebraische inhomogene Gleichungssystem
s " s #
Q − Ω 2M −ΩP P ŷy ĥh
= c (3.67)
ΩP P Q − Ω 2M ŷyc ĥh
oder kurz
T s c
T
H (Ω )ȳy = h̄h, ȳy = (ŷys )T , (ŷyc )T , h̄h = (ĥh )T , (ĥh )T (3.68)
und schließlich
H (Ω ))−1 h̄h = F (Ω )h̄h,

ȳy = (H MATLAB: yq=H\hq, für Ω =konst. (3.69)
mit der reellen Frequenzgang-Matrix F (Ω ). Gleichung (3.69) und damit die Amplituden ŷy nach
(3.65) sowie den Phasenwinkel Φ nach (3.66) werten wir in Abhängigkeit von Ω aus und er-
halten den Amplituden- und Phasenfrequenzgang. Man spricht auch von einem quasistationären
Hochlaufvorgang. Dies lässt sich unmittelbar programmieren.
MATLAB-Formulierung des MPQ- bzw. MDGKN-Systems

% M, h_s, h_c,.. vorab vereinbart
f=length(M); n=2*f; % f Freiheitsgrad, n=2f Systemordn.
II=2000; % II, Anzahl diskreter Om-Werte
Om=linspace(Oma,Ome,II) % Om-Vektor, II Werte
yq=zeros(n,II); % Vorabdimensionierung
hq=[h_s;h_c]; % Anregungshypervektor nach (3.68)
for ii=1:II % Lösung für Om(ii)
H=[Q-Om(ii)ˆ2*M -Om(ii)*P; % Koeffizientenmatrix aus (3.67)
Om(ii)*P Q-Om(ii)ˆ2*M]; %
yq(:,ii)=H\hq; % lineare Gleichung nach (3.69)
end
yd_s=yq(1:f,:); % Daten trennen in sin-
yd_c=yq(f+1:n,:); % cos-Anteile, wie in (3.68)
yd=sqrt(yd_s.ˆ2+yd_c.ˆ2); % Amplitude (3.65)
phi=atan2(-yd_s,yd_c); % Phase in cos(Om*t+Phi) (3.66)
Sind darüber hinaus die Zeitverläufe der harmonischen Schwingung zu Ω = konst von Inte-
resse, dann ist es zweckmäßig (3.63) auszuwerten. Mit t T = (t1 , t2 , . . . , 2π/Ω ) geht (3.63) in
die Matrizengleichung
y (tt T ) = ŷys sin Ωtt T + ŷyc cos Ωtt T , Ω = konst (3.70)
über, was im folgenden Programmsegment ausgewertet ist.
JJ=....; Omt=Om(JJ); % JJ-te Komp. aus Om, Ω = konst

t=linspace(0,2*pi/Omt,200) % Zeitvektor, 200 Werte
yt=yd_s(:,JJ)*sin(Omt*t)... % Zeitverläufe (3.70) über eine
+yd_c(:,JJ)*cos(Omt*t); % Periode T für Omt=Om(JJ)
plot_erzw(Om,yd,phi,t,yt,2,titel) % Plot-Function aus [52]
Alternativ zu t kann die dimensionslose Zeit τ = Ωt, 0 ≤ τ ≤ 2π eingeführt werden.

In Bild 3.5 sind Amplituden- und Phasenfrequenzgang sowie die Zeitsignale zu Ω = 50.01
rad/sec des Schwingers aus Bild 3.4 dargestellt. Es treten für Ω ≈ ω1 und Ω ≈ ω2 Resonanzüber-
höhungen mit gleichzeitigem Phasenwechsel auf. Die Eigenkreisfrequenzen ω1,2 ermitteln sich
mit (3.39).
MQ-System: Ist P = 0, liegt also ein MKN- oder MK-System vor, dann zerfällt (3.67) bezüglich
der Sinus- und Cosinus-Terme in die beiden algebraischen Gleichungssysteme f -ter Ordnung
Bild 3.5: Ergebnisse zum gedämpften System mit harmonischer Anregung
mit zwei rechten Seiten; nu = 2

s c
Q − Ω 2M [ŷys , ŷyc ] = ĥh , ĥh (3.71)
oder kurz
s,c
Q − Ω 2M ŷys,c = ĥh , (3.72)
was den Rechenaufwand gegenüber (3.67) reduziert: Ordnung ist halbiert, Umformung der Ko-
Q − Ω 2M ) = 0 tritt Resonanz auf; Ω = ω j , Die
effizientenmatrix erfolgt nur einmal. Für det(Q
Ergebnisse speichern wir in dreidimensionalen Feldern (Arrays), vgl. S. 23. Zu jeder f × nu -Seite
gehören die Ergebnisse eines Ω -Wertes.
MATLAB-Formulierung des MQ-Systems, vollständig in [52], Programm erzw.m:
% f, nu, JJ usw. vorab vereinbart % vgl. erzw.m
II=length(Om); % Dimension von Om, Ω
y_sc=zeros(f,nu,II); % 3D-Null-Array, II Seiten
for ii=1:II % Lösung von Seite ii
H0=Q-Om(ii)ˆ2*M; % Koeffizienten-Matrix (3.72)
y_sc(:,:,ii)=H0 \[h_s,h_c]; % Lösung von (3.72), 2 rechte S.
end
yd=sqrt(y_sc(:,1,1:II).ˆ2+... % Amplitude ŷy (3.65)

y_sc(:,2,1:II).ˆ2);
phi=atan2(-y_sc(:,1,1:II),... % Phase in cos(Om*t+phi) (3.66)
y_sc(:,2,1:II));
t=linspace(0,2*pi/Omt,200); % Zeitv., Omt=Om(JJ), Ω = konst
yt=y_sc(:,1,JJ)*sin(Omt*t)... % Zeitverl. (3.70), JJ gewählt,
+y_sc(:,2,JJ)*cos(Omt*t); % über eine Periode T = 2π/Ω
plot_erzw(Om,yd,phi,t,yt,1,titel) % grafische Auswertung
3.3.2.2 Komplexe Anregungsfunktion
Eine weitere Formulierung basiert auf komplexen Anregungsfunktionen. Wir ersetzen hierzu die
Zeitfunktionen der Anregungsterme in (3.62) durch
1 iΩt 1 iΩt √
cos Ωt = e + e−iΩt , sin Ωt = i e − e−iΩt , i= −1
2 2
und erhalten damit für (3.62)

M ÿy + Pẏy + Qy = ĥh eiΩt +ĥh e−iΩt (3.73)
mit den komplexen Anregungsamplitudenvektoren

1 c s

ĥh = ĥh − i ĥh ; ĥh konj. kompl. zu ĥh . (3.74)
2
Die Lösung von (3.73) y = ξ +ξξ ermitteln wir mit dem ersten Term der rechten Seite aus
M ξ̈ξ + Pξ̇ξ + Qξ = ĥh eiΩt (3.75)
und dem Lösungsansatz
ξ = ξ̂ξ eiΩt . (3.76)
Da in ξ̂ξ die Phaseninformation enthalten ist, muss auch ξ̂ξ komplex sein. Der Amplitudenvektor
ξ
ξ̂ berechnet sich nach einsetzen von (3.76) in (3.75) zu
−1
ξ̂ξ = −Ω 2M + iΩP
P +Q
Q ĥh = F (iΩ )ĥh, (3.77)
wobei F (iΩ ) die komplexe Frequenzgang-Matrix ist. Für den zweiten Lösungsanteil gilt

ξ = ξ̂ξ e−iΩt → ξ̂ξ = F (−iΩ )ĥh , (3.78)

so dass (3.75) mit der rechten Seite ĥh e−iΩt erfüllt ist. Die Lösung von (3.73) genügt dann

y (t) = ξ̂ξ eiΩt +ξ̂ξ e−iΩt ; ξ̂ξ konj. kompl. zu ξ̂ξ
(3.79)
= 2|ξ̂ξ |. ∗ cos (Ωeet + arg (ξ̂ξ )), MATLAB-orientiert
oder
y (t) = 2Re(ξ̂ξ ) cos Ωt −2Im(ξ̂ξ ) sin Ωt = ŷyc cos Ωt + ŷys sin Ωt. (3.80)

ŷyc ŷys
Geometrisch stellt (3.79) zwei Drehzeiger dar, die gegenläufig mit Ω umlaufen. Die Resultieren-
de ist, wie in Bild 3.6 für die k-te Komponente gezeigt, die reelle Lösung (3.80).
Bild 3.6: Zeigerdarstellung zur Lösung (3.79)
MATLAB-Formulierung, MPQ-System mit komplexem Erregervektor, vgl. erzw.m in [52]:

xi_d=zeros(f,II); % 2D-Zero-Array, II Om-Werte
hd=0.5*(h_c-i*h_s); % Anregungsvektor ĥh, (3.74)
for ii=1:II
H=Q-Om(ii)ˆ2*M +i*Om(ii)*P; % H=inv(F) aus (3.77)
xi_d(:,ii)=H\hd; % Amplitude ξ̂ξ nach (3.77)
end
yd=2.0*abs(xi_d); % Amplitude ŷy, (3.79)
phi=angle(xi_d); % Phase cos(Om*t+Phi) (3.79)
JJ=......; Omt=Om(JJ); % JJ-te Komponente
yt=xi_d(:,JJ)*exp(i*Omt*t); % Teillösung (3.76)
yt=real(yt+conj(yt)); % Zeitv., eine Periode (3.79)
plot_erzw(Om,yd,phi,t,yt,3,titel)
3.3.2.3 Komplexe Bewegungsgleichung

Eine Variante zur Formulierung in Abschn. 3.3.2.2: Wir fügen zu (3.62) formal eine zweite Glei-
chung hinzu
s c
M ÿy + Pẏy + Qy = ĥh sin Ωt + ĥh cos Ωt
s c (3.81)
M ẍx + Pẋx + Qx = −ĥh cos Ωt + ĥh sin Ωt,
und bilden für ζ = y + i x die komplexe Bewegungsgleichung

c s
M ζ̈ζ + Pζ̇ζ + Qζ = (ĥh − i ĥh ) eiΩt . (3.82)
Die Lösung von (3.81)1 ist dann y (t) = Re(ζζ (t)). Mit dem Ansatz
ζ = ζ̂ζ eiΩt
ergibt sich aus (3.82) die komplexe Amplitude

−1 c s

ζ̂ζ = −Ω 2M + iΩP P +QQ ĥh − iĥh (3.83)
und hiermit die Lösung
y (t) = Re(ζ̂ζ eiΩt )

(3.84)
= |ζ̂ζ |. ∗ cos (Ωeet + arg (ζ̂ζ )) = Re(ζ̂ζ ) cos Ωt − Im(ζ̂ζ ) sin Ωt.
3.3.2.4 Lösungsverhalten
Alle vorgestellten Methoden zur Bestimmung der Schwingungsamplituden führen auf ein alge-
braisches inhomogenes Gleichungssystem der Struktur
H (Ω )ûu = fˆ
und damit auf
ûu = H −1 (Ω ) fˆ
(3.85)
= F (Ω ) fˆ
mit der Frequenzgangmatrix
H (Ω ))
adj(H H (Ω ))
adj(H
F (Ω ) = = (3.86)
H (Ω ))
det(H N
aus der Adjungierten und der Determinanten von H . Demnach folgt für eine Lösungskomponente
aus (3.85)
Zj 1 1
û j = , aus: ûu = H (Ω )) fˆ = Z ,
adj(H
N N N
womit vier Lösungstypen zu unterscheiden sind
1. Zj
= 0, N
= 0 Allgemeine Lösung, Amplituden beschränkt
2. Zj = 0, N
= 0 Tilgung, einzelne Amplituden verschwinden
3. Zj
= 0, N = 0 Resonanz; û j → ∞
4. Zj = 0, N = 0 Scheinresonanz; Amplituden beschränkt
Ist N = 0 (Koeffizientenmatrix H singulär), dann entspricht N der charakteristischen Gleichung
des jeweils zugehörigen Eigenwertproblems gebildet mit eλt , wenn λ j = iΩ ; d. h. Eigenkreis-
frequenz ω j und Erregerkreisfrequenz Ω stimmen überein, es liegt Resonanz vor. Dies kann nur
dann eintreten, wenn mindestens eine ungedämpfte (δ j = 0), also harmonische Eigenschwingung
existiert, was in dämpfungsfreien Systemen, d. h. in MK-, MGK-Systemen, für alle Eigenschwin-
gungen gilt.
Im Allgemeinen spricht man aber auch dann von Resonanz – besser von Resonanzerscheinung
–, wenn N(Ω ) gegen ein relatives Minimum strebt und Z j
= 0 ist. Dies ist der Fall, wenn in
schwach gedämpften Systemen Ω ≈ ω j mit δ j
= 0 (klein) ist.
3.3.2.5 Beschreibung in der Zustandsform

Für allgemeinere Systeme liegt die Zustandsgleichung (3.8) mit harmonischer Störfunktion ent-
sprechend (3.73)

ẋx = Ax + b 0 + b̂b eiΩt + b̂b e−iΩt (3.87)
zugrunde. Der Lösungsanteil infolge der konstanten Störung ergibt sich unmittelbar zu
x ∞ = −A
A−1b 0 . (3.88)
Für die harmonischen Terme betrachten wir, wie in Abschn. 3.3.2.2, die verkürzte Anregung
żz = Az + b̂b eiΩt , x = z + i z (3.89)
mit der komplexen Lösungsamplitude
ẑz = F (iΩ ) b̂b, E − A )−1 kompl. Frequenzgangmatrix.

F (iΩ ) = (iΩE (3.90)
Die reelle Partikularlösung lautet somit
A−1 b 0 + 2 Re(ẑz) cos Ωt + (−2 Im(ẑz)) sin Ωt

x p (t) = −A
(3.91)
= x ∞ + x̂xc cos Ωt + x̂xs sin Ωt.
Die auftretenden Lösungstypen sind die aus Abschn. 3.3.2.4. Angewendet wird die Vorgehens-
weise in Abschn. 8.2.
Formulierung mit MATLAB Functions: Die komplexe Bewegungsgleichung (3.82) lässt sich
am einfachsten aufbereiten, um mit der Function
bode oder freqresp
aus der Control System Toolbox die Frequenz- und Phasengänge zu berechnen. Darauf wollen
wir kurz eingehen. Der Berechnung zu diesen Functions liegt die Zustandsraumdarstellung
żz = Az +B
B eiΩt
(3.92)
y = Cz +D
D eiΩt
zugrunde, mit der in der Regelungstechnik üblichen Matrizenschreibweise. Der Ansatz
z = ẑz eiΩt und damit y = ŷy eiΩt

liefert
(iΩE E −A
A)ẑz = B −→ ẑz = (iΩE A)−1B
E −A
ŷy = Cẑz +D
D
und damit für die komplexe Ausgangsgrößenamplitude
ŷy = C (iΩE A)−1B +D

E −A D. (3.93)
Ausgehend von (3.82) in Zustandsform des zu bearbeitenden Problems

c s

T T
ż = Az + b̂b − i b̂b eiΩt , z = ζ T , ζ̇ζ (3.94)
mit
s
s
T c
c
T
b̂b = 0 Tf ,1 , (ĥh )T ; b̂b = 0 Tf ,1 , (ĥh )T (3.95)
lassen sich die Matrizen in (3.93) ableiten. A entspricht (3.9), C nc ,2 f hängt von der Anzahl der nc
Ausgängen ab. Bei der Eingangsmatrix B ist eine komplexe und eine reelle Formulierung
c s
c s

b = b̂b − i b̂b oder B = b̂b , −b̂b (3.96)
denkbar. Dementsprechend enthält ŷync ,1 und damit Dnc ,1 in (3.93) eine oder aufgrund der zwei
rechten Seiten ŷync ,2 , Dnc ,2 zwei Spalten. Wir arbeiten mit dem komplexen Eingangsvektor b aus
(3.96) weiter. In erzw.m, [52] sind beide Formulierungen programmiert. Die Lösung zur kom-
plexen Eingangsmatrix lautet
y = ŷy ei Ωt , ŷy = ŷyRe + i ŷyIm (3.97)
bzw. mit der Schwingungsamplitude |ŷy|, dem Voreilwinkel Φ sowie der Punktoperation .∗
y = |ŷy|. ∗ ei Φ ei Ωt . (3.98)
Die Function bode gibt |ŷy| und die Phase Φ , die Function freqresp die komplexe Amplitude ŷy
aus. Die Phase berechnet sich anschließend zu
Φ = arctan (ŷyIm ./ ŷyRe ) . (3.99)
Jedem Ergebnis |ŷy|, Φ , ŷy ist in Abhängigkeit von Ω = (Ω1 , Ω2 , . . . , ΩL ) ein dreidimensiona-
les Array zugeordnet. Dabei wird von zwei möglichen Eingängen bzw. rechten Seiten in (3.92)
ausgegangen. Jedem Eingang wird eine Spalte pro Seite zugeordnet. Liegt, wie hier, nur ein ein-
dimensionaler Ausgang zu Ωk vor, dann enthält die zweite Spalte die Dimension 1 (Singleton
dimension index) und damit keine Information. Mit
y_d(:,:) = y_d(:,1,:); bzw. y_d = squeeze(y_d);
kann diese Spalte unterdrückt werden.
Zur Auswertung mit den beiden Functions werden unten die wesentlichen Programmschrit-
te aus erzw.m in [52] angegeben. Weitere Aufrufvarianten sind der Online-Hilfe (z. B. help
bode) zu entnehmen. In jedem Fall sind die Systemmatrizen aus (3.92) in dem State-Space-
Model (unten; sys) für zeitkontinuierliche Systeme zusammenzufassen, womit dann weiter ge-
arbeitet wird.
MATLAB-Formulierung des Zustands-Modells (State-Space-Model), Control System Toolbox
% sys = State-Space Modell; zeitkontinuierlich (ss)
M_1=inv(M); % Inverse von M
A=[zeros(f) eye(f); % Zustandsmatrix
-M_1*[Q P]];
B=[zeros(f,nu); % Eingangsmatrix B, nu Eing.
-M_1*[h_s h_c]];
C=[eye(f) zeros(f)]; % Messmatr., f Ausgänge
Dm=zeros(f,nu); % Durchgangsmatrix, Nullmatr.
sys=ss(A,B,C,Dm); % State-Space Modell
%..................... ...........................
MATLAB-Formulierung mit der Function freqresp

y_d=freqresp(sys,Om); % FREQRESP-Aufr., Om gegeben
% Ausgang: Komplexe Amplitude 3D-Array
y_d=squeeze(y_d); % kompl. Amplitude (3.97)
yd_abs=abs(y_d); % Betrag der Schwingungsampl.
Phi=angle(y_d); % Phase nach (3.99)
yt=real(y_d(:,JJ)*exp(i*Omt*t)); % Zeitv., eine Periode (3.97)
MATLAB-Formulierung mit der Function bode

[yd_abs,Phi]=bode(sys,Om); % BODE-Aufruf
% Ausgang: Reelle Ampl., Phase in Grad
Phi=squeeze(Phi)pi/180.; % Phase in Radian
yd_abs=squeeze(yd_abs); % Betrag der Amplitude
yt=real(yd_abs(:,JJ).* ...
exp(i*Phi(:,JJ))*exp(i*Omt*t)); % Zeitv., eine Periode (3.98)
In Bild 3.7 ist in einer Function-Ausgabe Amplituden- und Frequenzgang mit doppeltloga-
rithmischer Achsteilung: 20 log10 |ζ̂ j (log10 (Ω ))| [dB] dargestellt. Die Grafen stimmen mit denen
aus vorangegangenen Methoden überein. Diese Grafik wird nur erstellt, wenn keine Ausgabeva-
riablen übergeben werden: bode(sys,Om).
Formulierung mit der Fundamentalmatrix: Insbesondere für harmonische und periodische

Anregungen – sind durch F OURIER-Polynome approximierbar – sind die vorangegangenen Be-
trachtungen sehr geeignet. Erfolgt die Erregung u. a. durch Impuls- aber auch durch Sprungfunk-
tionen, die gerne als Testfunktionen zur Schwingungsbeurteilung herangezogen werden, dann ist
die Berechnung der allgemeinen Lösung mit Hilfe der Fundamentalmatrix (3.51) geeigneter. Die
allgemeine Lösungsstruktur für (3.56) können wir u. a. nach [9], [56] damit angeben:
$t
x (t) = Φ (t) x (t0 ) + Φ (t − τ) b (τ) dτ, Φ (t) = eAt . (3.100)
t0
Bild 3.7: Erzwungene Schwingungen mit Function Bode.m; Function-Grafik-Ausgabe
Bild 3.8: Impuls- und Sprungfunktion
Die Antwort (3.100) stellt im Gegensatz zur bisherigen Betrachtung bereits die Überlagerung
einer freien x h = Φ (t) x 0 , die den Einschwingvorgang wie in (3.50) beschreibt, und einer er-
zwungenen Schwingung (partikulären Lösung) dar.
Für die Impuls- bzw. Delta- und der Sprungfunktion kann das Integral auf der rechten Seite
von (3.100) angegeben werden. Dies soll stichwortartig erfolgen.
• Impulsfunktion: b (t) = b I δ (t − tI ), δ (t − tI ) Dirac-, Delta-Funktion (3.101)
Impulsantwort:
$t
x I (t) = Φ (t) x 0 + Φ (t − τ) b I δ (τ − tI ) dτ; Φ (t) = eAt

0 (3.102)
Φ (t) x0 0 ≤ t < tI , vgl. (3.50)
=
Φ (t) (xx0 + Φ (−tI ) bI ) t > tI
• Sprungfunktion b (t) = b s s(t − ts ) (3.103)

Sprungantwort:
$t
xs (t) = Φ (t) x0 + Φ (t − τ) bs s(τ − ts ) dτ

0 (3.104)
Φ (t) x 0 0 ≤ t < ts
=
E − Φ (t − ts )) A −1b s
Φ (t)xx0 − (E t > ts
Die Stabilität wird wiederum von x h = Φ (t) x 0 bestimmt.

MATLAB Code für eine Impulsantwort bei gegebenem Eingang bI sowie vorgegebenem
Anfangswert x0:
t = linspace(0,6,400); % diskrete Zeitwerte
for ii = 1:length(t) % Lösung für t(ii) (3.102)
if t(ii) - tI <= 0
x(:,ii) = expm(A*t(ii))*x0; % Lösung vor Impuls, homog. Dgl.
else
x(:,ii) = expm(A*t(ii))*...
(x0+expm(-A*tI)*bI); % Lösung nach Impuls
end
end
Ein Ergebnis zur Impulsantwort mit b I = [ 0, 0, 0.4, −0.2 ] und tI = 2 s sowie zur Sprungantwort
mit bs = [ 0.4, −1, 0, 0 ] und ts = 2 s zeigt Bild 3.9, wobei x (0) nicht die Gleichgewichtslage zum
Zeitpunkt t = 0 erfüllt, woraus der Einschwingvorgang in 0 ≤ t < 2 s folgt.
Zum Zwei-Massen-Schwinger nach Bild 3.4 ist der vollständige Programm-Code bei Impuls-
oder Sprunganregung IM_SP.m in [52] zu finden. Darüber hinaus stehen mit der Control System
Toolbox die beiden MATLAB Function impulse und step zur Verfügung, siehe diesbezüglichen
Hinweis auf S. 231.
Bild 3.9: Impuls- und Sprungantwort für das Begleitbeispiel, x (0) = [0.0005; 0; 0; 0]T

4 Simulation unter Simulink
Simulink ist eine interaktive grafische Entwicklungsumgebung zur Modellierung und Simulati-
on linearer und nichtlinearer dynamischer Systeme mittels Signalflussgrafen, wobei u. a. nichtli-
neare Zusammenhänge und viele Signalerzeugungen blockorientiert gewonnen werden. Das zu
simulierende mathematische Modell eines dynamischen Systems wird dazu grafisch mit Funkti-
onsblöcken in dem Modell-Fenster nachgebildet und als MDL-File abgespeichert. Das Simulink-
Tool arbeitet somit gleichungsorientiert im Gegensatz zu den Tools: SimScape, SimMechanics,
SimDriveline, SimPowerSystems und SimHydraulics, welche auf einer physikalischen Modellie-
rung mechanischer, elektrischer und hydraulischer Systeme in der Simulink-Umgebung basieren.
Die System-Parameter/Anfangswerte lassen sich direkt in den Funktionsblöcken oder indirekt
mittels Workspace, also durch Tastatureingabe und/oder über ein M-File unter MATLAB, einstel-
len. Die Ergebnisse sind wiederum in Simulink und/oder MATLAB darstellbar. Eine Weiterverar-
beitung der Daten in der MATLAB-Umgebung ist somit möglich.
Bezüglich der Ausführung beziehen wir uns auf MATLAB R2011a und Simulink 7.7 unter Win-
dows 7. Die Programme der Begleitbeispiele sowie die von Ergänzungen sind in [52] abgelegt.
Die für einen Einstieg in Simulink notwendigen Kenntnisse sollen kurz zusammengefasst und
später beispielorientiert ergänzt werden. Zur Vertiefung enthält u. a. Kapitel 8 mehrere Simulink-
Projekte unterschiedlicher Schwerpunkte. In Kapitel 6 werden mit der Stateflow Toolbox sowie
in Kapitel 7 mit der SimMechanics Toolbox weitere Blockelemente für die Simulink-Umgebung
eingeführt.
Ergänzende Erläuterungen zur Handhabung und Syntax sind [1] ,[2], [8], [31] zu entnehmen.
Z. B. sind in [2] Grundlagen mit Beispielen sehr detailliert und übersichtlich zusammengefasst.
Zum wesentlichen Hilfsmittel sollte aber auch hier die Online-Hilfe, die von Beginn an gezielt
einzusetzen ist, werden.
4.1 Zur Funktionsweise

4.1.1 Block-Struktur
Basis eines Simulink-Modells sind Funktionsblöcke mit vektoriellem Eingang u , dem Ausgangs-
vektor y , dem Vektor der Zustände x sowie den Parametern p, wie in Bild 4.1 für eine übergeord-
nete Struktur dargestellt. Der Zustandsvektor
u y
Zustände x
Parameter p
Eingang Ausgang
Block−Name
Bild 4.1: Simulink Funktionsblock, allgemein

DOI 10.1007/978-3-8348-8630-9_4,
162 4 Simulation unter Simulink
T
x = xTc , xTdk (4.1)
kann zeitkontinuierliche (xxc ) oder/und zeitdiskrete (xxdk ) Zustände enthalten. Es gelten die mathe-
matischen Beziehungen
y= fo (t, x , u , p) Ausgang (output), mit x = x c +xxd

ẋxc = fd (t, x , u , p) Ableitungsfunktion (derivative)
xdk+1 = fu (t, x, u, p) Zeitschritt (update).
Derartige Bausteine beschreiben also das Ein-/Ausgangsverhalten mit der eindeutigen Signal-
fluss-Richtung u → y .
Darüber hinaus existieren Blöcke ohne Eingang (Quellen, Sources), z. B. Constant Blöcke,
Funktionsgeneratoren und solche ohne Ausgang, z. B. To Workspace Block (Senke, Sinks).
Alle Blöcke sind in der Block-Library und in Blocksets zusammengefasst, vgl. Abschn. 4.3.1.
Sie sind gekennzeichnet durch den Block-Namen und das Block-Icon. Bei Links-Doppelmaus-
klick auf den Block öffnet sich die Block Parameters Dialogbox, in der – neben einer kurzen
Erklärung – spezifische Parameter des Blocks eingestellt werden können (Standard- (Default-)
Werte sind vorgegeben). Darüber hinaus existiert ein Help-Button, über den gezielt die zugehö-
rige Online-Hilfe geöffnet werden kann. Bei Rechts-Mausklick auf den Block öffnet sich ein
Kontextmenü, in dem u. a. Befehle zum Editieren von Blockeigenschaften und Formatieren des
Blocks ausgewählt werden können.
4.1.2 Simulationsablauf
Entsprechend der mathematischen Formulierung des Problems wird das Simulationsmodell
durch Verbinden geeigneter Funktionsblöcke und deren zugehörigen Parametern aufgebaut. Die
Simulation des Modells setzt sich dann aus den beiden Phasen Initialisierung und Ausführung
bezüglich der Zeit, meist numerische Integration, zusammen.
• Initialisierungsphase:
1. Die Blockparameter werden an MATLAB zur Auswertung übergeben und die sich er-
gebenden numerischen Werte werden den Blöcken zugeordnet.
2. Die Modell-Hierarchie wird weitgehend aufgehoben, d. h. die Blöcke jedes Subsys-
tems, dessen Ausführung nicht an Bedingungen geknüpft ist, werden in das Gesamt-
Modell einbezogen, so dass ein einziges Block-Modell entsteht.
3. Blöcke werden entsprechend dem Ablauf der Berechnung (serielle Arbeitsweise des
Digitalrechners) mittels Sortier-Algorithmus in eine abarbeitbare Reihenfolge
gebracht. Dabei ist zu beachten, dass für jeden Block bei der Berechnung des Aus-
gangs der dazu benötigte Eingang bekannt ist. D. h. es muss beim Start der Simulation
von Blöcken, die einen vorgegebenen Ausgang besitzen, z. B. die Anfangswerte der
Integrierer, ausgegangen werden. Solche Blöcke werden History-Blöcke genannt. Blö-
cke, die in Rückführungsschleifen, z. B. ohne zwischengeschaltetem Integrierer oder
Totzeitglied, liegen, bei denen der Ausgang direkt auf den Eingang wirkt, werden
erkannt. Dies sind so genannte algebraische Schleifen, bei denen fo (xx) selbst vom
Ausgang abhängt. In Bild 4.2 ist ein derartiges Beispiel angegeben. Innerhalb dieser
4.2 Die Integrationsverfahren 163
Schleifen sind keine seriellen Rechenschritte mehr vorgebbar. Es führt nur eine kon-
vergierende iterative Berechnung des Ausgangs zum Ziel, siehe auch Abschn. 4.5.
y1=u2
u1 sqrt(2)*u(1)+4 sin y2
Fcn Trigonometric
Gain
Function
1.2
√
y1 = 2 u1 + 4, u1 = 1,2 y2
√
y2 = sin u2 = sin (1,2 2 y2 + 4), beide Seiten hängen von y2 ab
Bild 4.2: Beispiel für eine algebraische Schleife
Beispiele in [52]: alg_loop1.mdl, alg_loop_2.mdl mit Angaben zum Simu-

link-Debugger unter: File/Model Properties/Description.
4. Die Verbindungen zwischen den Blöcken werden auf Verträglichkeit der Vektordimen-
sionen des treibenden (Ausgang) und getriebenen (Eingang) Blocks überprüft.
• Ausführungsphase:
Danach kann die Ausführung, in der Regel die numerische Integration, mit dem ausge-
wählten Löser odexx durchgeführt werden. Hierzu müssen die Ableitungsfunktionen – z. B.
entsprechend ẋk = fk (tn , x ) – gebildet werden, vgl. Kapitel 5. Dies erfolgt in zwei Schritten:
1. In der festgelegten Reihenfolge wird der Ausgabewert jeden Blocks bestimmt.
2. Es können jetzt für jeden Block die Ableitungen (z. B. ẋk = fk (tn , x )) in Abhängig-
keit von der aktuellen Zeit tn , seiner Eingangswerte und seines Zustandes berechnet
werden. Der so ermittelte Ableitungsvektor wird an den Integrator odexx zurückgege-
ben. Dieser ermittelt damit den neuen Zustandsvektor zum Zeitpunkt tn+1 , vgl. auch
Bild 5.8. Abschließend werden die Ausgaben, u. a. der Scopes, aktualisiert.
Die Ausführungsreihenfolge der Blöcke lässt sich über den Button Format/Block Dis-
plays/ Sorted Order in der Menüleiste des Modell-Fensters zum Simulink-Modell einblen-
den.
4.2 Die Integrationsverfahren

Für die numerische Bearbeitung der mathematischen Modelle dynamischer Systeme spielen die
Integrationsverfahren (kurz: Integrator, Solver, Löser, Code, . . .) die zentrale Rolle. Sie lösen
Anfangswertprobleme expliziter und impliziter Differenzialgleichungen u. a für:
ẋx = f (t, x (t)); x (t0 ) = x 0

(4.2)
0 = ẋx − f (t, x (t)); x (t0 ) = x 0 .
Die Tabellen 4.1 und 5.1 Seite 238 geben eine Kurzbeschreibung der verfügbaren Verfahren
wieder. Ausführliche Beschreibungen enthält die Online Hilfe u. a. unter: Choosing a Solver.
Tabelle 4.1: Integratoren mit fester Schrittweite
ode8 Runge-Kutta-Formel, Dormand-Prince, 8. Ordnung

ode5 Runge-Kutta-Formel aus ode45, Dormand-Prince-Formel, 5. Ordnung
ode4 Runga-Kutta-Formel aus ode45, Dormand-Prince-Formel, 4. Ordnung
ode3 Runge-Kutta-Formel aus ode23, Bogacki-Shampine-Formel 3. Ordnung
ode2 Verfahren nach Heun, 2. Ordnung
ode1 Explizites Euler-Verfahren, 1. Ordnung
ode14x Impliziter Löser, Extrapolationsordnung 1, 2, 3, 4Standard ,
Newtonschritte 1Standard ,... einstellbar
diskret keine Integration, Modell ohne zeitkontinuierliche Zustände
Grundlagen der mathematischen Methoden sind [59], [61], [65] zu entnehmen. Hier geben
wir, in Bezug auf die Integrator-Wahl, einen kurzen Überblick.
Grundsätzlich sind Verfahren mit fester –Tabelle 4.1– und variabler –Tabelle 5.1– Schritt-
weite h zu unterscheiden. Dabei kann die Integrationsmethode ein Einschritt- oder Mehrschritt-
verfahren sein, vgl. Bild 4.3, S. 165. Wie die Namen zum Ausdruck bringen, benutzen diese
Verfahren Information aus einem [tn , tn+1 ] oder mehreren [tn−k , . . . , tn , tn+1 ] Integrationsinter-
vallen. Dies kann wiederum auf eine explizite oder implizite Formulierung der Integrationsme-
thode, siehe Bild 4.3, S. 165, führen. Kombinationen beider Typen sind im Einsatz. Dabei werden
die Formeln auf bestimmte Eigenschaften, z. B. hohe Genauigkeit, gute Stabilität, getrimmt. Zu
den modernen Verfahren für steife Differenzialgleichungen zählen die Mehrschrittverfahren nach
den BDF-Methoden (Backward Differentiation Formula); vgl. Bild 4.3, S. 165. Unter MATLAB
gibt es eine modifizierte Methode, das NDF-Verfahren (Numerical Differentiation Formula); das
BDF-Verfahren ist optional aufrufbar.
4.2.1 Methoden und Bezeichnungen
Einschrittverfahren
Um einen kleinen Einblick in die Methoden mit den MATLAB-Bezeichnungen der Integrations-
verfahren zu erhalten, sollen zunächst die Verfahren ode4, ode5 und ode451 kurz skizziert werden.
Sie sind Vertreter der Einschrittverfahren auf der Basis der RUNGE -K UTTA-Methode. Allgemein
lassen sich, ausgehend von der skalaren Differenzialgleichung ẋ = f (t, x), die expliziten RUNGE -
K UTTA-Methoden – vgl. Bild 4.4 – wie folgt beschreiben:
Steigungswert in tn k1 = f (tn , xn ); xn := x(tn )
Steigungswerte in tn + ci h ki = f (tn + ci h, xn + h ∑i−1

j=1 ai, j k j ), i = 2, . . . , s
Ergebnis xn+1 = xn + h ∑si=1 bi ki .
1 ODE: Ordinaray Differential Equation

Darstellung und Methoden für die skalare Differenzialgleichung: ẋ = f (t, x)
Es sollen die Begriffe explizite und implizite Einschritt- und Mehrschrittverfahren am Beispiel erläutert
werden.
Einschrittverfahren: Information aus [tn , tn+1 ]
E ULER vorwärts xn+1 = xn + h f (tn , xn )
- explizites Verfahren 1. Ordnung (Fehler 1. Ordnung)
E ULER rückwärts xn+1 = xn + h f (tn+1 , xn+1 )

- implizites Verfahren 1. Ordnung (Fehler 2. Ordnung)
Mehrschrittverfahren: Information aus [tn−k , tn+1 ], k > 1

A DAMS -BASHFORTH-Verfahren
h
xn+1 = xn + (55 fn − 59 fn−1 + 37 fn−2 − 9 fn−3 ) , fn := f (tn , xn )
24
- explizites 4-Schrittverfahren 4. Ordnung
A DAMS -M OULTON-Verfahren
h
xn+1 = xn + (251 fn+1 + 646 fn − 264 fn−1 − 106 fn−2 − 19 fn−3 )
720
- implizites 4-Schrittverfahren 5. Ordnung
Kombination aus explizitem und implizitem Verfahren ist ein Prädiktor-Korrektor-Verfahren.
BDF-Verfahren (Backward Differenziation Formulas)
25xn+1 − 48xn + 36xn−1 − 16xn−2 + 3xn−3 = 12h fn+1
- implizites 4-Schrittverfahren
Bild 4.3: Bezeichnung der Funktionswerte und Formeln einiger Integrationsverfahren

Die Koeffizienten ai, j , bi , ci charakterisieren die s-Schrittmethode, sie werden in der so genann-
ten B UTCHER-Tabelle
c1
c2 a2,1
c3 a3,1 a3,2
..
. ... ... ...
cs as,1 as,2 . . . as,s−1
b1 b2 . . . bs−1 bs
angegeben. Damit ist das klassische RUNGE -K UTTA2 -Verfahren in der Form
0
1 1
2 2
1 1
2 0 2
1 0 0 1
1 2 2 1
6 6 6 6
formulierbar. Es ist ein 4-Schrittverfahren der Ordnung 4 mit dem algorithmischen Aufbau
k1 = f (tn , xn ) Steigungswerte ki
h h
k2 = f (tn+ 1 , xn + k1 ), zur Schreibweise: tn + → tn+ 1 usw.
2 2 2 2
h
k3 = f (tn+ 1 , xn + k2 )
2 2
k4 = f (tn+1 , xn + hk3 )
h
xn+1 = xn + (k1 + 2k2 + 2k3 + k4 ) Ergebnis, explizite Formel
6
sowie der geometrischen Interpretation nach Bild 4.4. Man beachte, dass jede Stufe eines RUN -
Bild 4.4: Geometrische Interpretation zum RUNGE -K UTTA-Verfahren 4. Ordnung
GE -K UTTA -Verfahrens eine Funktionsauswertung f (·) benötigt. Ein Integrationsschritt ist daher
i. a. etwa viermal so teuer wie der entsprechende E ULER-Schritt, vgl. Bild 4.3, S. 165. Dennoch
2 genauer: das Verfahren von K UTTA
ist aufgrund der hohen Ordnung das Verfahren von RUNGE -K UTTA viel effizienter, da u. a. mit
größerer Schrittweite gearbeitet werden kann. Dies setzt sich fort, denn die D ORMAND -P RINCE-
Methode [14] mit den Koeffizienten nach Tabelle 4.2 ist eine der effektivsten expliziten RUNGE -
K UTTA-Formeln, obwohl sich der Rechenaufwand noch einmal erhöht. Tabelle 4.2 enthält auch
Tabelle 4.2: Koeffizienten der D ORMAND -P RINCE-Methode
0
1 1
5 5
3 3 9
10 40 40
4
5
44
45 − 56
15
32
9
8
9
19372
6561 − 25360
2187
64448
6561 − 212
729
1 9017
3168 − 355
33
46732
5247
49
176 − 18656
5103
1 35
384 0 500
1113
125
192 − 2187
6784
11
84
(5)
xn 35
384 0 500
1113
125
192 − 2187
6784
11
84 0
(4)
xn 5179
57600 0 7571
16695
393
640 − 339200
92097 187
2100
1
40
die beiden MATLAB-Verfahren ode5 und ode4. Die 7-Schrittmethode (s=7) basiert auf den beiden
(5) (4)
Ergebnissen xn und xn , die mit den gleichen Steigungswerten ki aber unterschiedlichen Ge-
(5)
wichtungen b j ermittelt werden. Greift man auf das Ergebnis xn zurück, dann handelt es sich
um das des ode5 Verfahrens mit fester Schrittweite h; Verfahren 5. Ordnung. Im anderen Fall er-
gibt sich das Ergebnis des Verfahrens ode4 der Ordnung 4. Verwendet man beide Ergebnisse, so
(5) (4)
wird – z. B. aufgrund der Abweichung |xn − xn | – ein Maß zur Ermittlung der Schrittweite h,
im Zusammenhang mit einem vorgegebenen Fehler ε, bestimmbar. Wir erhalten Methoden mit
(4) (5)
variabler Schrittweite. Dabei kann xn (ode54) oder xn (ode45) als Ergebnis akzeptiert werden.
In gleicher Weise sind die anderen Einschrittverfahren in Tabelle 5.1, S. 238 zu interpretieren.
Wie die bisher betrachteten expliziten Einschritt- (RUNGE -K UTTA-) Verfahren stellt man
auch die impliziten Verfahren (z. B. das E ULER-Rückwärts-Verfahren aus Bild 4.3, S. 165) über-
sichtlich in einem Tableau der Struktur
c1 a11 a12 ... a1,s−1 a1,s

c2 a2,1 a2,2 ... a2,s−1 a2,s
c3 a3,1 a3,2 ... a3,s−1 a3,s
.. .. .. .. .. ..
. . . . . .
cs as,1 as,2 ... as−1,s−1 as,s
b1 b2 ... bs−1 bs
dar. Beispiel: Die Trapez-Regel

1
xn+1 = xn + h ( f (tn , xn ) + f (tn+1 , xn+1 ))
2
kann als zweistufiges implizites RUNGE -K UTTA-Verfahren aufgefasst werden:

zugehörige Tableau
k1 = f (tn , xn )
1 1 0 1 0
k2 = f (tn + h, xn + h( k1 + k2 )) 1 1 1
2 2 2 2
h 1 1
xn+1 = xn + (k1 + k2 ). 2 2
2
Nachteil der impliziten RUNGE -K UTTA-Verfahren ist, dass die ki nicht nacheinander berechnet
werden können, sondern dass in jedem Schritt ein i. a. nichtlineares Gleichungssystem von s · N
Gleichungen in den k 1 , . . . , k s gelöst werden muss, wobei N die Dimension des Differenzialglei-
chungssystems bezeichnet.
Bei weniger steifen Differenzialgleichungen folgt aus dem Fixpunktsatz für kontrahierende
Abbildungen, dass die Fixpunktiteration gegen die Lösung (ki )i=1,...,s konvergiert, wenn die
Schrittweite die L IPSCHITZ-Bedingung, vgl. [65], erfüllt; z. B. für k2 aus der obigen impliziten
RUNGE -K UTTA-Formel im -ten Iterationsschritt

1 1
k2+1 = f tn + h, xn + h k1 + k2 , = 1, 2, . . . , k21 Startwert.
2 2
Bei steifen Systemen muss das nichtlineare Gleichungssystem für die ki immer mit dem N EW -
TON -Verfahren oder einer verwandten Methode gelöst werden. Hierfür benötigt man die JACOBI -
Matrix.
Eine dritte Möglichkeit ist die Kombination eines expliziten (Prädiktorschritt (P)) und eines
impliziten (Korrektorschritt (K)) Verfahrens, die so genannte Prädiktor-Korrektor-Methode. Für
die E ULER-Verfahren nach Bild 4.3, S. 165 bedeutet dies:
P
xn+1 = xn + h f (tn , xn ) Prädiktorschritt P , E ULER-Vorwärts-Schritt
K
xn+1 = xn + h f (tn+1 , xn+1
P
) Korrektorschritt K (+ z. B. Fixpunkt-Iteration)
Mehrschrittverfahren
In ähnlicher Weise wie die oben angesprochenen Einschrittverfahren sind auch die Mehrschritt-
verfahren gekennzeichnet, wobei zusätzlich die Ordnung des Verfahrens anpassbar bzw. einstell-
bar ist, z. B. ode113, ode15s aus Tabelle 5.1, S. 238.
Bei den linearen Mehrschrittverfahren benutzt man zur Berechnung der Näherung xn+s die be-
reits ermittelten – zeitlich zurückliegenden Werte – Näherungen xn+s−1 , xn+s−2 , . . . , xn . Mehr-
schrittverfahren sind somit nicht selbststartend und arbeiten deshalb zu Integrationsbeginn u. a.
mit Einschrittverfahren zusammen. Es werden explizite und implizite s-Schritt-Verfahren un-
terschieden, vgl. Bild 4.3, S. 165. Die Mehrschrittverfahren A DAMS -BASHFORTH , A DAMS -
M OULTON usw. basieren auf der numerischen Lösung einer Integralgleichung [65], die BDF-Me-
thoden werden dagegen mit Hilfe der numerischen Differenziation konstruiert. Beispiele implizi-
ter Formeln sind u. a. nach [65]

s = 1 : xn+1 − xn = h fn+1 , fn+1 := f (tn+1 , xn+1 ), E ULER-Methode; vgl. Bild 4.3
s = 2 : 3xn+1 − 4xn + xn−1 = 2h fn+1
s = 6 : 147xn+1 − 360xn + 450xn−1 − 400xn−2 + 225xn−3 − 72xn−4 + 10xn−5 = 60h fn+1 .
Für s ≤ 6 sind die Formeln stabil, für s ≥ 7 instabil. Die Verfahren s ≤ 6 zeichnen sich durch ein
verbessertes Stabilitätsverhalten gegenüber expliziten Verfahren, insbesondere steifer Systeme,
aus. Bei impliziten Verfahren muss in jedem Schritt wieder ein nichtlineares Gleichungssystem,
z. B. für die implizite E ULER-Formel
F(xn+1 ) = xn+1 − xn − h f (tn+1 , xn+1 )
gelöst werden. Dies kann z. B. mit dem N EWTON-Verfahren mit dem Startwert xn erfolgen; hier-
zu muss die JACOBI-Matrix (∂ F/∂ x|xn+1 ), analytisch oder näherungsweise numerisch, berechnet
werden, vgl. Optionen zum Aufruf der Integrationsverfahren unter MATLAB in Kapitel 5.
4.2.2 Steifigkeit der Differenzialgleichung
Wesentlich für die Verfahrensauswahl ist die Kenntnis der Steifigkeit der Differenzialgleichung.
Wir geben eine Definition stichwortartig an: Ein Differenzialgleichungssystem heißt steif, wenn
die Eigenwerte des Systems sehr unterschiedliche (negative) Realteile aufweisen. Als Maß der
Steifigkeit gilt u. a. der Quotient der Beträge der absolut größten und kleinsten (negativen) Real-
teile der Eigenwerte
max j |ℜ(λ j )|
S := .
min j |ℜ(λ j )|
Bei steifen Differenzialgleichungen erreicht S Werte von 106 und höher. Das Problem der Stei-
figkeit existiert ausgeprägt bei nichtlinearen Differenzialgleichungen
ẋx(t) = f (t, x (t)) x (t) ∈ Rn . (4.3)
Die Steifigkeit wird für das linearisierte System definiert, indem das lokale Verhalten der exak-
ten Lösung x (t) in der Umgebung von tn betrachtet wird. Hierbei liegt die Anfangsbedingung
x (tn ) = x n , wo x n die berechnete Näherungslösung an der Stelle tn bedeutet, zugrunde. Unter der
Voraussetzung der gestörte Lösung
x (t) = x n +zz(t) für tn ≤ t ≤ tn + h; Norm von z und h klein
entwickeln wir (4.3) in eine TAYLOR-Reihe und brechen nach dem ersten Glied ab

∂ f
ẋxn + żz(t) = f (tn , x n ) + z (t) + O(zz2 ),
∂xx n
woraus schließlich mit (4.3) die erste Näherung

∂ f
żz(t) = z (t) = J (tn , xn ) z (t)
∂xx n
folgt. Dies ist eine lineare Differenzialgleichung mit konstanter Koeffizientenmatrix J (tn , xn ),
mit deren Eigenwerte sich S ermitteln lässt. Somit wird das qualitative Verhalten von x (t) in
der Umgebung von tn durch z (t) beschrieben. Das nichtlineare Differenzialgleichungssystem
wird als steif bezeichnet, falls die Eigenwerte der JACOBI-Matrix J (tn , xn ) sehr unterschiedliche
negative Realteile haben und S groß ist. Das Maß der Steifigkeit von (4.3) ist bei nichtlinearen
im Gegensatz zu linearen Systemen abhängig vom Zeitpunkt tn und der momentanen Näherungs-
Lösung x n , so dass sich S im Verlauf der Integration sehr stark ändern kann. Moderne Verfahren
nutzen dies zur Anpassung an den Integrationsablauf und stellen damit die Schrittweite sowie
die Ordnung des Integrationsverfahrens ein.
Eine sinnvolle Erweiterung der Definition für steife Systeme ist:
max j |λ j |
S := , Anhaltswert: S > 104 , . . . , 106 ,
min j |λ j |
wobei durch die Eigenwerte λ j auch schwach gedämpfte, hochfrequente Lösungsanteile erfasst
werden.
In MATLAB sind mehrere Methoden zur Lösung steifer Systeme implementiert, vgl. Tabel-
le 5.1. Die Function ode15s verwendet BDF- oder NDF-Formeln der Ordnung k ∈ {1, 2, 3, 4, 5};
vgl. [59], [65]. NDF-Methoden sind Modifikationen der BDF-Methoden, die ebenfalls A-stabil
(absolut stabil) [59], [65] sind. Sie besitzen eine etwas größere Genauigkeit als die BDF-Me-
thoden. Die Function ode23s verwendet ein ROSENBROCK-Verfahren der Ordnung 3, wobei der
Fehler mit einer Methode der Ordnung 2 geschätzt wird. Es ist geeignet, wenn die Genauigkeits-
ansprüche nicht zu hoch sind.
4.2.3 Bemerkungen zur Wahl der Verfahren

Einer Anfangswertaufgabe sieht man nicht unmittelbar an, ob ihre Lösung steif ist. Es gibt einige
Aufgabenklassen, bei denen man weiß, dass steife Lösungen zu erwarten sind, wie z. B. bei der
VAN - DER -P OL-Gleichung
ẍ − ε ( 1 − x2 ) ẋ + x = 0
mit sehr großen Parametern ε oder mechanischen Systemen mit sehr unterschiedlichen Steifig-
keits- und Dämpfungskonstanten. In diesen Fällen wird man sofort steife Löser verwenden.
Liegen keine guten Gründe dafür vor, dass eine steife Lösung zu erwarten ist, wird man zuerst
versuchen, das gegebene Problem mit einem nicht-steifen Löser zu behandeln, denn explizite
(eingebettete) RUNGE -K UTTA-Verfahren, z. B. ode45, oder Mehrschrittverfahren vom A DAMS-
Typ sind wesentlich billiger als steife Löser. Bei steifen Lösern hat man in jedem Schritt ein
nichtlineares Gleichungssystem zu lösen und hierzu die JACOBI-Matrix der rechten Seite oder
eine Näherung davon aufzustellen.
Praktisch: Beobachtet man, dass der Lösungsprozess nur sehr langsam voranschreitet, wird
man zu einem steifen Löser wechseln.
RUNGE -K UTTA-Verfahren ermöglichen eine einfache Schrittweitensteuerung (Adaptivität),
haben aber den Nachteil gegenüber dem A DAMS-Verfahren, dass in jedem Schritt die rechte Sei-
te von (4.2) an mehreren Stellen ausgewertet werden muss (für das Verfahren von D ORMAND
und P RINCE der Ordnung 5 an 6 Stellen). Beim Prädiktor-Korrektor-Verfahren kann man hohe
4.3 Simulink-Grundlagen 171
Ordnungen mit 2 oder 3 Auswertungen erreichen. Man wird daher ein Mehrschrittverfahren ver-
wenden, wenn die Auswertung der rechten Seite der Differenzialgleichung sehr teuer ist. In der
Regel wird man Verfahren hoher Ordnung nur dann verwenden, wenn die rechte Seite der Dif-
ferenzialgleichung sehr glatt ist. Man verwendet den TAYLORschen Satz, um Methoden hoher
Konsistenzordnung zu entwickeln.
Eine Regel für die Auswahl steifer Löser ist nicht so einfach zu formulieren. Einen Anhalts-
punkt geben die Stabilitätsgebiete der Verfahren, z. B. nach [59], [65]. Wenn man weiß, dass
die Eigenwerte der Linearisierung der rechten Seite in der Nähe der negativen reellen Achse
liegen, so wird man BDF bzw. NDF Formeln wählen. Weiß man, dass Eigenwerte der JACOBI-
Matrix näher an der imaginären Achse als an der negativen reellen Achse liegen, so wird man
ROSENBROCK-Methoden oder Extrapolationsverfahren verwenden.
4.3 Simulink-Grundlagen
Zunächst gehen wir auf Grundlagen zum Umgang mit Simulink ein, um daran anschließend die
Modellierung mit Simulink an einem kleinen Projekt zu vertiefen. Der Zugang zu Simulink er-
folgt mit dem Button in der Menü-Leiste des MATLAB Desktop nach Bild 1.1. Es öffnet sich
der Library Browser mit der Menüleiste File/Edit/View/Help. Insbesondere wird über
File/New/Model oder Ctrl+N ein neues Modell-Fenster mit der Menü-Leiste File/E-
dit/View/Simulation/Format/Tools/Help bereitgestellt. Entsprechend sind gespei-
cherte Simulink-Programme mit der Endung mdl zu öffnen. Für die letzten beiden Vorgänge
existieren die Standard-Button . Des Weiteren werden alle Hauptgruppen der Library ange-
zeigt, auf die wir im Folgenden eingehen werden.
4.3.1 Die Modell-Library

Wesentlich für jedes Simulationsprogramm ist das Modellangebot in der verfügbaren Library. In
Simulink 7.7 ist die Library in die vierzehn Hauptgruppen mit den eingefärbten Symbolen nach
Bild 4.5 unterteilt. Einhergehend mit der ständigen Erweiterung der Libraries der Vorgängerver-
sionen kam es zur Ergänzung und teilweise Umstrukturierung der Gruppen. D. h. Blöcke aus
Vorgängerversionen können anderen Gruppen zugeordnet sein. In Bild 4.5 ist eine Auswahl der
verfügbaren Funktionsblöcke abgebildet. Zu jedem Block gehört ein Parameter-Dialog-Fenster,
welches sich mit einem Doppelklick der linken Maustaste öffnen lässt.
Neben diesen aufgeführten Library-Blöcken existieren ergänzende Blocksets, die einerseits
innerhalb der Library unter Additional Math & Discrete und andererseits unter Simulink extra
sowie in anderen Tools zu finden sind.
Beispiel 4.1: Modellerstellung

Für die Differenzialgleichung
ẋ = −0,5 x + 5
ist das Simulink-Modell zu erstellen. Die Zeit t und x sind mit dem To Workspace Block
und x p = ẋ mit dem Outport Block, siehe Abschn. 4.3.2, in den Workspace zu schrei-
ben. Zur Integration von ẋ wird ein Integrator Block, zur Abbildung der rechten Seite
Bild 4.5: Beispiele für die Zuordnung der Funktionsblöcke der Library unter Simulink 7.7
ein Summierer, d. h. ein Sum Block (ohne Abbildung in Bild 4.5) benötigt. Die Kon-
stante 5 wird mit dem Constant Block und die Verstärkung von 0.5 mit dem Gain Block
realisiert. Nach dem Öffnen des Modell-Fensters (Ctrl+N) sind die ausgewählten
Blöcke der Library mit der linken Maustaste anzuklicken und bei gedrückter Taste ins
Modell-Fenster zu ziehen – click-and-drag mouse operation. Der Signalpfad zwischen
den Blöcken erfolgt, ausgehend vom Ein- oder Ausgang der zu verbindenden Blöcke,
ebenfalls mit gedrückter linker Maustaste. Eine automatische Signalverbindung wird
durch Aktivieren z. B. des Ausgangs-Blocks mit der linken Maustaste und anschließen-
der Aktivierung des Folgeblocks bei gleichzeitig gedrückter Strg- bzw. Ctrl- Taste
Bild 4.6: Beispiel eines einfachen Block-Modells

erreicht. Abschließend sind die Parameter 5, 0.5 sowie der Anfangswert x(0) = 0 des
Integrierers in die jeweilige Dialogbox einzutragen. Der Simulationsstart mit der zuvor
eingegebenen Integrationsdauer erfolgt über den Button Simulation/Start oder
dem Button. Das komplette Modell ist in Bild 4.6 abgebildet. Zum Experimentieren
dient Lib_Beisp.mdl aus [52].
4.3.2 Einstellung des Integrators und des Datentransfers
Bild 4.7: Configuration Parameters Fenster von Solver und Data Import/Export, Simulink 7.7
Die Integratorauswahl erfolgt im Modell-Fenster unter dem Menüpunkt Simulation Opti-

on Configuration Parameters; vgl. Bild 4.7. Hier existieren in Abhängigkeit der vorhan-
denen Toolboxen mehrere anwählbare Dialogseiten: Solver, Data Import/Export, Di-
agnostic usw. Auf der Solver-Seite, Bild 4.7 oben, werden Start- und Stopp-Zeit, das
Integrationsverfahren und Daten zur Schrittweite sowie zur Toleranzvorgabe eingestellt. Unter
Zeros crossing control ist die Nullstellen-Detektion spezieller Blöcke übergeordnet ein-
oder ausschaltbar.
Auf der Seite Data Import/Export nach Bild 4.7 unten wird u. a. der Datentransfer zwi-
schen Simulink und dem Workspace sowie einige Optionen organisiert:
• Load from workspace: Einerseits können unter Input ein Zeit- und Eingangsvektor t , u
und andererseits unter Initial State der Anfangswertvektor xInitial der Zustände an das
Simulink-Modell übergeben werden. Für [t,u] müssen im Modell dafür Inports-Blöcke
aus der Ports & Subsystems-Bibliothek vorhanden sein; siehe FromWorksp.mdl in [52].
• Save to workspace: Datentransfer aus dem Simulink-Modell in den Workspace. Dies bezieht
sich auf den Zeitvektor z. B. tout , auf den Zustandsvektor xout sowie auf die Ausgangsvaria-
blen yout , denen Outports-Blöcke – vgl. Bild 4.6 – aus der Ports & Subsystems-Bibliothek zu-
geordnet sein müssen. Die Reihenfolge der gespeicherten Zustände (Integrator-Ausgänge)
wird von dem Sortier-Algorithmus, wie in Abschn. 4.1.2 beschrieben, festgelegt. Sie kann
mit Format/ Block Displays/Sorted Order ins Modell-Fenster eingeblendet wer-
den. Darüber hinaus können die Zustandswerte (xFinal) zur Stopp-Zeit gespeichert wer-
den; siehe FromWorksp.mdl in [52].
• Save options: Unter Output options/Refine output ist es möglich, mit dem Refine
factor zusätzliche Ausgabewerte mittels Kurvenglättungs-Methoden im Integrationsin-
tervall [tn , tn+1 ] zu erzeugen; d. h. Refine factor = 1 liefert keine, Refine factor =
r liefert r − 1 Zwischenwerte. Der Defaultwert ist 1. Die Zwischenwerte beziehen sich nur
auf die Ausgabe und nicht auf die Darstellungen im Scope oder XY Graph.
Im Diagnostic-Fenster kann u. a. ausgewählt werden, wie bei den aufgelisteten Ereignissen
(z. B. Algebraic loop, Date overflow usw.) während einer Simulation reagiert werden soll; z. B.
mit: Warning, Error (Simulationsabbruch) oder none.
4.3.3 Datentransfer über den Workspace

Die Parameter und/oder Matrixelemente usw. der Funktionsblöcke lassen sich in den zugehö-
rigen Parameter-Dialog-Boxen als numerische oder symbolische Werte eintragen, z. B. gilt für
eine 2 × 2-Matrix:
[0 1; 1 4] oder A.
Ist der symbolische Wert (A) eingetragen, z. B. im State Space Block von Bild 4.8, dann müs-
sen die zugehörigen numerischen Werte vor dem Simulationsstart im Workspace liegen. Dieses
kann u. a. über eine Tastatureingabe oder über ein angestartetes M-File erfolgen, wie in Bild 4.8
verdeutlicht. Der Datentransfer aus dem Simulink-Modell in den Workspace erfolgt u. a. über
den TO Workspace Block in Array- oder Structure-Format, z. B. wie in Bild 4.8 für die Matrix
simout oder den Outport Block wie in Bild 4.6 und Abschn. 4.3.2. Damit können die Daten in
MATLAB u. a. zur grafischen Darstellung weiterverarbeitet werden. Eine weitere Möglichkeit zur
Übergabe der Simulationsdaten in den Workspace kann im Scope-Fenster durch aktivieren der
Array- oder Structure-Übergabe, vgl. Abschn. 4.3.5.6, S. 183, erreicht werden.
4.3.4 Simulationsaufruf aus der MATLAB Umgebung

Die Simulation kann einerseits direkt aus dem Menü-Punkt Simulation/Start oder mit
dem Start-Icon der Menüleiste und andererseits aus der MATLAB-Umgebung, mittels Tas-
Bild 4.8: Datenaustausch am Beispiel des State Space Blocks
tatur oder M-File, erfolgen. Aus der MATLAB-Umgebung wird der Start mit dem Aufruf der
Function sim eingeleitet. Optionen werden mit simset gesetzt und können mit simget aufgelistet
werden, verfolge: help sim usw. Die einstellbaren Optionen umfassen z. B. die der Solver- und
Data Import/Export-Seite, z. B. RelTol, AbsTol, MaxRows, Refine usw. Ausgabe-
Daten werden entsprechend dem Function-Aufruf in eckige Klammern gesetzt, sie beinhalten
die Größen der Data Import/Export Seite unter Save to workspace. Daten des Workspace,
die im Feld Load from workspace aufgeführt sind, stehen im Aufruf hinter den Optionen. Die
Syntax eines Aufrufs lautet:
[tout, xout, yout] = sim(’modell’, timespan, options, tu)
mit – siehe auch FromWorksp.mdl in [52] –
tout Zeitvektor
xout Zustände, spaltenweise
yout Daten der Outports, spaltenweise
’model’ Name der Modelldatei, z. B. ’model’ ohne Endung mdl
timespan Zeitintervall: z. B. te Stoppzeit (bei Startzeit 0) oder
[ta, te] Start und Stoppzeit usw.
option mit simset zu kreierende
optionale Parameter (z. B. Genauigkeit) der Simulation
tu Eingangsvariablen über Inports Blöcke tu = [t, u]
Beispiel: Aufruf für eine Integration im Debugger-Mode nach Abschn. 4.3.5.8, bei der maximal
1000 Zeilenelemente ausgegeben und die Integrationsdaten mit einem zusätzlichen Zwischen-
wert geglättet werden sollen. Die Integrationszeit sei 10 s:
meine_opt= simset(’MaxRows’,1000,’Refine’,2,’debug’,’on’);
[t,x]= sim(’Prog_Name’,10,meine_opt);
4.3.5 Hilfsmittel zur Modellerstellung und Datenauswertung

Zusatzinformationen, Kommentare in Textfeldern und ausführbare Callback Functions (Click
Functions), so genannte Annotations vervollständigen das S IMULINK-Modell.
Zur besseren Übersichtlichkeit und Transparenz werden Modellgruppen, meist von Teilstruk-
turen wie Filter, Regler, Radaufhängung usw., zu Subsystemen zusammengefasst. Dabei ist es
wesentlich, dass die zugehörigen Blöcke bereits optisch Aussage über ihren Inhalt anzeigen. Zur
diesbezüglichen Block-Maskierung geben wir einige Anregungen. Darüber hinaus bieten die Sco-
pe Blöcke Möglichkeiten zur Grafikdarstellung in der MATLAB-Umgebung, so dass Änderungen

und Ergänzungen leicht durchgeführt werden können.
4.3.5.1 Platzieren von Zusatzinformation im Modellfenster, Click Function

Vermerke, Kommentare und ausführbare Anweisungen (Annotations) lassen sich an freien Stel-
len im Block-Diagramm anbringen. Nach einem double-click mit der linken Maustaste erscheint
am ausgewählten Platz ein kleines Rechteck mit dem Cursor. Text kann eingegeben werden, der
Übergang zur neuen Zeile erfolgt mit der Return-Taste. Durch Anfahren des Cursers im Text
mit der Maus bzw. der Richtungstaste (u. a. →) kann der Text, wie üblich, korrigiert und er-
gänzt werden. Das Textfeld ist bei positioniertem Mauszeiger und halten der linken Maustaste
verschiebbar.
Durch Betätigen der rechten Maustaste öffnet sich, wie Bild 4.9 eingeblendet, das Kontextme-
nü 2, u. a. mit Menüpunkten zur Gestaltung des Textes. Nach Auswahl des Punkte Annotation
Properties... erscheint, wie links im Bild 4.9, in 3 der Text in dem oberen Textfeld 3a. Hier
sind Änderungen und Gestaltungen bequem durchzuführen.
Darüber hinaus besteht die Möglichkeit ausführbare Textfelder, z. B. zur Parameterübergabe,
anzulegen. Die Eingaben im oberen Textfeld 3a dienen wie bisher der angezeigten Information,
die des unteren Textfeldes 3b der auszuführenden Anweisungen. Zur Erzeugung der zugehörigen
Callback Funktion (Click-Fnc) ist das Feld: Use display text as click callback zu aktivie-
ren. Enthält das obere Textfeld auch die ausführbaren Anweisungen und ist das untere leer, dann
werden diesen durch die Aktivierung übernommen. Der Apply Button erstellt letztendlich die
Click-Function. Das im Modellfenster angezeigte Textfeld wird durch einen Einfachklick ausge-
führt.
Beispiel: Im Modell eines linearen Einmasseschwingers nach Bild 4.9 sind das Textfeld 1
zum Problem sowie die beiden Click-Functions (clickfnc) 4, 5 integriert. Nach öffnen des Mo-
Bild 4.9: Kommentarfelder und Click Functions am Beispiel eines Einmasseschwingers

dellfensters Schwing_M.mdl sind zunächst die Systemparameter und die Anfangswerte der
Integratoren mit 4 zu setzen. Danach erfolgt der Simulationsstart . Für eine grafische Darstel-
lung der Ergebnisse in der MATLAB-Umgebung kann die Click Function 5 ausgeführt werden.
Das zugehörige M-File erscheint im Editor und die Plotanweisungen werden abgearbeitet.
In den Beispiel-Programmen von Abschn. 4.5 und Abschn. 4.6, u. a. metro_S1.mdl [52]
wird gezeigt, wie Parameter von Blöcken mit Click Functions gesetzt werden können, vgl. auch
Beispiel 4.2.
4.3.5.2 Zur Erstellung eines Subsystems

Bei komplexeren bzw. umfangreichen Modellen gewinnt man an Übersichtlichkeit, wenn Mo-
dellgruppen zu Subsystemen zusammengefasst werden. Darüber hinaus können mehrfach einge-
setzte Baugruppen in einer Modell-Bibliothek in Form von Subsystemen bereitgestellt werden.
Wir unterscheiden in Bild 4.10 zwei Möglichkeiten der einfachen Subsystem-Erstellung für die
zeitdiskrete Folge yk = yk−1 + 1, k = 1,2, . . ., die wir stichwortartig beschreiben.
Bild 4.10: Subsystem-Erstellung, oben: Modell-Ausschnitt, Subsmodell; unten: maskiertes Subsystem
1. Ausschnitt eines vorhandenen Modells; vgl. Bild 4.10 links:

a. Modell kopieren, da Vorgehensweise eingeschränkt umkehrbar ist.
b. Bereich mit Gummiband abgrenzen: linke Maustaste gedrückt halten und gegenüber-
liegende Eckpunkte des Subsystems anfahren → Elemente des Subsystems sind mar-
kiert.
c. Button Edit → create subsystem → Subsystem ist erstellt, vgl. Bild 4.10 un-
ten.
d. Eigene Kennung und Beschriftung einbringen; vgl. Abschn. 4.3.5.4.
e. Subsystem speichern; ggf. zuvor Block zur Isolierung in neues Fenster kopieren und
möglicherweise ergänzen.
2. Direkte Erstellung; vgl. Bild 4.10 rechts:
a. Block Subsystem aus Ports & Subsystems in das Modell-Fenster ziehen.
b. Doppelklick auf den Block öffnet das Fenster für das Subsystem; Modell kann erstellt
oder hineinkopiert werden.
In Bild 4.10 unten ist das Modell mit dem erstellten und anschließend maskierten Submodell,
siehe Abschn. 4.3.5.4, dargestellt. Der Model Browser mit den Modell-Elementen wird durch den
Button ein-/ausgeblendet. Experimentierfiles: SubModell_1.mdl, SubModell_2.mdl
in [52].
4.3.5.3 Einbinden von Referenzmodellen (Model Referencing)

Im Gegensatz zu den Subsystemen nach Abschn. 4.3.5.2 müssen die in ein neues Modell einzu-
bindenden Modelle, die Referenzmodelle, nicht in dieses kopiert werden.
Das Referenzmodell existiert als unabhängiges, lauffähiges Modell mit sinnvollen Schnittstel-
len in Form von Inport- und Outport-Blöcken aus der Ports & Subsystems Library. Die Parameter
des Referenzmodells müssen im Modell Workspace stehen. Dies organisiert man bei geöff-
netem Simulink-Modell mit Hilfe des Model Explores , vgl. Abschn. 4.3.5.7. Den Zugang zum
Workspace erhält man in der Model Hierarchy-Spalte unter dem Modellnamen, das zugehöri-
ge Fenster öffnet sich. Unter Data Source: lassen sich Eingabeoptionen, wie MATLAB File,
MATLAB Code usw. auswählen. Mit MATLAB Code sind die Parameter, z. B. mu1=2; mu2=3;,
in das Eingabefeld zu schreiben. Mit dem Button Reinitialize from Source werden die Daten in
den Workspace übertragen. Als Bezugsgrößen sind die Variablennamen, durch Komma vonein-
ander getrennt, in das Feld Model arguments einzutragen, z. B. mu1, mu2. All diese Größen
beziehen sich nur auf das Referenzmodell. Der Bezug zu den eigenen Daten im Subsystem, auch
Parent Model genannt, wird über die Reihenfolge hergestellt. Das Referenzmodell ist somit kom-
plett und lauffähig.
Mit dem Model Block aus der Library Ports & Subsystems wird das vor Änderungen geschütz-
te Referenzmodell in das zu erstellende Simulink-Modell unter Angabe des Namens eingebunden,
wobei die Signalpfade zu den Inport- und Outport-Blöcken des Referenzmodells als Ein- bzw.
Ausgänge erscheinen. Durch einen Doppelt-Klick auf diesen zunächst rot eingefärbten Block
öffnet sich das Block Parameters: Model Fenster, in das unter Model name: der Name des Refe-
renzmodells einzutragen ist. In der Zeile Model arguments values sind die eigenen Parameter in
oben festgeschriebener Reihenfolge durch Komma getrennt aufzulisten, z. B. in der Form:
Zahlenwerte: 5,6 oder Variablenname: z1, z2
Die Zuordnung erfolgt mit dem Button Apply und wird in der Zeile Model arguments angezeigt.
Die Variablennamen werden z. B. benötigt, wenn für den Block eine eigene Parameterbox, vgl.
Abschn. 4.3.5.4, erstellt wird. Die Zahlenwerte können in diesem Fenster, zu öffnen über das Kon-
textmenü zum Model Block (rechte Maustaste) unter: ModelReference Parameters...,
oder im Explorer später geändert werden.
Letztendlich ist der Ausführungsmodus auszuwählen, u. a. Normal oder Accelerator

(Standard). Dabei wird unter Normal das Subsystem als autonomes Modell ausgeführt; ggf. ist
das Häkchen unter Simulink/Configuration Parameters.../ Optimization/
Signals and Param..../Inline parameters zu setzen. Unter Accelerator wird
nach dem Start des erstellten Modells zunächst ein Simulation Target, ein C Mex-File des Refe-
renzmodells, das unter Windows die Endung _msf.mexw32 (bzw. 64 für eine 64Bit-Version)
trägt, sowie das Verzeichnis slprj mit zusätzlichen Dateien erstellt. Bei jedem Neustart des
Modells wird unter Accelerator das System auf Änderungen überprüft und ggf. neu compiliert.
Unter welchen Bedingungen dies erfolgen soll, ist in Simulation / Configuration Parameters... /
Model Referencing / Rebuild: auszuwählen. Alle Files müssen im aktuellen oder in einem zum
MATLAB-Pfad gehörigen Verzeichnis stehen. Für den Accelerator Modus wird ein C-Compiler
vorausgesetzt, er wird mit mex -setup aus dem Command Window ausgewählt und eingebun-
den, vgl. Seite 317.
Die im Bild 4.19 modellierte Fahrbahn ist ein typisches Beispiel für ein Referenzmodell. Hier-
mit wird in der Beschreibung (Discription unter: Edit/Model Properties) zum Simulink-
Modell F_Profil.mdl aus [52] die Erstellung vertieft.
Einschränkungen sind unter der Online Hilfe unter: model referencing limitations
angegeben. Konvertierungen von Submodellen aus Abschn. 4.3.5.2 in Referenzmodelle sind
möglich, siehe help simulink.SubSystem.convertToModelReference.
4.3.5.4 Maskierung und Parameterbox

Eigens kreierte Blöcke, Subblöcke sowie Level-1 M-File S-Function Blöcke, siehe Abschn. 4.7,
lassen sich mittels Text, Grafik oder numerischer Ausdrücke kennzeichnen. Hierzu ist der zu
bearbeitende Block zu aktivieren und unter dem Menü-Punkt Edit oder im Kontextmenü (öff-
nen mit rechter Maustaste) mit Edit Mask bzw. Ctrl+M den Mask Editor zu öffnen. Im
Drawing commands Fenster sind dann die Eintragungen vorzunehmen, wobei eine Beispiel-
Tabelle mit der zugehörigen Syntax dies unterstützt. Wir geben einige Möglichkeiten an.
Texterzeugung
disp(’text’); erscheint zentriert im Block
text(x,y,’text’); über x,y positionierbar
fprintf(’text’)
disp(’text1 \ntext2’); mit Übergang auf neue Zeile \n
Grafikerzeugung
Darüber hinaus kann die Funktion des zu maskierenden Subsystems durch Grafiken im Block,
wie in Bild 4.10 unten, hervorgehoben werden. Mittels Plot-Aufruf lassen sich 2D-Grafiken di-
rekt erzeugen, z. B.
plot(sin(0:pi/100:2*pi)); oder
plot(t,y);,
wobei die Daten t und y im Fenster: Initialization/Initialization commands
z. B. wie mit
t=0:1/100:1; ; y=0.5+0.25*sin(2*pi*t);
erzeugt werden oder im Workespace liegen müssen. Im Icon-Fenster unter Units kann die
Skalierungsart eingestellt werden u. a.: Normalized (Fenstereckpunkte, unten links (0,0) oben
rechts (1,1)) oder mit Autoscale automatisch an die Extremwerte des Fensters angepasst.
3D-Grafiken, z. B. mit plot3 erzeugt, müssen zunächst in ein spezielles Grafikformat konver-
tiert werden. Im Allgemeinen lassen sich Grafiken und Photos unterschiedlicher Formate (vgl.
help imread) zur Maskierung der Blöcke nutzen. Wir zeigen dies mit einer 3D MATLAB-Grafik,
die wir zunächst mit cplxroot(2,15) erzeugen. Die im Grafikfenster dargestellte Grafik expor-
tieren wir in das JPG-Format und speichern die Grafik z. B. unter SubGrafik.jpg. Dieses
File lässt sich mit
image(imread(’SubGrafik.jpg’))
einbinden, wie in Bild 4.11 gezeigt; vgl. auch SubDemo_1.mdl, SubDemo_2.mdl in [52].
a: 3D-Einbindung b: Photo-Einbindung
Bild 4.11: Beispiele für eigens kreierte Block-Maskierungen
Labelerzeugung
Weiterhin lassen sich auch eigene Label der jeweiligen In- und/oder Outports anzeigen. Wir
geben zwei Möglichkeiten an, wobei vorausgesetzt wird, dass ein Block-Icon, wie in Bild 4.11,
existiert.
I Beschriftung der Ein- und Ausgabeports im Subsystem ändern:
– vorhandene Beschriftung mit rechter Maustaste anklicken
– Beschriftung ändern
– Edit Mask / Transparency auf Transparent setzen
II Für einen Block mit zwei Eingängen und einem Ausgang lauten die ins Drawing Com-
mand-Fenster einzutragenden Befehle:
port_label(’input’,1,’Eing 1’)
port_label(’input’,2,’Eing 2’)
port_label(’output’,1,’Ausg 1’)
vgl. Bild 4.11, wobei unter Transparency jetzt Opaque (undurchsichtig) auszuwählen
ist.
Parameter-Dialogbox
Darüber hinaus können auch subblockeigene Parameter-Dialog-Boxen erstellt werden, in denen,
wie in Standardblöcken, Parameter einzutragen oder zu aktualisieren sind, vgl. u. a. das Sub-
system der Fahrbahnunebenheit Bild 4.19 bzw. sim_v11s.mdl sowie sim_v12.mdl und
F_Profil in [52].
Wesentliche Schritte zur Parameter-Initialisierung:

• Feld Parameters im Mask Editor auswählen (siehe oben)
• Add Button anklicken (freie Zeile öffnet sich)
• Eintrag unter Prompt, z. B.: Bezeichnung/Verwendung, wie Filterkoeffizient a1
• Eintrag unter Variable, z. B. Variablen-Name: a1
• Eintrag wird in freigeschaltete Zeile übernommen
• weitere Einträge mit Add Button ... usw.
• Ergänzende Dialog parameters:
Spalte type: edit oder
(checkbox oder)
popup, Auswahl-Parameter im Fester Popups eingeben
Spalte Evaluate: (aktiv)
4.3.5.5 Marken und Speicher für den Signalfluss

In umfangreichen Modellen können die üblichen durchgezogenen Signalpfade zur Unübersicht-
lichkeit führen. Mit Hilfe der Goto / From Blöcke sowie der Data Store Memory / Read / Write
Blöcke aus der Signal Routing Sublibrary werden Signale ohne physikalische Verbindung wei-
tergeleitet. In Bild 4.12 sind beide Transfer-Möglichkeiten anhand des Modells zur Differenzial-
Bild 4.12: Beispiel zum Signalfluss mit Marken
gleichung eines Räuber-Beute-Modells 2. Ordnung für x, y

2
ẋ = 1,2x − x2 − (ẏ + y)
3
xy
ẏ = 1,5 −y
x + 0,2
demonstriert, wobei alle Signalflüsse lokale Größen sind. Während die Goto / From Blöcke in
einer Hierarchie-Ebene die Signale unmittelbar weiterleiten, benötigen die Data Store Blöcke den
zusätzlichen Memory Block. In beiden Fällen leitet ein Goto bzw. Data Store Memory Block die
Signale an mehrere korrespondierende From bzw. Data Store Read Blöcke weiter. Der Eingang
z. B. in den Goto Block kann reell, komplex oder vektoriell aller Simulink-Datentypen sein. Dies
gilt auch für den portlosen Signalfluss in/aus Subsystemen, wie anhand eines Submodells zu
einem Ein-Massen-Schwinger mit Dat_trans.mdl in [52] gezeigt. Dabei sind einige Regeln
zu beachten, die wir anhand der Goto / From Blöcke kurz erläutern, vgl. Online Hilfe.
Wesentlich ist die Einstellung in der Parameterbox des Goto Blocks. Einerseits erhält das
Signal eine Bezeichnung (Tag), z. B. A wie in Bild 4.13 und andererseits den Tag Visibility Pa-
rameter: local, scoped, global, der vom Ort der Blöcke in der Hierarchie-Ebene des Modells
abhängig ist. Für miteinander korrespondierender Blöcke, sie enthalten den gleichen Tag Name,
ist zu unterscheiden:
• local: Goto und From Block liegen in einer Hierarchie-Ebene, d. h. in der Hauptmodellebe-
ne, wie in Bild 4.12, bzw. in einem Subsystem. Der Tag Name steht in eckiger Klammer,
z. B. [ A ].
• scoped: Neben dem Goto und From Block wird der Goto Tag Visibility Block benötigt. Da-
bei können alle drei in einer Ebene, z. B. einem Subsystem (weniger sinnvoll), liegen oder
in unterschiedlichen Ebenen, z. B. Subsystemen unterhalb des Goto Tag Visibility Blocks.
Beispiel: Goto Tag Visibility und From Block in einer Ebene und der Goto Block in einem
eingebettetem Subsystem, vgl. Bild 4.13 oder Goto Tag Visibility und Goto Block in der
übergeordneten Ebene und der From Block in einem Subsystem, vgl. GotoFrom.mdl in
[52]. Bei zwei und mehr ähnlich aufgebauten Ebenen, die jeweils Bestandteil eines Subsys-
tems sind, ist mehrfach der gleiche Tag Name zulässig. Der Tag Name steht in geschweifter
Klammer, z. B. { A } wie in Bild 4.13.
• global: Goto und From Block/Blöcke können in beliebigen Ebenen eines Modells angeord-
net sein. Mehrfach Tag Name sind auszuschließen.
Bild 4.13: Beispiel zum pfadlosen Signalfluss in zwei Hierarchie-Ebenen
Zusammenfassend: Liegen die Blöcke mit gleichem Tag Name in einer ebenen, so sind sie
mit local zu vereinbaren. Existieren mehrere geschachtelte Subsysteme, so empfiehlt sich die
scoped Vereinbarung. Namensgebungen führen weniger zu Konflikten. Bei übersichtlich ange-
ordneten Subsystemen bietet sich die global Vereinbarung an. In der Parameter-Box des Goto
Blocks werden alle Verbindungen mit den korrespondierenden From Blöcken angezeigt. Mit
einem Mausklick auf den jeweiligen Eintrag wird der From Block im Simulink-Modell hervorge-
hoben.
4.3.5.6 Zur Bearbeitung der Scope-Darstellung

Linientypen, -stärken und -farben einer Grafik im Scope aus Bild 4.5 sind nicht direkt mani-
pulierbar. Es soll deshalb eine Möglichkeit zur Einblendung der Menü-Leiste entsprechend des
MATLAB-Grafik-Fensters (figure) Bild 1.11 angegeben werden. Damit sind dann bekannte Ände-
rungen und Ergänzungen möglich.
Einblenden der Menü-Leiste

Bei geöffnetem Modell und aktiviertem Scope wird mit den Set-Befehlen
set(0,’ShowHiddenHandles’,’On’)
set(gcf,’menubar’,’figure’), Wiederholung bei mehreren Scopes
die Menüleiste der Standard MATLAB Figure eingeblendet und somit die Grafik, u. a. mit den
in Abschn. 1.6.2.5 beschriebenen Mitteln, bearbeitbar. Dies gilt auch für den XY Graph. Nach
eingeblendeter Menü-Leiste wird mit figure(gcf) das Grafik-Fenster aktiviert, um es, wie
oben angegeben, zu bearbeiten. Aber auch über Befehlseingaben im Command Window wie z. B.
xlabel(’...’), ylabel(’...’), title(’....’), grid
sind jetzt Ergänzungen zulässig.
Darstellung im Figure-Fenster mit simplot
Mit dem Befehl simplot lassen sich Daten, die u. a. mittels Scope-Eintrag unter
Parameters/Data history:
Screen data to workspace (aktiv)
Variable name: {ScopeData} (default)
Format: Array | Structure | Structure with time
in dem vereinbarten Format in den Workspace geschrieben wurden, vereinfacht grafisch darstel-
len, vgl. help simplot. Beispiel: simplot(Data), wobei Data vom Format Structure
with time ist. Dies bezieht sich auch auf die Daten aus dem To Workspace Block. Vielfach
ist es sinnvoll, den simplot Befehl in Zusammenhang mit einem To Workspace Block unter
File/Model Properties/Callbacks – z. B. simplot(Data) – einzutragen, so dass
dieser unmittelbar nach der Integration ausgeführt wird, wie u. a. in sim_v12.mdl aus [52].
4.3.5.7 Der Model Explorer

Der Model Explorer, siehe auch Abschn. 6.1.6 und Bild 6.9, S 329, liefert u. a. einen schnel-
len Überblick aller in einem Simulink-Modell eingebrachten Blöcke. Die üblicherweise durch
Mausklick bezüglich der Modelle/Blöcke eingeblendeten Dialog-, Parameter-Boxen können im
Explorer integriert, geöffnet, die Einträge gesichtet und geändert werden. Dies wird um Informa-
tionen in einem Stateflow-Chart, wie in Kapitel 6, ergänzt.
Der Explorer wird aus der Menüleiste des Modell-Fensters unter View/Model Explorer
bzw. mit dem Button , über Explore des Kontext Menüs eines mit Rechts-Klick der Maustas-
te angewählten Objekts/Blocks oder aus dem Command Window mit daexplr geöffnet. Die
wesentlichen Elemente des Explorers, siehe Bild 6.9 sind die Haupt-Toolbar, die Search-Leiste
und die Spalten:
• Model Hierarchy • Contents / Search • Dialog
Die Dialog-Spalte kann mit dem Button ein- und ausgeblendet werden.
Die Model Hierarchy Spalte zeigt die hierarchisch angeordnete Baumstruktur der Simulink-
Umgebung mit den Haupt-Knoten Simulink Root, es folgen der Base Workspace (MATLAB Work-
space) sowie Knoten der geöffneten Simulink-Modelle. Jeder Modell-Ast enthält den Model
Workspace, die Subsysteme des Modells usw. Ein Mausklick auf den Modell-Knoten öffnet
die Contents Spalte ergänzt um die im Modell befindlichen Blöcken sowie zugehöriger Block-
Informationen in Abhängigkeit von der Auswahl im Feld Column View: z. B. Default, System
I/O usw. Gleichzeitig erscheinen die Modell-Eigenschaften (Model Properties) in der Dialog
Spalte.
Die Dialog- und Parameter-Fenster lassen sich durch Mausklick auf ein Blocksymbol in der
Contents Spalte in der Dialog Spalte anzeigen, Inhalte können gesichtet und geändert werden.
Vorteil: Viele über die Kontext- (Shortcut-) Menüs angewählten modell- und blockeigenen
Boxen eines Simulink-Modells sind auch im Explorer zugänglich.
In der folgenden Ausführung gehen wir nur auf die Anwahl mittels Kontext-Menü aus dem
Simulink-Modell ein. Das Handling mit dem Explorer ist für den Benutzer sehr hilfreich. Es emp-
fiehlt sich deshalb, unterstützt durch die Online-Hilfe zum Explorer, mit den Beispiel-Program-
men zu experimentieren.
4.3.5.8 Der Simulink-Debugger, erste Schritte

Mit dem Simulink-Debugger kann die Simulation Schritt für Schritt ausgeführt werden. Zu jedem
Schritt sind Ergebnisse zugänglich, so dass diese u. a. an ausgewählten Blöcken überprüft wer-
den können. Die einzelnen Ausführungsschritte werden methods (Methoden) genannt. Pro Block
können mehrere Methoden erforderlich sein.
Der Debugger basiert auf einer grafischen Oberfläche (GUI, Graphic User Interface) und auf
einer Command-Zeilen-Eingabe. Der Aufruf aus der Command-Zeile erfolgt mit >> sldebug
(’File_Name’). Es wird das Simulink-Modell mit dem eingegebenen File-Namen geöffnet,
die Eingaben erfolgen hinter dem neuen Prompt (sldebug @0): >>. Alle Kommandos wer-
den mit der Eingabe help angezeigt: z. B. step für den Übergang zum nächsten Simulations-
punkt.
Wir betrachten hier etwas ausführlicher die grafische Oberfläche. Aus dem Simulink-Modell-
Fenster unter Tools/Simulink Debugger wird die Oberfläche geöffnet. Die Hauptkom-
ponenten sind, wie in Bild 4.14: Toolbar sowie die Unterfenster Break Points, Simulation Loop,
Outputs, Sorted List und Status. Mit dem Icon ? der Toolbar lässt sich die Online-Hilfe öffnen.
Erste Schritte mit dem Debugger werden wir im Zusammenspiel mit dem Beispiel einer alge-
braischen Schleife aus Bild 4.2 durchführen. In Bild 4.14 ist dieses Modell sowie die Debugger-
Oberfläche nach einigen Schritten dargestellt.
Es lassen sich Berechnungen von Break Point zu Break Point oder unter Einbezug von Zwi-
schenschritten zur Anzeige bringen. In beiden Fällen ist zunächst der Start/Continue Button
zu betätigen. Zum Setzen eines Break Points ist der Block zum zu betrachtenden Ergebnis mit
einem Linksmausklick zu markieren, siehe sin Block in Bild 4.14, um anschließend mit ei-
nem Linksklick auf einen der Button der Toolbar den Break Point zu setzen. Er wird unter
Blocks der Break Points Spalte angezeigt. Hier kann ausgewählt werden: unter Setzen des
Stopps (Break) vor dem Block, unter Anzeige der Ein-/Ausgangsdaten (I/O) oder beides. Die
zugehörigen Daten kommen nach jedem Durchlauf in der Spalte Outputs zur Anzeige. Weitere
Break Points können gesetzt werden.
Mit wird die Rechnung bis zum folgenden Break Point fortgesetzt und die Ausgabe auf der
Outputs Seite aktualisiert, siehe Bild 4.14. Hier zeigt TM (Major Time Step) die aktuelle Zeit an,
gefolgt von dem Namen (iD, z. B. 0:1) der im nächsten Schritt ausgeführten Methode und dem
Bild 4.14: Modell-Fenster und grafische Debugger-Oberfläche
des Blocks auf den die Methode angewendet wird. U1 ist der Eingang, Y1 der Ausgang (mehrere
sind möglich). Mit lassen sich diese eines angewählten Blocks anzeigen.
Im Modell-Fenster wird im Animations-Mode einerseits die Box der folgenden Methode
(Next method box), vgl. Eintrag unter Outputs, eingeblendet und nach jedem weiteren Schritt
durch der Block mit dem gesetzten Break Point durch einen farbigen Pfeil (Block Pointer) und
einer Kachel (Method Tile) markiert. Die Kachel-Farbe und deren Lage enthalten Information
über den Ausführungsschritt, z. B. rot für Update, dunkelgrün für Outputs usw.
Für das Modell aus Bild 4.14 kann somit die Zeit TM sowie der Ein- und Ausgang am sin
Block verfolgt werden. Insbesondere zeigt sich, dass in einem Integrationsschritt versucht wird,
die algebraische Schleife iterativ zu lösen. Hier liegt Konvergenz vor.
In der Spalte Simulation Loop, siehe Bild 4.15, wird die Liste der Methoden, die während der
Simulation aufgerufen werden, hierarchisch in Baumstruktur angezeigt. Jeder Knoten steht für
eine Methode, er kann als zusätzlicher Break Point gesetzt werden. Die in der untersten Ebene
auftretenden Block Namen (Methoden), z. B. Trigo..., sind Hyperlinks. Ein Klick hierauf
markiert den zugehörigen Block im Modell-Fenster.
Mit den Button können alle oder wesentliche Schritte der Integration, also auch
zu Zwischenzeiten eines Integrationsintervalls (TM, Minor Time Step), angezeigt werden. Mit
(step) werden alle Methoden sämtlicher Hierarchie-Ebenen angezeigt, mit (step over) in je-
dem Schritt die der aktuellen Hierarchie-Ebene. Alle tiefer liegenden Methoden werden natürlich
Bild 4.15: Simulation Loop, Fenster mit Baum der Methoden
abgearbeitet aber nicht angezeigt. Mit (step out) erfolgt ein Sprung ans Ende (z. B. Trigo)
der aktuellen Methode, alle Zwischenschritte werden ausgeführt.
Mit (step top) wird an die Stelle der ersten Methode des nächsten Zeitschritts gesprungen
(im Allgemeinen an den Anfang der Simulationsschleife). Mit (step blockmth) erfolgt der
Sprung zum jeweils folgenden Block.
Diese Schritte sind auch ohne Break Point ausführbar. Experimente mit weiteren Beispielpro-
grammen sollten später durchgeführt werden.
4.4 Simulink-Modellierung eines einfachen Projekts

Wir wollen eine Einführung zur Modellerstellung und Simulation unter Simulink nicht an spezifi-
schen kleinen Beispielen, sondern schrittweise an einem kleinen Projekt vornehmen. Es werden
dabei bewusst einige numerische Probleme eingearbeitet, die später zu diskutieren sind. In den
Kapiteln 5, 6, 7 und 8 folgen ergänzende Beispiele/Projekte unterschiedlichster Problematiken,
z. B. zur Bearbeitung von Systemen mit Zustandsereignissen (Events).
4.4.1 1/4-Fahrzeugmodell und die Bewegungsgleichungen

Das Schwingungsverhalten, angeregt durch eine Rampenauffahrt, ist für das 1/4-Fahrzeugmodell
nach Bild 4.16 zu untersuchen. Das skizzierte Modell des Fahrzeuges, bestehend aus Aufbau
(mA ) und Reifen (mR , kR ), bewegt sich mit konstanter Geschwindigkeit über eine Rampe

0,1 t in [m] für t < 0,1 s
xS = (4.4)
0,01 in [m] für t ≥ 0,1 s, ausschließlich der Fahrbahnunebenheit
4.4 Simulink-Modellierung eines einfachen Projekts 187
Bild 4.16: Fahrzeugmodell auf unebener Fahrbahn
und schließlich auf einer unebenen Fahrbahn. Die Radaufhängung wird durch die Feder (kA ), den
Dämpfer (dA ) und das C OULOMBsche Reibelement (Reibkraft FC ), z. B. infolge eines Blattfeder-
pakets nach [12], beschrieben; kR berücksichtigt die Reifensteifigkeit. Die Auslenkungen xA , xR
zählen wir aus der Gleichgewichtslage, die sich infolge der Gewichte einstellt.
Systemparameter: mA = 103 kg; mR = 102 kg; dA = 12 103 N s/m
kA = 40 103 N/m; kR = 40 104 N/m; FC = 400 N
Bild 4.17: Schnittbild zum Fahrzeugmodell
Die zugehörigen Bewegungsgleichungen ergeben sich mit Bild 4.17 nach N EWTON aus
Abschn. 2.3.2.1 zu:
mA ẍA + kA (xA − xR ) + dA (ẋA − ẋR ) + FC sign(ẋA − ẋR ) = 0

(4.5)
mR ẍR − kA (xA − xR ) − dA (ẋA − ẋR ) − FC sign(ẋA − ẋR ) − kR (xS − xR ) = 0.
Aufgrund des Reibansatzes berücksichtigen die Bewegungsgleichungen die Bereiche der Gleit-
reibung vrel = ẋA − ẋR

= 0; ausgedrückt durch die Definition der sign-Funktion

1 für vrel > 0
sign vrel = sign(0) mathematisch nicht definiert. (4.6)
−1 für vrel < 0
Es liegen also Bewegungsgleichungen mit Unstetigkeiten vor, vgl. Kapitel 5. Dieses kann
numerisch Schwierigkeiten bereiten. Aus diesem Grund entschärft man das Problem oft durch
die abgebildete stückweise stetige Reibkennlinie (Sättigungsfunktion, sat).
Beide Fälle sollen betrachtet werden.
4.4.2 Aufbereitung der Bewegungsgleichungen

Die Bewegungsgleichungen (4.5) bestehen vorwiegend aus linearen Abhängigkeiten. Bei der
Modellierung wollen wir deshalb auf dem State Space Block3 aus der Continuous-Library mit
der übergeordneten Gleichungsstruktur in Simulink-Schreibweise
x = Ax + Bu
(4.7)
y = Cx + Du
aufbauen. Hierzu muss die Systemgleichung (4.5) in Zustandsform überführt werden, wobei wir
die Modelle ohne und mit Reibelement unterscheiden und in dieser Reihenfolge auch in Simulink
bearbeiten wollen.
4.4.2.1 Fahrzeugmodell ohne Reibelement

Für die Zustandsdifferenzialgleichung führen wir neue Abkürzungen der Zustände ein:
x1 = xA ; x2 = xR ; x3 = ẋA ; x4 = ẋR . (4.8)
Hiermit können wir die Bewegungsgleichungen (4.5) für FC = 0 auf die Form
ẋ1 = x3
ẋ2 = x4
kA dA (4.9)
ẋ3 = − (x1 − x2 ) − (x3 − x4 )
mA mA
kA dA kR
ẋ4 = (x1 − x2 ) + (x3 − x4 ) − (x2 − xS )
mR mR mR
3 auch eine vektorielle Betrachtung mit einem oder zwei Integrierer-Blöcken ist möglich
bringen, wobei xS die Eingangsfunktion nach (4.4) ist. Wir wählen x1 = xA und x2 = xR als
Ausgänge. (4.9) hat somit die Struktur
ẋx = Ax + B u, u = xs
(4.10)
y = CxCx.
Die Systemmatrizen stellen wir zusammen:

- Systemmatrix A :
⎡ ⎤
0 0 1 0
⎢ 0 0 0 1 ⎥
A=⎢ ⎣ −kA /mA
⎥ (4.11)
kA /mA −dA /mA dA /mA ⎦
kA /mR −(kA + kR )/mR dA /mR −dA /mR
- Eingangsvektor B für die Eingangsgröße u = xS :
B = [0, 0, 0, kR /mR ]T (4.12)
- Messmatrix C und Durchgangsmatrix D für die Messgrößen x1 , x2 :

1 0 0 0 0
C= ; D= (4.13)
0 1 0 0 0
- Zustandsvektor x und Messvektor y :
x = (xA , xR , ẋA , ẋR )T = (x1 , x2 , x3 , x4 )T ; (4.14)
y = (xA , xR )T = (x1 , x2 )T . (4.15)

Alternativer Ausgang y : Ist man an der Beschleunigung des Aufbaus ẍA = ẋ3 sowie an der Rei-
fenkraft fR interessiert, dann erreichen wir dies mit
⎡ ⎤
kA kA x1
dA ⎢
ẋ3 − mA mA − mA mA ⎢ x2 ⎥
dA
⎥+ 0
= ⎣ ẋ1 ⎦ u, u = xS
fR 0 kR 0 0 −kR
ẋ2
y = C x + D u.
4.4.2.2 Fahrzeugmodell mit Reibelement

Die Systemmatrix A bleibt unverändert. Da die Relativgeschwindigkeit x3 − x4 ins Reibgesetz
eingeht und wir dieses außerhalb des State Space Blocks modellieren müssen, ist der Ausgangs-
vektor y gegenüber der vorangegangenen Betrachtung zu erweitern. Einerseits können wir C so
wählen, dass y = x , andererseits können wir aber auch C so aufbauen, dass am Ausgang die Re-
lativgeschwindigkeit x3 − x4 anliegt. Über die Eingangsmatrix B bringen wir jetzt zusätzlich die
Reibkräfte in das System ein, so dass folgende Matrizen gegenüber dem reibungsfreien System
einzusetzen sind:
- Eingangsmatrix B , Eingangsvektor für das C OULOMB-Reibelement ũu:
⎡ ⎤
0 0
⎢ 0 0 ⎥ xS
B=⎢ ⎣
⎥ , ũu = (4.16)
0 −FC /mA ⎦ sign (x3 − x4 )
kR /mR FC /mR
- Messmatrix C und Durchgangsmatrix D , es bieten sich zwei Möglichkeiten an:

a) Ausgabe aller Zustandsgrößen
C = E4×4 4 × 4-Einheits-Matrix, D = 04 × 2 4 × 2-Null-Matrix (4.17)
b) Ausgabe der Auslenkungen x1 , x2 sowie der Relativgeschwindigkeit x3 − x4

⎡ ⎤ ⎡ ⎤
1 0 0 0 0 0
C = ⎣ 0 1 0 0 ⎦; D=⎣ 0 0 ⎦ (4.18)
0 0 1 −1 0 0
Wir arbeiten mit der Ausgabe aller Zustandsgrößen, also mit (4.17).
Im Weiteren wollen wir die Simulink-Modellierung schrittweise aufbauen. Wir beginnen mit
der Formulierung des Fahrbahnprofils.
4.4.3 Das Fahrbahnprofil
Das Fahrbahnprofil werden wir in zwei Schritten erzeugen. Zunächst modellieren wir die Fahr-
bahnunebenheit und daran anschließend die Rampe und das ebene Plateau nach (4.4). Das voll-
ständige Fahrbahnprofil setzt sich dann auf dem Plateau additiv aus beiden Anteilen zusammen.
Natürlich können auch gemessene Fahrbahnunebenheiten verarbeitet werden. Liegen Mess-
werte sowie ein hierzu parallel aufgenommener Zeitvektor, der ein Maß für die Geschwindigkeit
darstellt, vor, dann können diese mit dem From Workspace Block aus Sources in das Problem
eingebunden werden. Der mit anzugebende Zeitvektor dient dabei zur Synchronisierung mit der
Simulationszeit.
4.4.3.1 Modellierung der Fahrbahnunebenheit
Zur Nachbildung der Fahrbahnoberfläche gehen wir von einem tiefpassgefilterten digitalen wei-
ßen Rauschen aus, siehe Bild 4.20 links. Der Tiefpass sei ein B UTTERWORTH-Filter 3-ter Ord-
nung (lineare gewöhnliche Differenzialgleichung 3. Ordnung)
...
y F + μ1 ωg ÿF + μ2 ωg2 ẏF + μ3 ωg3 yF = μ3 ωg3 u (4.19)

uF
mit dem Eingangssignal u und den Filterparametern μ1 = μ2 = 2; μ3 = 1 sowie der Grenzfre-

quenz (Eckfrequenz) ωg . Der Funktionsblock Band-Limited White Noise aus der Blocklibrary
uF yF Fahrbahnunebenheit
- -
Band-Limited Tiefpassfilter
White Noise
Bild 4.18: Fahrbahnmodellierung
Sources liefert das digitale Rauschsignal uF . Mit dem Parameter ωg des Tiefpassfilters (Form-
filters) glätten wir das Signal und steuern den Oberwellengehalt der Fahrbahnunebenheit. Die
Amplitudenwerte werden über die Intensität des Rauschsignals eingestellt; einfachheitshalber
ziehen wir den Koeffizienten μ3 ωg3 in (4.19) in die Intensitätseinstellung uF hinein:
uF = μ3 ωg3 u.
Diesen Blockparameter stellen wir unter Noise power des Rauschgenerators ein. Der Parame-
ter Sample time des gleichen Fensters beschreibt die Impulsbreite, vgl. Bild 4.20, und ist somit
ein weiteres Maß für die Unebenheit der Fahrbahn in Abhängigkeit von der Fahrzeuggeschwin-
digkeit. Der endgültige geglättete Unebenheitsgrad in Frequenzanteil und Amplitude wird über
das Tiefpassfilter eingestellt.
Wir betrachten eine Fahrbahnunebenheit mit dem Parametersatz:
Tiefpass ωg 100 rad/sec
Rauschgenerator Noise power μ3 ωg3 u, z. B.: u = 0,1333
Sample time 0,02 sec
Seed [23341] (standard)
Die Filtergleichung (4.19) oder allgemeiner gewöhnliche lineare Differenzialgleichung lässt sich
auf unterschiedliche Weise modellieren. Wir geben drei Beispiele:
1. Modellierung mit den Funktionsblöcken: Integrierer, Verstärker und Summierer (lineare

und nichtlineare Differenzialgleichung)
2. Modellierung mit dem State Space Block; siehe Fahrzeugmodell. Der lineare Anteil der Dif-
ferenzialgleichung muss in Zustandsform formuliert sein; isolierte Nichtlinearitäten lassen
sich vielfach über die Eingangsmatrix einbringen.
3. Modellierung als Übertragungsfunktion [28] mit dem Transfer Fcn Block.
mu3*omg^3
s3+mu1*omg.s2 +mu2*omg^2.s+mu3*omg^3
Transfer Fcn1
4. Modellierung mit einer S-Function in den Programmiersprachen MATLAB, C, C++, Ada

oder Fortran. Hiermit ist nahezu jede Form der Modellierung möglich. Die Handhabung ist
wegen der Synchronisation mit dem Simulationsprozess aufwendiger; die Programmstruk-
tur ist weitgehend festgeschrieben, siehe Abschn. 4.7.
Wir wollen (4.19) nach 1. mit einer Integriererkette realisieren. Hierzu lösen wir (4.19) nach
der höchsten Ableitung auf
...
y F = − μ1 ωg ÿF − μ2 ωg2 ẏF − μ3 ωg3 yF + uF (4.20)
...
und bilden aus y F durch Hintereinanderschalten von drei Integrierern ÿF , ẏF , yF . Die Gewich-
tungen der Ableitungen für die Rückkopplung erreichen wir mit Verstärker-Blöcken (Gain Blö-
cken). Mittels Summierer fassen wir alle Größen entsprechend der rechten Seite von (4.20) zur
höchsten Ableitung zusammen, so dass vor dem ersten Integrierer des Modells (4.20) realisiert
ist. Bild 4.19 oben zeigt das erstellte Blockmodell, mit dem die Simulation ausgeführt werden
kann. In Bild 4.20 ist das erzeugte Rauschsignal und die erzielte Fahrbahnfunktion dargestellt.
Bild 4.19: Subsystem der Fahrbahnunebenheit
Weisses Rauschen (bandbegrenzt) −3 Strassenprofil

x 10
8000 6
6000
Fahrbahnunebenheit [m]
4
4000
2
Intensität
2000
0
0
−2
−2000
−4000 −4
−6000 −6
0 0.2 0.4 0.6 0.8 1 0 0.2 0.4 0.6 0.8 1
Zeit [sec] Zeit [sec]
Bild 4.20: Rauschsignal und Fahrbahnunebenheit
Da das Fahrbahnmodell für sich eine Einheit darstellt, können wir es als maskiertes Subsystem
(eigener Funktionsblock) mit dem Ausgang der Fahrbahnfunktion (Zeitfunktion) kreieren; vgl.
Abschn. 4.3.5.2 sowie Bild 4.19 unten. Wir werden es später in das Fahrzeugmodell einbringen.
Das Simulink-Modell sim_v11s.mdl aus Bild 4.19 ist in [52] zu finden. Für die Filterparame-
ter des Submodells ist eine Parameterbox nach Abschn. 4.3.5.4, Parameter-Dialogbox, angelegt.
Da dieses Subsystem in mehrere Modelle eingeht, wäre es günstiger, das Modell aus Bild 4.19
als Referenzmodell zu definieren, um später hierauf eine Referenz (Model Referencing) wie in
Abschn. 4.3.5.3 zu erstellen. Dies wird mit F_Profil.mdl in [52] gezeigt.
Übungsvorschlag: Modellieren Sie die Filtergleichung (4.19) mit Hilfe der zugehörigen Übertra-
gungsfunktion und bilden Sie damit ein maskiertes Submodell mit zugehöriger Parameterbox.
4.4.3.2 Modellierung der ebenen Fahrbahnstruktur

Um einige Blöcke der Simulink-Library zu präsentieren, werden wir bei der Modellierung der
ebenen Fahrbahnstruktur zwei Darstellungen gegenüberstellen. Die zuvor formulierte Fahrbah-
nunebenheit geht additiv in die hier zu formulierende Fahrbahnstruktur ein.
Modellierung mit einem Function-Block
Mit den Function-Blöcken in Bild 4.21 aus der User-Defined Functions Bibliothek kann der
funktionale Zusammenhang von n Eingängen und m Ausgängen hergestellt werden (MIMO 4 -
Block). Die Funktionen lassen sich einerseits direkt ins Block-Fenster, vgl. Parameterfenster
des Fcn Blocks in Bild 4.21, andererseits indirekt über eine Function (M-File) einbringen. Die
Bild 4.21: Function-Blöcke zur Erzeugung der Rampenfunktion, Rampe_S.mdl
Function für den Interpreted MATLAB Function Block (vor Simulink 7.7: MATLAB Fcn) ist im
Editor mit:
function y = rampe(u) % rampe.m
if u < 0.1
y = 0.1 * u;
else
y = 0.01;
end
zu erstellen und unter rampe.m abzuspeichern. Der Eintrag ins zugehörige Blockfenster um-
fasst u. a:
4 MIMO Multiple Input Multiple Output System
MATLAB function rampe, output dimensions 1, output signal type auto

Der gleiche Inhalt des M-Files rampe.m ist auch für den MATLAB Function Block (Simulink 7.7;
vorher: Embedded MATLAB Function) im MATLAB Funktion Block Editor, der sich mit einem
Doppel-Mausklick auf den Block öffnet, einzutragen. Der erstellte Code wird in einen compi-
lierten C Mex-Code – ein C-Compiler muss installiert sein – gebracht, es wird zusätzlich die
S-Function rampe_S_sfun und das Verzeichnis slprj, vgl. Abschn. 4.3.5.3 angelegt. Damit
macht der MATLAB Function Block in vielen Fällen eine Programmierung von S-Functions nach
Abschn. 4.7 überflüssig.
Mit diesen Formulierungen wird über die Unstetigkeit hinweg integriert; das Zeitereignis Ram-
penende wird nicht detektiert. Darüber hinaus wird eine additiv hinzugefügte Fahrbahnuneben-
heit auch auf der Rampe überlagert. Dies wollen wir aber ausschließen.
Modellierung mit dem Switch und Gain Block

Alternativ modellieren wir jetzt die Fahrbahn (4.4) mit einem Gain Block – die Verstärkung kann
ein Skalar oder eine Matrix sein – mit dem Eingang der Zeit t und dem Ausgang 0.1*t ent-
sprechend (4.4). Der Verstärkungsfaktor 0.1 ist direkt in das zugehörige Parameterfenster des
Gain Blocks einzutragen. Das Fahrbahnniveau nach der Rampenauffahrt wird durch den Con-
stant Block mit der zugewiesenen Niveauhöhe (hier: 0.01) eingestellt. Die logische Entschei-
dung bezüglich des Eintretens des Zeitereignisses: oberes Fahrbahnniveau erreicht (hier nach
(4.4): 0.1*t ≤ 0.01), führen wir mit dem Switch Block – vgl. Bild 4.22 und Signal Routing
Library – aus, wobei der Threshold-Parameter (Schwellwert-Parameter, hier: 0.01) im Switch
Block-Fenster einzustellen ist. In Abhängigkeit des ’control inputs’ und des Schwellwertes in
Bild 4.22 wird der Rampenanstieg 0.1*t solange duchgeschleift bis der Schwellwert erreicht
ist, anschließend wird auf den konstanten Wert 0.01 umgeschaltet. Am Block-Ausgang liegt da-
mit die Fahrbahnstruktur für 0 ≤ t ≤ te an. Das zugehörige Simulink-Modell zeigt Bild 4.22 rechts.
Im Gegensatz zur Formulierung mit dem M-File rampe.m, kann der Zeitpunkt des Schaltens,
also das Zeitereignis Rampenende, durch aktivieren von Enable zeros crossing detec-
tion im Parameterfenster des Switch Blocks ermittelt werden. Es erfolgt somit im Sinne der
Numerik eine exakte Anstückelung der Integrationsbereiche.
Rampenfunktion
if control > = threshold
0.01
control input output
Constant
0.1 1
if control < threshold Out1
Switch1 Clock Gain Switch
Bild 4.22: Schalterfunktion und Simulink-Modell für die ebene Fahrbahnstruktur
4.4.4 Parametrisierung des Zustandsmodells im State Space Block
Den linearen Anteil der mathematischen Formulierung des Fahrzeugmodells nach Abschn. 4.4.2
bringen wir, wie in Abschn. 4.3.3 angegeben, über den State Space Block in die Modellierung ein.
Hierzu tragen wir, nicht die numerische Form der Matrizen, sondern die eingeführte Matrizen-
Bezeichnungen A, B, C, D in die Parameter-Dialog-Box des State Space Blocks ein. Vor dem
Simulationsstart müssen die zugehörigen numerischen Werte im Workspace vorliegen. Dies lässt
sich am einfachsten mittels M-File nach Bild 4.23 (sim_v13D.m), welches die Parameter und
die verwendeten Matrizen enthält, erreichen. Das M-File sim_v13D ist vor dem Simulations-
%-----------------------------Daten-Modul sim_v13D.m
% Simulink-Modell: sim_v12.mdl
fprintf (’Lade Daten für Rampenauffahrt’)
% Systemparameter
mA=1.0e+03; % Aufbauten-Masse [kg]
mR=1.0e+02; % Rad-Masse [kg]
kA=40.0e+03; % Federst. der Radaufhängung [N/m]
kR=40.0e+04; % Reifensteifigkeit [N/m]
dA=12.0e+03; % Dämpfung der Radaufhängung [Ns/m]
d=0.01; % Rampenhöhe [m]
A=[zeros(2) eye(2); % Systemmatrix

[-kA kA -dA dA ]/ mA;
[ kA -(kA+kR) dA -dA] / mR];
B=[0; 0; 0; kR/mR]; % Eingangsmatrix des reibfreien Modells
C=[eye(2) zeros(2)]; % Ausgangsmatrix des reibfreien Modells
D=zeros(2,1); % Durchgangsmatrix des reibfr. Modells
xi=[0;0;0;0] % Anfangswerte für die Simulation
disp(’ ’), disp(’ok.’)

%-----------------------------Daten-Modul sim_v13D.m
Bild 4.23: Daten-File für das reibungsfreie Modell
start auszuführen. Automatisch erfolgt dies mit dem Eintrag des Filenamens sim_v13D unter:
File-Button → Modell properties/Callbacks/InitFcn. Dieses File wird vor dem
Integrationsstart mit die Taste start ausgeführt. Ein Eintrag unter PreLoadFcn bewirkt nur
bei Öffnung des Modells eine Aktualisierung der Parameter.
4.4.5 Modellierung der Reibelemente
4.4.5.1 Coulomb-Reibkennlinie
Der Coulomb and Viscous Friction Block, Bild 4.5, aus der Discontinuities-Library bietet sich auf
den ersten Blick für eine Modellierung an. Er basiert auf
y = sign(u)(Gain abs(u) + Offset)
mit dem Ausgang y, dem Eingang u sowie den Block-Parametern Gain – Wert der viskosen
Kraft (Steigung) – und Offset – Wert der Gleitreibungskraft. Da wir den Betrag der Reibkraft
FC in die Eingangsmatrix B (4.16) hineingezogen haben, ist für die C OULOMBsche Reibung des
Fahrzeugmodells
Offset = 1 und Gain = 0
im Block-Parameter-Fenster zu setzen. Der Block-Eingang ist die Relativgeschwindigkeit zwi-

schen Aufbau und Rad, also
u = ẋA − ẋR = x3 − x4 .
Wegen der sign-Funktion können Haftreibungsphasen nicht erfasst werden (MATLAB Definition:
sign(0)=0). Es liegt eine Unstetigkeit vor, so dass dieser Block für eine numerische Integration,
insbesondere wenn x3 ≈ x4 , ungeeignet erscheint; vgl. Abschn. 4.4.3.1. Dennoch wollen wir ihn
weiterhin einsetzen.
4.4.5.2 Abschnittsweise stetige Reibfunktion

Zur Modellierung der abschnittsweisen stetigen Reibfunktion nach Bild 4.24 sollen u. a. der
Switch und Gain Block zur Modellierung herangezogen werden. Die bezogene Reibkraft ergibt
sich aus
%
F 1
v0 vrel −s0 v0 ≤ vrel ≤ s0 v0 , s0 ≥ 1
=: y = , für (4.21)
FC sign(vrel ) |vrel | > s0 v0
d. h. der Switch Block muss diese Größe in Abhängigkeit des Control-Inputs durchschalten bis
Bild 4.24: Reibkennlinie mit Bezeichnungen und Beschaltung des Switch Blocks
der Schwellwert/Threshold s0 ≥ 1 erreicht ist. Dies ist der Fall, wenn wir an den Control-Input
|u| = v10 |vrel | legen und den Block-Parameter threshold auf die maximale, bezogene Haftrei-
bungskraft F/FC (s0 ≥ 1) setzen, wie in Bild 4.24 angegeben. Dadurch werden auch die unter-
schiedlichen Größen von Haft- und Gleitreibung durch μ0 = s0 , μ = 1 näherungsweise berück-
sichtigt. Das Block-Modell der approximierten Reibkennlinie mit dem Eingang vrel = x3 − x4
und dem Ausgang y sowie der Steigung im Nulldurchgang v10 = 50 s/m – vgl. Gain Block – ist in
Bild 4.25 dargestellt, siehe auch Bild 4.32. Damit sind alle benötigten Komponenten modelliert,
so dass wir die problemabhängigen Simulink-Modelle erstellen können, vgl. Bild 4.30, 4.32.
Sign
Switch Abs
1 |u| 50 1
Out1 In1
Gain
approximierte Reibkennlinie
Bild 4.25: Block-Modell zur approximierten Reibkennlinie, 1/v0 = 50 s/m
4.4.5.3 Statischer Test der Reibmodelle
Bild 4.26: Block-Modell Ctest.mdl zum statischen Test der Reibkennlinien mit einer Testfunktion
Bei nichtlinearen Funktionen, also hier den Reibmodellen, ist ein separater Test des Block-
Modells – Ctest.mdl aus [52] – unumgänglich. Als Eingang unserer zu testenden Modelle
nach Bild 4.26 wählen wir zunächst eine Sägezahnfunktion, die die Relativgeschwindigkeit reprä-
sentiert. Die approximierte Kennlinie kann durch Variation der Steigung im Nulldurchgang 1/v0
und den Schwellwert s0 verändert werden. Die erhaltenen Ergebnisse sind in Bild 4.27 wiederge-
geben. Bei dem Coulomb & Viscous Friction Block wird stets der Nulldurchgang der Testfunktion
(Ereignis) detektiert und somit die Umschaltung ±1 exakt vorgenommen, d. h. die Reibkennlinie
zeichnet sich durch eine Diskontinuität (Sprung) aus. Diese Arbeitsweise ist festgeschrieben und
somit nicht manipulierbar. Im Gegensatz dazu kann die Arbeitsweise des Switch Blocks mit und
ohne Nullstellenbestimmung (zero crossing detection) bezüglich der Umschaltpunkte erfolgen.
Um dies zu verdeutlichen, sind in Bild 4.28 Ergebnisse zur approximierten Kennlinie für beide
Coulomb−Reibung approx. Reibkennlinie

3 3
Testfunktion
2 2
1 1
0 0
−1 −1
−2 −2
Threshold 1
−3 −3
0 0.5 1 1.5 2 0 0.5 1 1.5 2
Zeit t [s] Zeit t [s]
approx. Reibkennlinie approx. Reibkennlinie

3 3
2 2
1 1
0 0
−1 −1
−2 −2
Threshold 2 Threshold 2
−3 −3
0 0.5 1 1.5 2 0 0.5 1 1.5 2
Bild 4.27: Ergebnisse zur C OULOMBschen und approximierten Reibkennlinie; Steigungen im Nulldurch-
gang: b), d) 5, c) 500
3 3
mit Nullstellenermittlung ohne Nullstellenermittlung
2 2
1 1
Diskontinuität
0 0
Reibkraft Reibkraft
−1 −1
−2 −2
Testfunktion Testfunktion
−3 −3
0 0.2 0.4 0.6 0.8 0 0.2 0.4 0.6 0.8
Zeit [s] Zeit [s]
Bild 4.28: Ergebnisse mit und ohne Zeros Crossing Detection des Switch Blocks
Arbeitsweisen des Switch Blocks gegenübergestellt. Die Testfunktion ist jetzt ein Sinus. Einer-
seits ist das korrekte Einhalten der Schaltpunkte, andererseits die durch den Integrator (variable
Schrittweite) vorgegebene Tastung erkennbar. Es wird über die Ereignisse hinweg integriert. Auf
die Bearbeitung von Systemen mit Ereignissen wird im Abschn. 5.6 ausführlich eingegangen.
4.4.6 Die Startroutine für die MATLAB-Umgebung

Im Allgemeinen erfolgt der Simulationsstart über den Button Simulation/Start oder .
Vielfach ist es wünschenswert, die Simulation eines Block-Modells aus der MATLAB-Umgebung
zu starten. Dies ist insbesondere dann der Fall, wenn innerhalb einer Berechnung mit einem M-
File auf von einem Simulink-Modell erzeugte Daten zurückgegriffen werden muss. In unserem
Fall wollen wir über das Anstarten eines M-Files Parameter für das Block-Modell sim_v12
%------------------------------Start-File sim_v12S.m
sim_v12 % öffnen des Simulink-Modells

try % Startversuch, Fehler?
time = sim(’sim_v12’,3); % Start des Simulink-Modells
% mit Endzeitvorgabe
catch % nach Fehler neuer Start
sim_v13D % Aufruf des Daten-Moduls
% Daten in Workspace geschr.
time = sim(’sim_v12’,3); % siehe oben
end
h = findobj(0, ’Name’, ’Rampe’); % existiert figure?
if isempty(h), % nein,
h=figure(’Position’,[150 194... % dann Konfiguration
452 257],... % Position und Bildgröße
’Name’,’Rampe’,... % Namensgebung
’NumberTitle’,’off’); % Nr. ausblenden
end
figure(h) % Auswertung unter MATLAB
................... % Plot-Befehle
Bild 4.29: Start-File mit Aufruf des Simulink-Modells und des Datenfiles
in den Workspace schreiben, dann das Block-Modell öffnen und starten und nach der Simula-
tion die erzeugten Daten grafisch unter MATLAB auswerten; sie werden mit dem To Workspace
Block transferiert. Das Parameterfile sei sim_v13D.m [52], Bild 4.23. Bis auf die Integrati-
onszeit von 3 s sollen alle weiteren Simulationsparameter u. a. im Menü Configuration
Parameters festgeschrieben sein. Wie in Abschn. 4.3.4 beschrieben, hat der Aufruf im Start-
file sim_v12S.m dann folgende Form
time = sim (’sim_v12’, 3)
mit der die Integration über das Intervall 0 ≤ t ≤ 3 sec ausgeführt wird. Dieser Aufruf ist in das
M-File sim_v12S.m, wie in Bild 4.29 auszugsweise beschrieben, einzubinden. Die angegebe-
nen Schritte (weitere in [52]) in sim_v12S.m lassen sich u. a. mit Hilfe der Kommentarzeilen
nachvollziehen. Der Aufruf von sim_v12S erfolgt z. B. aus dem Command Window oder einem
M-File.
4.4.7 Simulink-Modelle und Simulationsergebnisse

4.4.7.1 Das reibungsfreie Modell
Mit den erstellten Einzelkomponenten ist zunächst das Fahrzeugmodell ohne Reibelement zu
erstellen. Dabei ist mit dem Manual Switch Block das ebene und unebene Fahrbahnprofil auszu-
wählen. Das Simulink-Modell sim_v12.mdl ist in Bild 4.30 abgebildet. Zur Datenübergabe in
den Workspace wählen wir den To Workspace Block. Nach der Modellierung sind insbesondere
bezüglich des State Space Modells die Parameter und Anfangswerte mit den im Parameterfile
sim_v13D.m verwendeten Bezeichnungen in der Parameter-Dialog-Box einzutragen. Dieses
Bild 4.30: Fahrzeugmodell ohne Reibelement auf ebener oder unebener Fahrbahn
Modell ist dann mit dem erstellten Startfile sim_v12S.m aus dem Command Window oder
mit dem Start-Button des Modell-Fensters, sofern das Datenfile sim_v13D.m, entsprechend
dem Hinweis von S. 195, in dem Feld unter Callbacks eingetragen ist, zu starten. Darüber
hinaus ist eine Ausführung von sim_v12S.m auch bei geöffnetem Modell-Fenster durch einen
Doppel-Mausklick auf den Startblock in Bild 4.30 – z. B. mit Hilfe eines Subsystemblocks er-
stellt – möglich. Alle angesprochenen Files sind in [52] abgelegt.
Simulationsergebnisse
In Bild 4.31 sind für beide Fahrbahnprofile die Ergebnisse gegenübergestellt. Man liest ab: Wäh-
rend der Rampenauffahrt folgt das Rad (xR ) unmittelbar der Rampenfunktion, der Aufbau (xA )
ist demgegenüber leicht zeitverzögert. Dies gilt auch für den Einschwingvorgang in die Gleich-
gewichtslage. Bei unebener Fahrbahn fällt auf, dass die Radauslenkung dem Profil entspricht –
Abhebevorgänge sind nicht modelliert, vgl. Abschn. 8.6 – der Aufbau aber aufgrund der Dämp-
fung die höherfrequenten Anteile nicht enthält. Dies ist ein Maß für die mehr oder weniger gute
Fahrwerksabstimmung, sie könnte noch optimiert werden.
Übungsvorschlag: Erstellen Sie auf der Basis eines Systems zweiter Ordnung
M ẍx +D
Dẋx +Kx
Kx = Bũu
von (4.5) ein Modell in vektorieller Modellierung mit zwei Integrierern.
Hilfe in sim_v14MDK.mdl aus [52].
4.4.7.2 Das reibungsbehaftete Modell
Für beide Reibmodelle erstellen wir auf der Basis von sim_v12.mdl nach Bild 4.30 ein
weiteres Block-Modell, wobei für die approximierte Kennlinie in (4.5) FC sign(ẋA − ẋR ) durch
F aus (4.21) zu ersetzen ist. Formal fügen wir zu sim_v12.mdl die getesteten Reibmodelle
hinzu und ergänzen das Datenfile sim_v13D.m um die Matrizen aus Abschn. 4.4.2.2 für das
Auslenkungen [m]
0.015
xA
xR
0.01
0.005
ebene Fahrbahn
ohne Reibelement
0
0 0.5 1 1.5 2 2.5 3
Zeit t [s]
Auslenkungen [m]
0.015
xA
xR
0.01
0.005
unebene Fahrbahn
ohne Reibelement
0
0 0.5 1 1.5 2 2.5 3
Zeit t [s]
Bild 4.31: Einschwingvorgang nach Rampenauffahrt bei ebener und unebener Fahrbahn
Bild 4.32: Block-Modell mit C OULOMBscher und approximierter Reibkennlinie
System mit Reibung. Die so aufgebauten Modelle sind in Bild 4.32 zusammengefasst.
Diskussion der Simulationsergebnisse
Eine Simulation mit dem Modell nach Bild 4.32, d. h. mit dem Coulomb & Viscous Friction Block
und ebener Fahrbahn, lässt keine Integration mit variabler Schrittweite zu. Dies liegt, wie schon
−3 Auslenkungen [m] Relativgeschw. [m/s]

x 10
15
0.06
10 0.04
0.02
xA
5 xR 0
−0.02
ebene Fahrbahn
0 −0.04
COULOMB−Reibung
−0.06
−5
0 0.2 0.4 0.6 0.8 1 0 0.2 0.4 0.6 0.8 1
x 10
15
0.06
10 0.04
0.02
xA
5 0
xR
−0.02
ebene Fahrbahn
0 −0.04
approx. Reibkennlinie
−0.06
−5
0 0.2 0.4 0.6 0.8 1 0 0.2 0.4 0.6 0.8 1
x 10
15
0.06
10 0.04
xA 0.02
5 xR 0
−0.02
ebene Fahrbahn
0 −0.04
−0.06
−5
0 1 2 3 4 0 1 2 3 4
Bild 4.33: Gegenüberstellung der Ergebnisse
vermutet, an der sprunghaften Änderung der Reibkraft in Bereichen, in denen die Relativge-
schwindigkeit ihr Vorzeichen wechselt. In diesem Fall ist die rechte Seite von (4.5) eine un-
stetige Funktion und somit in dieser Form nicht integrierbar. Dies hat nichts mit einer steifen
−3 Auslenkungen [m]
x 10
15
xA
xR
10
unebene Fahrbahn
0
ohne Reibelement
−5
0 0.5 1 1.5 2 2.5 3
Zeit t [s]
−3 Auslenkungen [m]
x 10
15
xA
xR
10
unebene Fahrbahn
0
−5
0 0.5 1 1.5 2 2.5 3
Zeit t [s]
Bild 4.34: Einfluss der Reibung bei unebener Fahrbahn
Differenzialgleichung zu tun, wie vielfach in der Literatur dargestellt. Auf eine korrekte Vorge-
hensweise wird in den Kapiteln 5 –8 eingegangen. Um dennoch einen Einblick in das System-
verhalten zu gewinnen, integrieren wir mit fester Schrittweite, z. B. h ≤ 0,0001. Das zugehörige
Simulationsergebnis ist in Bild 4.331 dargestellt. Man erkennt, dass sich nach einem kurzen
Einschwingvorgang ungedämpfte Schwingungen xA (t), xR (t) mit einer konstanten Amplituden-
differenz zueinander einstellen. Wie der Verlauf der Relativgeschwindigkeit zeigt, verschwindet
diese nahezu nach ca. 0,45 s. Numerisch bedeutet dies einen permanenter Vorzeichenwechsel der
Reibkraft bei betragsmäßig kleiner Relativgeschwindigkeit. Die Ursache der Dauerschwingung
in Bild 4.331 für t > 0,45 s liegt somit im Verschwinden der Relativgeschwindigkeit, was bei
korrekter Betrachtung in einer Haftreibungsphase endet. Dadurch wird der Dämpfer zwischen
Rad (R) und Aufbau (A) nach Bild 4.16 nahezu unwirksam – beide Teile können als miteinander
verhakt angesehen werden –, so dass aufgrund der fehlenden Dämpfung sich ein konservatives
Schwingungsverhalten einstellt.
Die Simulationsergebnisse in Bild 4.332,3 mit der approximierten Kennlinie des Modells auf
ebener Fahrbahn nach Bild 4.32 zeigen im Bereich 0 ≤ t ≤ 1 s auf den ersten Blick vergleichba-
res Verhalten. Vorteil dieser Modellierung ist, dass hier mit variabler Schrittweite integriert wer-
den kann. Aufgrund des steilen Nulldurchgangs der Reibfunktion liegt in diesem Bereich eine
steife Differenzialgleichung vor. Im Bereich kleiner Relativgeschwindigkeiten zeigt der Verlauf,
wiederum wegen des steilen Nulldurchgangs, eine stückweise stetige Änderung. Damit wirkt die-
ses Reibelement in der angenäherten Haftreibungszone wie ein geschwindigkeitsproportionaler
Dämpfer mit großer Dämpferkonstante bei kleiner Relativgeschwindigkeit. Dies wird deutlich,
wenn man, wie in Bild 4.333 dargestellt, die Integrationszeit auf 4 s erhöht.
Die Integration der Modelle mit unebener Fahrbahn zeigten sich bezüglich der Unstetigkeiten
nicht so kritisch, da hier die Relativgeschwindigkeit aufgrund der Schwingungen nach Bild 4.34
stärkeren Schwankungen unterliegt, so dass vrel ≈ 0 weitgehend auszuschließen ist. Das dyna-
mische Verhalten zeichnet sich wieder dadurch aus, dass das Rad (xR ) dem Fahrbahnprofil un-
mittelbar folgt, der Aufbau (xA ) verhält sich dagegen ruhiger; Oberwellenanteile werden stärker
gedämpft, was bei einem Fahrzeug durch eine gute Feder- und Dämpferabstimmung anzustreben
ist. Unberücksichtigt bleiben Abhebevorgänge, also typische Zustandsereignisse. Sie können mit
den später vorgestellten Methoden erfasst werden, vgl. auch Abschn. 8.6.
2 2 2 2
a) b) c) d)
Reibkraft
0 0 0 0
ode15s ode15s ode45 ode113

−2 −2 −2 −2
0 0.5 0 0.5 0 0.5 0 0.5
t [s] t [s] t [s] t [s]
Bild 4.35: Auswirkung der Integratorwahl bei steifen und unstetigen Differenzialgleichungen
Einfluss der Diskontinuitäten

Abschließend wollen wir noch kurz etwas zur Integratorwahl bei steifen Differenzialgleichungen
auch im Zusammenhang mit den Unstetigkeiten bemerken. Da wegen des steilen Nulldurchgangs
der approximierten Kennlinie steife Differenzialgleichungen zu integrieren sind, sind dement-
sprechend die Integratoren ode15s oder ode23s zu wählen. Darüber hinaus ist zu bedenken, dass
es bei Systemen mit stückweise stetigen Funktionen ohne direkte Berücksichtigung der Unstetig-
keitsstellen, z. B. wie beim Switch Block ohne zeros crossing detection, zu größeren
numerischen Fehlern mit Einfluss auf die Rechenzeit kommen kann. Diese Effekte lassen sich
mit dem Modell sim_v14.mdl veranschaulichen. Hierzu wurde mit ode15s / ode45 / ode113
über 0,5 s integriert und die bezogene Reibkraft (Switch Block-Ausgang) über der Zeit t aufgetra-
gen. Bild 4.35 zeigt die Ergebnisse. Dabei wurden die Schaltereignisse (mit threshold=1.2)
nur in Bild 4.35a detektiert, in den übrigen wurde über die Unstetigkeiten hinweg integriert. Das
Abschalten der Ereignisermittlung führt in Bild 4.35b demnach zu oszillatorischen Verläufen um
die Unstetigkeitsstelle, der steife Bereich wird sauber wiedergegeben. Das oszillatorische Verhal-
ten verstärkt sich erheblich mit den beiden weniger geeigneten Integratoren ode45 / ode113 wie
in Bild 4.35c,d und beschränkt sich nicht nur auf die Bereiche der Unstetigkeiten. Am stärksten
ausgeprägt ist es bei der Integration mit dem Mehrschrittverfahren (ode113). Dies ist eine bekann-
te Erfahrung: Mehrschrittverfahren eignen sich im Allgemeinen (konstruktionsbedingt) weniger
für Systeme mit Diskontinuitäten. Auch eine Integration mit ode45 / ode113 und Ereignisermitt-
lung zeigte dieses oszillatorische Verhalten, welches somit insbesondere auf die Steifigkeit der
Differenzialgleichung zurückzuführen ist.
4.5 Algebraische Schleifen in dynamischen Modellen 205
4.5 Algebraische Schleifen in dynamischen Modellen
4.5.1 Algebraische Schleifen
Algebraische Schleifen in einem Signalfluss enthalten nur Blöcke mit direktem Durchgang (di-
rect feedthrough), deren Eingangssignale direkt auf den Ausgang durchgeschleift werden.
Hierzu zählen die mathematischen Funktionsblöcke: Sum-, Gain-, Produkt-Block – siehe
Bild 4.38 – usw. Aber auch der im vorangegangenen Abschnitt eingesetzte State Space Block mit
der Durchgangsmatrix D
= 0 , sowie Transfer Function und Zero-Pol Blöcke. Darüber hinaus
entstehen algebraische Schleifen, wenn das Ausgangssignal eines Integrierers direkt zum Setzen
des externen Anfangssignals, auch unter Zwischenschaltung weitere Blöcke mit direktem Durch-
gang, genutzt wird. Abhilfe: es ist der Ausgang des State Port Signals wie in Abschn. 5.6.4.1
Bild 5.27, zurückführen.
Wird bei der Initialisierung eines Simulink-Modells eine algebraische Schleife (algebraic loop)
erkannt, dann wird eine Warnung (kann über: Simulation/Configuration Parameters/-
Diagnostics unterdrückt werden) mit den im Signalfluss liegenden Blöcken ausgegeben. Mo-
dellierungen rein algebraischer Probleme, wie in Bild 4.2 bzw. in alg_loop_1.mdl, alg_
loop_2.mdl, Alg_Gl_Sys.mdl aus [52], enthalten zwangsweise algebraische Schleifen. Ge-
löst werden diese Schleifen in jedem Integrationsschritt iterativ, siehe Abschn. 4.3.5.8. Da die
Konvergenz und die gefundene Lösung vom Startwert im Einzugsbereich einer Lösung abhängig
sind, sollte dieser gesetzt werden. Dies kann mit den Blöcken IC bzw. Algebraic Constraint aus
den Subbibliotheken Signal Attributes bzw. Math Operations, siehe oben angegebene Program-
me, geschehen.
Treten in dynamischen Modellen algebraische Schleifen auf, dann liegen Startwerte aus dem
jeweils vorangegangenen Integrationsschritt vor, die in der Regel im Einzugsbereich der iterativ
zu bestimmenden Lösung liegen, das Problem wird entschärft. Wenn möglich, sollten dennoch
die algebraische Schleifen durch Umformulieren eliminiert werden. Dies soll beispielorientiert
gezeigt werden.
4.5.2 System mit algebraischer Schleife
Typischer Vertreter von dynamischen Systemen mit algebraischen Schleifen sind die in Ab-
schn. 5.4 behandelten differenzial-algebraischen Gleichungen. Bild 5.13 zeigt ein mögliches
Simulink-Modell. Wir wollen uns hier auf Formulierungen durch gewöhnliche Differenzialglei-
chungen (ODE) mit mehreren Freiheitsgraden beschränken. In diesem Fall ist das Auftreten al-
gebraischer Schleifen abhängig von den Kopplungen der Differenzialgleichungen, z. B. einer
Trägheitskopplung.
Wir betrachten zunächst das einfache in Bild 4.36 abgebildete ebene mathematische Pendel
(m, L) an einem translatorisch bewegten Quader (M), der sich reibungsfrei auf einer horizontalen
Unterlage bewegt. Am Quader greift die Erregerkraft
f = q sin (Ωt + Φ) an. Im Drehgelenk A
soll das Selbsterregungsmoment mS = α − β ϕ 2 ϕ̇ mit den Parametern α, β wirken, vgl. VAN
DER P OL-Schwinger S. 234. Das Modell, Bild 4.36, stellt für f = 0 ein grobes Ersatzmodell
eines aus der Musik bekannten Metronoms dar, was später genauer zu untersuchen ist.
Bild 4.36: Pendelsystem, Metronom-Modell
4.5.2.1 Bewegungsgleichungen, erstes Simulink-Modell

Die Aufstellung der Bewegungsgleichungen führen wir im Sinne von D’A LEMBERT. Dazu sind
Koordinaten einzuführen, die Körper (Quader, Pendel) frei zu schneiden, die Schnittkräfte und
Schnittmomente einzutragen und zu benennen, Bild 4.37. Zusätzlich sind die Trägheitskräfte/-
Bild 4.37: Freischnitt
momente entgegen den eingeführten Koordinatenrichtungen einzutragen. Ansetzen der Gleichge-

wichtsbedingungen für die Systemteile Quader und Pendel führt auf die Bewegungsgleichungen.
Zunächst folgen die Gleichgewichtsbedingungen zu:
Quader mit der Masse M
∑ FQ,x,k = 0 → Fx + M ẍ − q sin (Ωt + Φ) = 0 (4.22)

(k)
Pendel mit der Masse m und der Länge L
∑ FP,x,k = 0 → Fx − mẍ − mLϕ̈ cos ϕ + mLϕ̇ 2 sin ϕ = 0 (4.23)

(k)
4.5 Algebraische Schleifen in dynamischen Modellen 207
(A)
∑ MP,k = 0 → −mẍL cos ϕ − mL2 ϕ̈ − mgL sin ϕ + α − β ϕ 2 ϕ̇ = 0 (4.24)
(k)
Elimination von Fx mit (4.22) und auflösen nach ẍ bzw. ϕ̈ liefern die in ein Simulink-Modell
umzusetzenden Bewegungsgleichungen:

mL 1
ẍ = −ϕ̈ cos ϕ + ϕ̇ sin ϕ +
2
q sin (Ωt + Φ)
M+m mL
(4.25)
1 1
ϕ̈ = ( −ẍ cos ϕ − g sin ϕ ) + α − β ϕ ϕ̇
2
L mL2
ẍ, ϕ̈ sind jeweils vor dem ersten Integrierer der Integrationskette in dem Simulink-Modell, Bild 4.38,
abzubilden. In (4.25) sind die Gleichungen über die Beschleunigungen gekoppelt, es liegt eine
Trägheitskopplung vor.
Nach dem Start des Modells, Bild 4.38 und metro_S.mdl [52], wird die Warnung einer
vorhandenen algebraischen Schleife mit dem Signalfluss der Schleife, wie in Bild 4.38 markiert,
im Command Window ausgegeben.
Bild 4.38: Simulink-Modell des Pendelsystems
4.5.2.2 Elimination der algebraischen Schleife
Zunächst formulieren wir die Ein-/Ausgänge u_1 → u_6 der in Bild 4.38 gekennzeichneten
Blöcke der algebraischen Schleife, um damit Eingang u_2 = x_pp des Integrierers 2 mit den in
Bild 4.38 eingeführten Bezeichnungen in indizierter Schreibweise, z. B. u_2 → u2 , zu bilden.
Im Einzelnen liest man ab:
u1 = ue + uϕ p − u6
mL mL
u2 = u1 = ue + uϕ p − u6 (4.26)
M+m M+m
u6 = u5 uc
mit u5 = −u4 − ug + use ; u4 = 1

L u3 ; u3 = u2 uc . Damit folgt
1
u6 = − u2 u2c − ug uc + use uc
L
und schließlich

mL 1
u2 = ue + uϕ p + u2 u2c + ug uc − use uc . (4.27)
M+m L
Da u2 = f (u2 ) eine implizite Funktion in u2 ist, kann diese algebraische Schleife nur iterativ
nach u2 für den folgenden Integrationsschritt aufgelöst werden.
Wir lösen (4.27) explizit nach u2 auf, womit die algebraische Schleife eliminierbar wird. Es ergibt
sich
mL
u2 = ue + uϕ p + ug uc − use uc (4.28)
M + m − muc
2
bzw. mit den ursprünglichen Bezeichnungen

mL 1 g
ẍ = q sin (Ωt + Φ) + ϕ̇ 2 sin ϕ + sin ϕ cos ϕ
M + m sin ϕ mL
2 L
(4.29)
1
− α − β ϕ 2
ϕ̇ cos ϕ .
mL2
D. h. statt (4.25)1 ist nun (4.29), wie in metro_S0.mdl in [52], zu modellieren, es tritt keine
algebraische Schleife mehr auf. Ein Vergleich mit (4.25) zeigt, dass mathematisch in (4.25)1 ϕ̈
aus (4.25)2 einzusetzen ist. Die Trägheitskopplung in (4.29) ist nicht mehr vorhanden.
Alternativ hätten wir auch u_5 = phi_pp mit den Übertragungen in der algebraischen Schlei-
fe, Bild 4.38, formulieren können, um damit die Integrationskette für ϕ̈ zu ersetzen, vgl. me-
tro_S1.mdl in [52]. Es ergibt sich:
−m q
ϕ̈ = cos ϕ ϕ̇ 2
sin ϕ + sin (Ωt + Φ)
M + m sin 2 ϕ mL
(4.30)
M+m g 1
+ sin ϕ − α − β ϕ 2
ϕ̇
m L mL2
In diesem Fall ist sogar (4.30) unabhängig von x und den zeitlichen Ableitungen, vgl. Abschn. 5.7.4.
4.6 Vektorielle Betrachtungsweise und Modellierung 209
4.6 Vektorielle Betrachtungsweise und Modellierung
Die Bewegungsgleichungen von Systemen mit mehreren Freiheitsgraden überführt man zweck-
mäßigerweise in eine vektorielle Schreibweise. Hiermit lässt sich in der Regel ein übersichtliche-
res Simulink-Modell erstellen. Angewendet auf (4.25) bedeutet dies:

mL2 mL cos ϕ ϕ̈ mgL sin ϕ − α − β ϕ 2 ϕ̇ 0
+ = sin (Ωt + Φ) (4.31)
mL cos ϕ M+m ẍ −mLϕ̇ 2 sin ϕ q
oder kurz
M (ϕ) ÿy + f (ϕ, ϕ̇) = q sin (Ωt + Φ) . (4.32)
Dabei ist M = M T die von ϕ abhängige symmetrische und positiv definite (det(M M ) > 0) Massen-
matrix, f die nichtlineare Vektorfunktion und q der Vektor der Erregeramplituden.
Zur Modellierung von (4.32) wird der Vektor ÿy vor dem ersten Integrierer abgebildet. Hierzu
multiplizieren wir zunächst (4.32) mit der Inversen von M durch:
ÿy = M −1 ( − f (ϕ, ϕ̇) + q sin (Ωt + Φ)) . (4.33)
In Bild 4.39 sind zwei Möglichkeiten zur Invertierung von M dargestellt. In der linken Bild-
Bild 4.39: Zwei Möglichkeiten zur Invertierung der Massenmatrix
hälfte wird die Invertierung und gleichzeitige Multiplikation mit der Vektorfunktion der rechten
Seite von (4.33) mit dem Divide Block vorgenommen. Die Massenmatrix M = M (ϕ) wird aus
zwei Anteilen, wie dargestellt, abgebildet. Die Integration wird jetzt vektoriell für ÿy → ẏy → y
durchgeführt. Abschließend kann y mit dem Demux Block (Demultiplexer) in seine Komponen-
ten zerlegt werden. Damit lässt sich die Vektorfunktion einschließlich der Anregung der rechten
Seite von (4.33) – meist– komponentenweise abbilden und mit dem Mux Block (Multiplexer)
vektorisieren.
Auf der rechten Seite von Bild 4.39 ist die Inversion und Multiplikation mit dem MATLAB
Function Block vorgenommen. Die Abhängigkeit von M von cos ϕ wird vor der Invertierung in
dem Block erzeugt. Die vollständigen Simulink-Modelle metro_S2.-, metro_S3.mdl sind in
[52] abgelegt.
Vorteil der Vorgehensweise: Die Anzahl der Blöcke hat sich gegenüber der Modellierung von
(4.25) reduziert. Algebraische Schleifen bezüglich der Trägheitskopplungen treten nicht auf. Im
Zusammenhang mit der Subsystem-Technik nach Abschn. 4.3.5.2 sowie Abschn. 4.3.5.3 und der
folgenden Betrachtung lassen sich Systeme höherer Ordnung mit vertretbarem Aufwand erstel-
len.
4.6.1 Simulationsergebnisse, selbsterregte Schwingungen und Mitnahme-Effekte

Aufgrund des Momentes α − β ϕ 2 ϕ̇ in (4.31) wird Zu- und Abfuhr von Energie in den Phasen

α α
ϕ < Anfachung, ϕ > Dämpfung (4.34)
β β
durch die Schwingung des Systems selbst gesteuert. Bezüglich des Schwingungsverhaltens wol-
len wir die freien Schwingungen q = 0 und die erzwungenen Schwingungen mit q
= 0 für eine
Analyse unterscheiden.
Aufgrund des Verhältnisses von Dämpfung zur Anfachung in einem Schwingungszyklus
kommt es zu periodischen, selbsterregten Schwingungen. In der Phasenebene (ϕ̇(ϕ)) stellen
sie eine geschlossene Kurve, den Grenzzykel, dar, vgl. Bild 5.6. Für einen in metro_S1.mdl
[52] vorgegebenen Parametersatz kann der Grenzzykel für austauschbare Anfangswerte als Ein-
schwingvorgang berechnet werden. Gleichzeitig wird von einer FFT-Analyse des Schwingungs-
signals – a) mit dem Power Spectral Density Block aus Simulink Extras/Additional Sinks,
b) mit einer, unter File/Model Properties/Callbacks/StopFcn programmierten
FFT-Analyse mit grafischer Ausgabe – das Frequenzspektrum dargestellt. Hieraus lässt sich die
Selbsterregerfrequenz fs ablesen.
Bild 4.40: Gegenüberstellung von Anregung fe (Ω ) = q sin (Ωt + Φ) und Schwingung ϕ(t)
Darüber hinaus ist bekannt [58], dass, wenn die Erregerkreisfrequenz Ω in der Größenord-
nung der Selbsterregerkreisfrequenz ωs = 2π fs liegt, so genannte Mitnahme-Effekte oder auch
Zieh-Erscheinungen auftreten können. Die Abweichung von der Selbsterregerfrequenz kann um
so größer sein je stärker die Erregung q ist. Dieses Schwingungsphänomen ist u. a. in metro_S1
[52] ausführlich herausgearbeitet. Die Ergebnisse sollen kurz dargestellt werden. Die sich ein-
stellende Selbsterregungsfrequenz liegt bei fs = 1,83 Hz bzw. ωs = 11,5 rad/s. In Bild 4.40
sind für die Erregerkreisfrequenzen Ω ≈ 14,4 rad/s und Ω ≈ 23 rad/s die zugehörigen Anre-
gungen und die zugehörigen erzwungenen Schwingungen ϕ(t) dargestellt. Es ist deutlich zu
erkennen, dass nach einer kurzen Einschwingphase für Ω = 14,4 rad/s die Periodendauer, d. h.
die Frequenz, übereinstimmt. Die selbsterregte Schwingung wird frequenzmäßig von der Erre-
gung mitgenommen. Für Ω ≈ 23 rad/s ist dies nicht der Fall – bei größerem Zeitintervall sind
Schwebungen erkennbar. Die Frequenzspektren in Bild 4.41 belegen für die Erregerfrequenzen
Ω ≈ 2,88 / 14,4 / 17,25 / 23 rad/s dieses Ergebnis. Die Frequenzen der gekennzeichneten Piks
stimmen mit Ω überein. In Abschn. 5.7.4 wird gezeigt, wie man periodische Schwingungen di-
rekt aus einem Randwertproblem unter MATLAB ermittelt.
Bild 4.41: Frequenzspektren zum Mitnahme-Effekt
Typische Beispiele selbsterregter Schwingungen, siehe auch [58]: elektrische Klingel mit
Klöppel, Uhr mit Unruhe, Musikinstrumente (Violine, Mundharmonika, Klarinette...), Brems-
quietschen, Flattern von Kraftwagenrädern, gleitgelagerte Turbo-Rotoren, elektrische Schwing-
kreise, Regelungskreise und durch Wind angeregte Hochspannungsleitungen, Lichtmasten, Fa-
brikschornsteine usw.
4.6.2 Nichtlineare Gleichungen höherer Ordnung
Im vorangegangenen Beispiel des Einzelpendels konnte die Modellierung insbesondere durch die
eingeführte Massenmatrix vereinfacht werden. Bei Systemen mit mehreren Freiheitsgraden muss
man versuchen, auch die Vektorfunktion f in (4.33) zu vektorisieren. Um einerseits dies und an-
dererseits das Schwingungsphänomen der Synchronisierung in selbsterregungsfähigen Systemen
zu zeigen, soll das Einzelpendel auf fünf einschließlich der Quader, wie in Bild 4.42 dargestellt,
ergänzt werden. Unter http://www.stumbleupon.com/su/AeBCLu wird diesbezüglich
ein Experiment mit fünf Metronome (Taktgeber in der Musik) auf einem frei beweglichen Brett
gezeigt.
Bild 4.42: Fünf-Pendelsystem, MATLAB Grafik
Die Bewegungsgleichungen können wir durch Verallgemeinerung von (4.25) bzw. (4.31) er-
reichen, wenn wir die Pendelwinkel vektorisieren und eine Abkürzung
T
ϕ = [ ϕ1 , ϕ2 , ...., ϕ5 ]T , ϕ 2 := ϕ̇12 , ϕ̇22 , ...., ϕ̇52
ϕ̇ (4.35)
einführen (MATLAB: Punkt-Operation anwenden, ϕ̇ ϕ 2 := ϕ̇

ϕ . ∗ ϕ̇
ϕ ). Schreiben wir noch für die
ϕ , ϕ̇
Selbsterregerfunktion m s (ϕ ϕ ), dann lauten die Bewegungsgleichungen
1 g 1
ϕ +
ϕ̈ cos ϕ ẍ = − sin ϕ + ϕ , ϕ̇
m s (ϕ ϕ)
L L mL2
(4.36)
1 M + 5m 1 q
cos (ϕ ϕ +
ϕ T ) ϕ̈ 2
ẍ = sin (ϕ ϕ2 +
ϕ T ) ϕ̇ sin (Ωt + Φ)
L mL L mL2
T
oder kurz mit y = [ϕ1 , ϕ2 , ..., ϕ5 , x]T = ϕ T , x
⎡ g 1 ⎤ ⎡ ⎤
− sin ϕ + m s ϕ
(ϕ , ϕ
ϕ̇ ) 0
⎢ L mL 2 ⎥ ⎣
M ÿy = ⎣ ⎦+ q ⎦ sin (Ωt + Φ) (4.37)
1
ϕ T
ϕ
sin (ϕ ) ϕ̇ 2
mL2
L
⎡ ⎤
⎡ 1 ⎤ 1 0 0 0 0 c1
E 5×5 ϕ)
cos (ϕ ⎢ 0 1 0 0 0 c ⎥
⎢ L ⎥ ⎢ 2 ⎥
ϕ) = ⎢
M (ϕ ⎣
⎥ = ⎢ ....................................
⎦ ⎢
⎥ (4.38)
⎥
1 M + 5m ⎣ 0 0 0 0 1 c5 ⎦
ϕ T)
cos (ϕ
L mL2 c1 c2 c3 c4 c5 (M + 5m)/(mL2 )
wobei ci = 1/L cos ϕi , i = 1,2, ...,5. Ein Vergleich mit (4.31) nach Division durch mL2 zeigt,
dass sich die Struktur nicht geändert hat und sich somit der Modellierungsaufwand für (4.37)
gegenüber (4.31) nicht wesentlich ändert, vgl. metro_S4.mdl in [52].
Gegenüber der mehr theoretischen Selbsterregerfunktion

ms j (ϕ j , ϕ̇ j ) = α − β ϕ 2j ϕ̇ j (4.39)
soll eine zweite unstetige Funktion, wie bei einer Pendeluhr mit G RAHAM-Gang5 aus Gangrad
mit sägeförmigen Zähnen und Anker eingeführt werden. Das Gangrad wird von einer Feder
angetrieben, der Anker ist mit dem Pendel verbunden. Durch den Eingriff der Ankerklauen in
die Zähne des Gangrades wird bereichsweise eine Kraft ausgeübt und somit ein Moment M
(Annahme: konstant) auf das Pendel übertragen, so dass für das j-te Pendel6
⎧
⎪
⎪ ϕ̇ j > 0 : −q j1 < ϕ j < +q j2 → ms j = +M − aϕ̇ j
⎨
ϕ̇ j < 0 : −q j2 < ϕ j < +q j1 → ms j = −M − aϕ̇ j
ms j (ϕ j , ϕ̇ j ) = (4.40)
⎪
⎪ ϕ̇ j > 0 : ϕ j < −q j1 oder ϕ j > +q j2 → ms j = −aϕ̇ j
⎩
ϕ̇ j < 0 : ϕ j < −q j2 oder ϕ j > +q j1 → ms j = −aϕ̇ j
mit den Schaltwinkeln q jk und dem Dämpfungsmoment aϕ̇ j gilt. Beide Gleichungen (4.39),
(4.40) lassen sich, wie in metro_S4.mdl gezeigt, vektorisieren, so dass sie in (4.37) eingebun-
den werden können.
Eine MATLAB-Script-Version mit (4.39) ist zusätzlich in [52] abgelegt.
Ergebnisse: Ausgehend von unterschiedlichen Anfangswerten der Pendel werden zunächst die
freien Schwingungen (q = 0) mit (4.39) betrachtet. Wie in Bild 4.43 zu erkennen, synchronisieren
sich die Schwingungen nach kurzer Einschwingphase. Bekanntes Beispiel ist das Musizieren
Bild 4.43: Synchronisation der Pendelwinkel ϕi
eines großen Orchesters. Auf Selbsterregung basierende Instrumente – Streich-, Blasinstrumente

– können bei leichter Verstimmung synchronisiert werden, so dass ein sauberer Ton erzeugt wird.
Durch experimentieren mit den Anfangswerten der Pendel, kann auch erreicht werden, dass
Gruppen (z. B. 2 und 3 Pendel) synchronisiert werden, sie schwingen phasenverschoben. Weitere
Ergebnisse werden in Abschn. 5.7.4 präsentiert.
Bei den erzwungenen Schwingungen q
= 0 mit einer Erregerkreisfrequenz Ω in der Nachbar-
schaft der Selbsterregerfrequenz treten wieder Mitnahme-Effekte auf, d. h. der ganze Verband
schwingt synchron mit Ω . Dies ist in metro_S4.mdl vorbereitet und wird in einer Animation
durch das Modell wie in Bild 4.42 veranschaulicht. Simulation mit (4.40) liefern vergleichbare
Ergebnisse.
5 http://www.uhrmachermeister.de/technik/graham.shtml
6 Kauderer, H.: Nichtlineare Mechanik, Springer, 1958
4.7 Modellierung mit Hilfe einer S-Function

Mit Hilfe eines S-Function-Blocks aus der Sublibrary User-Defined Functions können mit S-
Functions7 z. B. eigene Programmcodes in den Programmiersprachen:
• MATLAB M-File, Level-1, Level-2 Standard ab Simulink 6 (R14)
• C, C++ compiliert als Mex-File (Aufruf: mex File_name.c)
• FORTRAN compiliert als Mex-File
• ADA compiliert als Mex-File
in ein Simulink-Modell eingebunden werden. Die Arbeitsweise der S-Function ist festgeschrie-
ben. Der S-Function-Block genügt der Blockstruktur aus Abschn. 4.1.1. Die Partitionen des Zu-
standsvektors x nach (4.1) sind der zeitkontinuierliche Vektor x c und der zeitdiskrete x dk . Blöcke
ohne Zustände enthalten stattdessen den Leer-Vektor x = [ ]. D. h. zeitkontinuierliche, zeitdis-
krete und hybride Systeme können bearbeitet werden. Dem Benutzer sind somit kaum Grenzen
gesetzt. Es lassen sich u. a.
• eigene Blocksets erzeugen – prüfe Möglichkeit des MATLAB Function Blocks
• Codes anderer Programmiersprachen einbinden
• umfangreiche gleichungsorientierte Modellierung formulieren
• Implementierung von Treiber, z. B. zur Ansteuerung von AD-Wandlern einer angeschlosse-
nen Hardware
• grafische Animation ausführen, siehe Demo: penddemo.mdl, S-Functions pendan.m
für ein inverses Pendel und lissaj.mdl mit s_lissaj.m, s_lissaj_ani.m in [52]
für eine einfachste Animation von L ISSAJOUS-Figuren.
S-Functions basieren auf einer speziellen Syntax, wodurch ein strenger Bezug zu den Simulink-
Gleichungslösern geschaffen wird. In der Sublibrary User-Defined Functions im Block S-Func-
tion Examples sind Beispiele und Templates aller zulässiger Programmiersprachen enthalten, u. a.
die Templates
sfuntmpl.m (Level-1 M-File), msfuntmpl.m, msfuntmpl_basic.m (Level-2 M-File)
sfuntmpl_basic.c, sfuntmp_doc.c (Level-2 C-File)
siehe auch:
$MATLABPATH/toolbox/simulink/blocks8 , $MATLABPATH/simulink/src
$MATLABPATH/toolbox/simulink/simdemos/simfeatures/src
Für eigene Anwendungen sollten diese Templates herangezogen werden, alle Schritte und
Größen sind dokumentiert. Insbesondere enthält sfuntmpl_doc.c ausführliche Erläuterun-
gen, die auf Level-2 M-File S-Functions übertragbar sind. Darüber hinaus kann man sich an den
Demo-Beispielen unterschiedlichster Probleme gut orientieren.
4.7.1 M-File S-Function

Eine M-File S-Function kann einerseits mit der älteren Level-1 und andererseits mit der aktuellen
Level-2 Syntax erstellt werden. Im Gegensatz zur Level-2 sind in der Level-1 Syntax die Mög-
lichkeiten der maßgeschneiderten Blockerstellung gegenüber den Blöcken der Simulink-Library
eingeschränkt.
7 http://www.mathworks.de/help/pdf_doc/allpdf.html, Simulink-Handbuch
8 $MATLABPATH: MATLAB-Pfad
4.7 Modellierung mit Hilfe einer S-Function 215
Für jede Methode existiert in der Sub-Library: User-Defined Functions ein eigener S-Function
Block (Name: system bzw. matlablfile). In der zugehörigen Dialog-Box ist der Name der zu
erstellenden S-Function sowie zusätzliche Eingangsparameter p j , die durch Komma voneinander
zu trennen sind, einzutragen. Bild 4.44 zeigt die Box für den Level-2 Standard.
Bild 4.44: Level-2 M-File S-Function-Block mit Dialog-Box
Die M-Files bestehen jeweils aus einer Haupt-Function und mehreren Sub-Functions, die ei-
nerseits indirekt über ein flag und andererseits direkt über Function-Aufrufe (Callback-Methode)
von Simulink aufgerufen werden. Dies reicht von der Initialisierung bis zur Berechnung der Aus-
gabedaten.
4.7.1.1 Level-1 Standard

In einer Level-1 M-File S-Function steuert Simulink den Ablauf mit einem flag-Parameter, der
an die S-Function übergeben wird. Das flag markiert die Simulationsphase, d. h. die S-Function
muss festgeschriebene Sub-Function für zugeordnete flag-Werte enthalten. In Tabelle 4.3 sind
einige Functions sowie die flag-Werte angegeben.
Tabelle 4.3: Simulations-Phasen im Level-1 Standard
Simulationsphase Function flag

Initialisierung mdlInitializeSizes 0
Ermittlung der Ableitungen mdlDerivatives 1
Update des zeitdiskreten Zustandes mdlUpdate 2
Ermittlung der Ausgabe mdlOutputs 3
Ermittlung des nächsten Abtastzustandes mdlGetTimeOfNextVarHit 4
Ende des Simulations-Task mdlTerminate 9
Die S-Function sf_carm.m aus [52] verdeutlicht anhand des Zustandsmodells zum 1/4-
Fahrzeugmodell ohne/mit Reibung aus Abschn. 4.4.1 den S-Function-Aufbau. Zunächst aber
noch einige Einzelheiten. Der Function-Kopf einer Level-1 S-Function hat folgende Struktur:
function [sys,x0,str,ts]=File_name(t,x,u,flag,p1,p2,· · ·)
Mit den Eingangsparametern der Zeit t, dem Zustandsvektor x, der Block-Eingangsgröße u,
dem Steuerflag flag sowie den optionalen User-Parametern p1, p2,... Die wesentlichen
Ausgangswerte sind: der flag-abhängige Vektor sys u. a. der Ableitungs- und Ausgangsgrößen,
der Anfangswert x0 und die m×2-Matrix der m Abtastzeitinformation, z. B. [0 0] für eine
zeitkontinuierliche Abtastung, str ist leer [ ]. Auf die Begriffe in der Initialisierungsfunction
wollen wir kurz eingehen.
Initialisierungsfunction
Der Initialisierungsteil in mdlInitializeSizes, vgl. auch Tabelle 4.4 und Beispiel-Pro-
gramm sf_carm.m, enthält neben den Dimensionierungen
sizes.NumcontStates Anzahl der zeitkontinuierlichen Zustandsvariablen
sizes.Num.DiscStates Anzahl der zeitdiskreten Zustandsvariablen
sizes.NumOutputs Anzahl der Ausgänge
sizes.NumInputs Anzahl der Eingänge
weitere Festschreibungen, von denen wir die Begriffe:
• Direct feedhrough
• Dynamically sized inputs
• Setting sample times and offsets
stichwortartig erläutern wollen.

Direct Feedthrough: Der Ausgang oder die variable Abtastzeit hängen explizit vom Eingang u ab,
d. h.
- die Ausgangsfunktion (mdlOutputs, flag=3) sei eine Funktion vom Eingang u. Beispiel
ist die bekannte Messgleichung aus der Regelungstechnik: y = Cx +Du
Du sprungfähiger Sys-
teme, vgl. auch Beispiel 4.2.
- bei veränderlicher Abtastung (Aufruf: mdlGetTimeOfNextVarHit, flag=4), wenn in
der Berechnung zum nächsten Schritt u eingeht; vgl. Demos: vsfunc.m, dsfunc.m.
Dynamical Sized Inputs: S-Functions können für veränderliche Dimensionen des Eingangsvektors
u geschrieben werden. In diesem Fall ist sizes.NumInputs mit −1 zu vereinbaren.
Setting Sample Times and Offsets: Die Information ist in einer m×2-Matrix bei m Abtastzeiten in
festgeschriebener Reihenfolge einzugeben, siehe Template sfuntmpl.m:
ts = [ 0 0, % zeitkontinuierlich, variable Schrittweite
0 1, % zeitkontinuierlich, konstante Schrittweite
period offset, % diskrete Abtastzeit mit period>0, offset<period
-2 0 ] % variable diskrete Abtastzeit; flag=4!
Wird die Abtastzeit vom treibenden Block übernommen (geerbte Abtastzeit, inherited sample
time), dann ist NumSampleTime = 1 und ts = [-1 0] zu setzen, vgl. Beispiel 4.2.
Die Initialisierungsdaten werden durch den Aufruf
sizes = simsizes
sechs Initialisierungsdaten nach Tabelle 4.4
sys = simsizes(sizes)
im Vektor sys gespeichert und im flag=0 Schritt an Simulink übergeben.
Tabelle 4.4: Felder der Structure sizes
Feld-Name Beschreibung
sizes.NumcontStates Anzahl der zeitkontinuierlichen Zustände
sizes.Num.DiscStates Anzahl der zeitdiskreten Zustände
sizes.NumOutputs Anzahl der Ausgänge
sizes.NumInputs Anzahl der Eingänge
sizes.DirFeedthrough flag für ’direkten Durchgang’
sizes.NumSampleTimes Anzahl der Abtastzeiten
Beispiel einer M-File S-Function und das Simulink-Modell

Das Zustandsmodell des 1/4-Fahrzeuges aus Abschn. 4.4.1 ohne/mit Reibung wollen wir zu-
nächst mit Hilfe einer Level-1 M-File S-Function sf_carm.m formulieren. Dabei liegt (4.10)
für das System ohne Reibung mit A , B , C nach (4.11), (4.12), (4.13) und der Rampenauffahrt
u = xs (4.4) als Eingangsgröße zugrunde. Bei Berücksichtigung der Reibung gilt die Eingangs-
matrix B mit der Eingangsgröße ũu nach (4.16). C ist die Einheitsmatrix. Die stückweise lineare
Reibkennlinie sei die aus Abschn. 4.4.5.2 (4.21) mit s0 = 1, vgl. Bild 4.24
%
FC v10 vrel −v0 ≤ vrel ≤ v0 vrel = x3 − x4
F= , für , (4.41)
FC sign(vrel ) |vrel | > v0
d. h. wir integrieren über die Unstetigkeit hinweg. Sollte die Integration Probleme bereiten, so
kann diese Unstetigkeit auch nach [11] durch Ausrunden der Anstückelpunkte vermieden wer-
den.
Alle Parameter, Systemmatrizen und Eingänge können einerseits innerhalb der S-Function
berechnet werden, wobei darauf zu achten ist, dass dies nur einmal während der Simulation er-
folgen soll, z. B. in der Initialisierungsphase zu flag=0. Andererseits könnten wir sie vor dem
Simulationsstart mittels Datenfile in den Workspace schreiben und dann mit dem Eintrag in die
Parameter-Dialog Box, vgl. Bild 4.44, in die S-Function einbringen. Der S-Function-Aufruf ent-
hält diese Parameterliste nach dem flag:
function [sys,x0,str,ts] = sf_carm(t,x,u,flag,A,B,C,D)
Hier erstellen wir die Systemmatrizen in der Function syspa.m, die wir an die S-Function
sf_carm.m aus [52] anhängen. Über den Eingangsparameter iflag = 0 / 1 sprechen wir das
reibungsfreie / reibungsbehaftete System an. iflag muss in der Parameter-Dialog Box als sym-
bolischer oder numerischer Wert stehen; im ersten Fall muss der numerische Wert im Workspace
bekannt sein. Die Daten-Function syspa.m entspricht dem M-File sim_v13D.m aus [52].
Da es sich um ein zeitkontinuierliches System handelt, werden nur die Function mdlIniti-
alizeSizes, mdlDerivatives, mdlOutputs aufgerufen, die restlichen werden nicht be-
nötigt, siehe sf_carm.m in [52].
Das zugehörige Simulink-Modell sim_v16m.mdl aus [52] ist in Bild 4.45 wiedergegeben.
4.7.1.2 Level-2 Standard

Der Level-2 Standard ist gegenüber dem Level-1 Standard erweitert und neu strukturiert und mit
dem C Mex-File Standard (Level-2) vergleichbar. Die Haupt-Function, z. B.
Bild 4.45: Simulink-Modell mit S-Function-Block für die Zustandsgleichungen
function function_name(block) % Function-Kopf

setup(block) % Function-Aufruf
enthält im Kopf den gewünschten Namen sowie die Function setup u. a. zur Initialisierung:
• Anzahl der Ein- und Ausgänge (Ports)

• Setzen der Attribute: Dimension, Datentyp, Komplexität und Abtastzeit dieser Ports
• Anzahl der Parameter in der Dialog-Box
• Auflistung aller benötigten Handles für weitere lokale Functions der S-Function innerhalb
des RegBlockMethod Aufrufs, z. B.
allgemein: block.RegBlockMethod(’Methode’,@zugehoerigerHandle)
speziell: block.RegBlockMethod(’CheckParameters’,@CheckPrms)
Die Sub-Function CheckPrms ist lokale Function zur Überprüfung der übernommenen
Dialog-Box-Parameter.
Einen Überblick soll die Level-2 M-File S-Function sf_car2m.m zum 1/4-Fahrzeug ohne/mit
Reibung vermitteln, wobei die Handhabung des Parameters iflag und der Systemgrößen ge-
genüber der Level-1 Vorgehensweise unverändert bleibt. Es soll hier die verkürzte Function
sf_car2m.m abgedruckt werden. In [52] sind zusätzliche Optionen nachzulesen:
Level-2 M-File S-Function:
function sf_car2m(block) % Haupt-Function
setup(block);
%%endfunction sf_car2m
function setup(block) % Initialisierung

global A B C v0 % Param.-Übergabe
[A,B,C,v0] = syspa(block.DialogPrm(1).Data); % Systemgrößen
% ---- Setzen der Block-Eigenschaften

% Anzahl der Block-Ein- und -Ausgänge
block.NumInputPorts = 1; % ein Eingang
block.NumOutputPorts = 1; % ein Ausgang
% Port-Eigensch. (Datentyp, Komplexität usw.) dynamisch bezogen

block.SetPreCompInpPortInfoToDynamic;
block.SetPreCompOutPortInfoToDynamic;
% Portdimension und Eigenschaft

block.InputPort(1).Dimensions = 1; % Dimension, Eing.-Vekt.
block.OutputPort(1).Dimensions = size(C,1); % Dimension, Ausg.-Vekt.
% Anzahl der übergebenen Parameter; stehen in der Parameter-Dialogbox

block.NumDialogPrms = 1; % 1*: iflag, Steuergröße
% Abtastzeit und Offset --> hier zeitkontinuierliche Rechnung

block.SampleTimes = [0 0]; % vgl. msfuntmpl.m
% Anzahl der zeitkontinuierlichen Zustände

block.NumContStates = size(A,1);
% ---- Ende Block-Eigenschaften
% Benötigte Routinen in dieser S-Function, lokale Functions

block.RegBlockMethod(’CheckParameters’,@CheckPrms);
block.RegBlockMethod(’InitializeConditions’,@InitializeConditions);
block.RegBlockMethod(’Outputs’, @Outputs);
block.RegBlockMethod(’Derivatives’, @Derivatives);
%%endfunction setup
%% lokale Functions
% Überprüfung des übergebenen Parameters iflag

function CheckPrms(block)
if block.DialogPrm(1).Data ~=0 && block.DialogPrm(1).Data ~=1
error(’Fehler im Steuerparameter iflag: 0 ohne, 1 mit Reibung!’);
end
%%endfunction CheckPrms
function InitializeConditions(block)
global A % Parameterübergabe
% Setzen der Anfangswerte der Zustandsgrößen
block.ContStates.Data = zeros(size(A,1),1);
%%endfunction InitializeConditions
function Outputs(block)
global C % Parameterübergabe
% Systemausgang berechnen: y = C*x + D*u, hier: D = 0, so dass: y = C*x
%x = block.ContStates.Data;
block.OutputPort(1).Data = C * block.ContStates.Data; % = C * x
%%endfunction Outputs
% Zustandsableitung: x’: --> x’ = A*x+B*u_ges

function Derivatives(block)
global A B v0 % Parameterübergabe
x = block.ContStates.Data; % Zustandsvektor
u=block.InputPort(1).Data; % Eingangsgröße
if block.DialogPrm(1).Data == 1 % Steuerung: mit R.
vrel=x(3)-x(4); % Relativgeschw.
if abs(vrel) < v0 % Haft- / Gleitreibung
reib=vrel/v0; % Haftreibung
else
reib=sign(vrel); % Gleitreibung
end
block.Derivatives.Data = A*x + B*[u; reib]; % System mit Reibung
else
block.Derivatives.Data = A*x + B*u; % System ohne Reibung
end
%%endfunction Derivatives
%--------------------------------------------------------------------
function [A,B,C,v0] = syspa(iflag) % siehe Programmsammlung
.... unvollständig .....
Das zugehörige Simulink-Modell sim_v16_2m.mdl ist in [52] zu finden. In der S-Function

sf_car2m.m aus [52] sind weitere Optionen zum Direct Feedthrough, zum Überschreiben der
Porteigenschaften, zur Kontrolle der Parameter sowie zur Erstellung eines TLC (Target Language
Compiler)-Files eingearbeitet.
Abschließend geben wir noch zwei Beispiele zur Level-2 Version an, die Level-1 Version ist
in [52] zu finden.
Beispiel 4.2: Parameteränderung in einem Simulink-Block

Eine Sinusschwingung (Sine Wave-Generator) mit der Schwingungsdauer von T =
2π/5 s soll während der Simulation alle π Sekunden ihre Amplitude umschalten.
D. h. ausgehend von der Amplitude 1 soll nach π Sekunden eine Änderung auf 5
nach weiteren π Sekunden wieder auf 1 erfolgen usw. Die Umschaltzeitpunkte sind
durch ein Rechtecksignal (Signal Generator) zu erzeugen. Es liegt also ein Block-
Parameterwechsel infolge eines Ausgangswertes eines anderen Blocks vor.
Dieses Problem ist jeweils mit einer Level-1, Level-2 M-File S-Function unter Ver-
wendung des Befehls set_param, vgl. help/doc set_param, zu lösen.
Syntax zum set_param Befehl
set_param(’meinModell/Block’,’BlockParameter’,’neuerWert’)
Lösung: Das Eingangssignal u – Ausgang des (Signal Generator) Blocks – steuert
über den set_param Befehl die Amplitude des Sine Wave Blocks in der S-Function
sinfunc.m bzw. sinfunc2.m des Modells sim_sinfunc.mdl bzw.
sim_sinfunc2.mdl, vgl Bild 4.46 a. Wir geben hier nur die Ausgabe-Function
der Level-2 M-File S-Funktion sinfunc2.m an, die vollständigen Files stehen in
[52]:
%% Berechnung und Ausgabe
function Output(block)
% -- Amplitude des Signal-Generators abfragen
am=str2num(...
get_param(’sim_sinfunc2/Signal Generator’,’Amplitude’));
% -- mit Eingang vergleichen, nur sinnvoll für Rechtecksignal
if abs(block.InputPort(1).Data - am) < eps(am);
set_param(’sim_sinfunc2/Sine Wave’,’Amplitude’,’5’)
else
set_param(’sim_sinfunc2/Sine Wave’,’Amplitude’,’1’)
end
Durch die Abfrage (get_parm) der Rechtecksignal-Amplitude ist jede Amplitude

zulässig. Die Zeitverläufe der Steuerfunktion (Rechteck) sowie der geschaltete Sinus-
Verlauf sind in Bild 4.46 b dargestellt.
a: Simulink-Modell b: Funktionsverläufe
Bild 4.46: Beispiel zur Parameterumschaltung in Funktionsblöcken
Beispiel 4.3: Animation von L ISSAJOUS-Figuren unter Simulink

Zur Erzeugung und zur Animation von L ISSAJOUS-Figuren
x = R sin(2t + Φ); y = R sin(3t)
in der x, y-Ebene eines kartesischen Koordinatensystems sind zwei separate Level-2

M-File S-Function (s_lissaj.m, s_lissaj_ani.m) sowie das zugehörige Simu-
link-Modell lissaj.mdl in [52] angegeben. In s_lissaj wird die obige Glei-
chung ausgewertet. Die Zeit t ist der Eingang, am Ausgang liegt der Vektor [x, y]T
an. Die Parameter R, Φ stehen in der Parameter-Dialog-Box. In s_lissaj_ani ist
die Animation der Kurve programmiert, wobei die Parameter aus der Dialog-Box der
ersten S-Function, u. a. R zur Skalierung, übernommen werden.
4.7.2 C Mex-File S-Function
4.7.2.1 S-Function Builder
Der S-Function Builder unterstützt die (automatische) Erstellung von C Mex-File S-Functions
sowie die von C Quell-Codes. 1-D und 2-D Signale und Ausgänge sind zulässig. Die Datentypen
entsprechen denen von Simulink.
Zur Modellierung dient der abgebildete S-Function Builder Block aus

der Sublibrary: User-Defined Functions. Mit einem Doppel-Mausklick
der linken Taste auf das Block-Icon (oder Klick mit rechter Maustaste
→ Open Block) öffnet sich die S-Function Builder Dialog-Box mit der
sich die S-Function für den Block erstellen lässt.
Bild 4.47: Builder Dialog-Box
Wie die in Bild 4.47 abgebildete Dialog-Box zeigt, ist sie in Seiten unterteilt, in die die Infor-
mationen zur Erstellung der S-Function einzutragen sind. Im Einzelnen sind dies:
• Initialization (Initialisierung): Anzahl der (zeit-) kontinuierlichen und/oder diskreten Zu-

stände, die zugehörigen Anfangswerte und Informationen zur Abtastzeit (Sample Time).
• Data Properties (Daten-Eigenschaften): bezüglich der Dimension der Ein- und Ausgänge
(Input, Output Ports), der Parameter einschließlich der Datentypen. Die zugehörigen nume-
rischen Werte sind anschließend in den oberen Teil (S-function parameters) einzutragen.
• Libraries: Eintrag der benötigten Standard C Header-Files und externer Functions-Files.
• Outputs (Ausgänge): C-Code zur Berechnung der Ausgänge y0 (kontinuierlich, diskret),
z. B. y0[0]=u0[0] und in Bild 4.47.
• Continuous Derivatives (Ableitungsfunktionen, Dgl.) C Code der Differenzialgleichungen,
z. B. dx[0]=xC[0].
• Discrete Update: Aktualisieren der Abtastfolge, z. B. xD[0]=u0[0] – zeitdiskret.
• Build Info: Anwahl von Optionen zur Erstellung des S-Function Mex-Files (u. a. compilie-
ren) oder Speicherung des C Quell-Codes (Save code only aktivieren). Soll die S-Function
im Beschleunigungs-Mode (accelerated mode) ablaufen, dann ist ein TLC-File zu generie-
ren (wird nicht für die Simulink-Beschleunigung benötigt). Zum Compilieren muss ein/der
C-Compiler, siehe Abschn. 6.1, installiert sein! Dies geschieht mit
>> mex -setup
Die Übersetzung erfolgt mit dem Build(Save)-Button. Sind anschließend Systemparame-

ter aus dem Feld S-function parameters zu ändern, dann genügt nach der Änderung eine
Speicherung: Save code only aktivieren und Save(Build)-Button betätigen. Achtung: Die
eingetragenen Parameter müssen übernommen sein. Dies ist der Fall, wenn sie linksbündig
stehen.
Wichtig: Die eingeführten und im Builder angezeigten Bezeichnungen, u. a. für die Zustände
xC, xD und für die Ableitungen dx sind festgeschrieben. Alle weiteren Vereinbarungen sind
selbsterklärend.
Anhand des 1/4-Fahrzeuges ohne/mit approximierter Reibkennlinie aus Abschn. 4.4 mit den
um die Reibung erweiterten Zustandsgleichungen (4.9)
ẋ1 = x3
ẋ2 = x4
(4.42)
ẋ3 = − kA (x1 − x2 ) + dA (x3 − x4 ) + i f lag F /mA , i f lag = 0, 1

ẋ4 = kA (x1 − x2 ) + dA (x3 − x4 ) + kR (x2 − xS ) + i f lag F /mR
sowie der Reibkennlinie nach (4.41) kann die Erstellung der S-Function mit dem Builder nach-
vollzogen und damit experimentiert werden. Hierzu sind die beiden Modelle: sim_v16_Bc und
sim_v16_Bc1.mdl in [52] abgelegt. Sie unterscheiden sich in der Handhabung des Steuerpa-
rameters iflag für die Modellierung ohne/mit Reibung.
4.7.2.2 Einfache C Mex-File S-Function

Die Programmierung der S-Function in C ist weniger durchsichtig. In der Sublibrary User-De-
fined Function sind mit dem Block: S-Function Examples Templates und Demo-Beispiele zu öff-
nen. Es empfiehlt sich u. a. an das Template sfuntmpl_basic.c sowie an die zugehörigen
Details aus:
$MATLABPATH\simulink\src\sfuntmpl_doc.c
zu orientieren.
Wir können zur C Mex-File S-Function nur wenige grundlegende Bemerkungen machen.
Bei C Mex-File S-Function werden die Routinen von Simulink direkt aufgerufen; ein flag-
Parameter existiert nicht. Dies entspricht der Arbeitsweise der Level-2 M-File S-Function. C
Mex-File S-Function sind vor dem Start des Simulink-Modells mit dem Aufruf
mex File_name.c
zu compilieren und zu linken. Wegen der höheren Ausführungsgeschwindigkeit eines compilier-
ten Programmes gegenüber der Interpretermethode der M-File S-Function, empfiehlt sich diese
Vorgehensweise bei rechenintensiven Algorithmen.
Eine wichtige Anwendung von C Mex-File S-Function ist der Zugriff auf Hardware (z. B. AD-
Wandler), dieses ist in der Programmiersprache C üblicherweise problemlos. Außerdem können
bereits existierende Hardwaretreiber eingebunden werden.
In Anlehnung an die M-File S-Function sf_carm.m zeigen wir in der Programmsammlung
[52] den Quell-Code der C Mex-File S-Function sf_carc.c. Grundlage war das Demopro-
gramm stspace.c; es wurde lediglich auf den Eingabe-Check verzichtet. Im Gegensatz zu
sf_carm.m gehen wir in sf_carc.c für das Modell sim_v16c.mdl davon aus, dass die
System-Matrizen A , B , C , D über das Datenfile sim_v13D.m in den Workspace geschrieben
werden und somit in der Parameter-Dialog Box des S-Function Blocks aufgeführt sein müssen.

5 Simulation unter MATLAB
In diesem Kapitel soll die numerische Integration linearer und nichtlinearer Anfangswertpro-
bleme sowie die Lösung von Randwertproblemen gewöhnlicher Differenzialgleichungen unter
MATLAB behandelt werden, d. h. wir arbeiten skriptorientiert. Wesentlich ist die Aufbereitung
und Anpassung der Differenzialgleichungen/Bewegungsgleichungen an die Möglichkeiten der
Löser. Mögliche Simulink-Modelle werden diskutiert.
Alternativ können Randwertprobleme auch als Anfangswertprobleme formuliert werden und
mit dem Schießvefahren gelöst werden. Die Idee hierzu ist in schiess.pdf [52] nachzulesen.
Nicht behandelt werden Differenzialgleichungen mit Totzeit (Function: dde23, ddesd) und par-
tielle Differenzialgleichungen (Function: pdepe). Beispiele mit Code-Anzeige aller verfügbaren
Methoden können mit dem Aufruf von >> odeexamples aus dem Command Window einge-
sehen und durch die Online-Hilfe vertieft werden.
5.1 Struktur der Differenzialgleichungen
Wie in Abschn. 2.2 erläutert, unterscheiden wir prinzipiell zwischen einer impliziten
ḡg(ẋx, x , t) = 0 , ẋx(t0 ) = ẋx0 , x (t0 ) = x 0 , so dass ḡg(ẋx0 , x 0 , t0 ) = 0 (5.1)
sowie einer expliziten
ẋx = g (xx, t), x (t0 ) = x 0 (5.2)
Formulierung der Differenzialgleichung mit den Anfangswerten ẋx0 , x 0 zum Zeitpunkt t0 (meist
t0 = 0). Die Gleichungen (5.1), (5.2) sind gewöhnliche nichtlineare Differenzialgleichungen
(ODE1 ) n-ter Ordnung mit der unabhängigen Variablen t. Hängt ḡg bzw. g nicht explizit von
der Zeit ab, z. B. g(x)
g(x), dann sprechen wir von einer autonomen, im anderen Fall von einer nicht-
autonomen Bewegungsgleichung oder Differenzialgleichung.
In der Regel existieren für (5.1), (5.2) keine analytischen Lösungen, so dass auf Näherungen
u. a. per numerischer Integration zurückgegriffen werden muss. Hierzu gibt es eine Vielzahl von
Codes, die auf (5.1), (5.2) aufbauen und diese als Anfangswertprobleme lösen.
Bei mechanischen Modellen tritt die Beschleunigung q̈q linear auf, vgl. Kapitel 2, sie werden
deshalb durch Bewegungsgleichungen mit f Freiheitsgraden
M q̈q = f a (t, q , q̇q), q̇q(t0 ) = q̇q0 ; q (t0 ) = q 0 , (5.3)
wobei in q Lage- und/oder Winkelvariablen (Minimalkoordinaten) und in f a Kräfte und/oder Mo-

mente stehen, beschrieben. Die Massenmatrix in (5.3) kann sowohl zeit- und/oder lageabhängig
1 ODE Ordinary Differential Equation

DOI 10.1007/978-3-8348-8630-9_5,
226 5 Simulation unter MATLAB
M := M (t, q ) oder konstant sein. Gleichung (5.3) ist ebenfalls eine gewöhnliche nichtlineare Dif-
ferenzialgleichung 2 f -ter Ordnung. Setzen wir in (5.3) q̇q = v , dann folgt zunächst
E q̇q = v E = diag(1, 1, . . . , 1)
(5.4)
M v̇v = f a (t, q , v )
mit den Anfangswerten q (t0 ) = q 0 und v (t0 ) = v 0 zum Zeitpunkt t0 . Beide Gleichungen unter
(5.4) beschreiben das Anfangswertproblem in der Standardform oder expliziten Form nach (5.2)
mit dem Zustandsvektor x = (qqT , v T )T , wenn M invertierbar ist.
Die verfügbaren Integratoren in MATLAB sind mit odexx, z. B. ode45, gekennzeichnet. Sie
verarbeiten grundsätzlich (5.2). Das Gleichungssystem (5.4) in der Form
M ẋx = f (t, x ), M = diag(E

E , M ); x (t0 ) = x 0 (5.5)
lassen nahezu alle Codes zu, wobei M konstant, zeit- oder/und zustandsabhängig sein darf. Ist
M singulär, dann wird (5.5) als differenzial-algebraisches Gleichungssystem identifiziert und
bearbeitet; vgl. Abschn. 5.2.1.
Ab MATLAB 7 R14 ist mit ode15i die Integration impliziter Differenzialgleichungen (5.1) nun
möglich.
Wir verdeutlichen die Unterschiede der mathematischen Formulierungen an einem kleinen
Beispiel.
Beispiel 5.1: Strukturen der Differenzialgleichungen

Die Masse (m) ist mit einem Feder-Dämpfer-Element aus einer Reihenschaltung eines
K ELVIN -VOIGT-Modells mit einer Feder gegenüber der Umgebung abgestützt, vgl.
Abschn. 8.6. Gleichgewichtsbedingungen bezüglich der Masse m und des Knotens
zwischen Feder und nichtlinearem Feder-Dämpfer-Element liefern mit Bild 5.1 die
Bild 5.1: Einmassenschwinger mit nichtlinearem Feder-Dämpfer-Element
Bewegungsgleichungen der Vertikalschwingungen um x = 0, s = 0
mẍ + k(x − s) = −mg

(5.6)
fD (ṡ) + k0 s − k(x − s) = 0 ,
dabei werden x und s aus der Lage der entspannten Elemente gezählt. Dies ist ein
5.1 Struktur der Differenzialgleichungen 227
Differenzialgleichungssystem dritter Ordnung. Da nach Voraussetzung fD (ṡ) beliebig

nichtlinear in ṡ sein soll, gelingt es in der Regel nicht, (5.6) explizit nach ṡ aufzulösen.
Es liegt mit x = (x1 , x2 , x3 )T = (x, s, ẋ)T ein implizites Differenzialgleichungssystem
der Form (5.1)
ẋ1 − x3 =0
mẋ3 + k(x1 − x2 ) + mg = 0 (5.7)
fD (ṡ) + k0 x2 − k(x1 − x2 ) = 0
vor, wir behandeln es in Abschn. 5.5. Setzen wir speziell nach [66]
ṡ
fD (ṡ) = d0 ṡ + d ṡ |ṡ| , |ṡ| = , (5.8)
sign (ṡ)
dann folgt für d = 0 unmittelbar eine lineare explizite Differenzialgleichung. Berück-

sichtigen wir den quadratischen Term in (5.8), dann müssen wir die dritte Gleichung
von (5.7) zunächst nach ṡ auflösen. Hierzu lesen wir aus (5.8) die Vorzeichenaussage
sign (ṡ) = sign (k(x − s) − k0 s) ab. Damit folgt aus (5.7)3 mit (5.8) eine quadratische
Gleichung in ṡ, so dass
⎡ ' ⎤
+ 2
1
d0 d0
ṡ = ⎣− (−) + (x − s) − k0 s ⎦ sign (k(x − s) − k0 s) . (5.9)
2d 2d d
Nach Bild 5.2 gehört zum negativen Vorzeichen (−) die anfachende Kennlinie
fD (ṡ− ), die durch Spiegelung an der Ordinate aus der Dämpfungsfunktion fD (ṡ) her-
vorgeht, sie interessiert hier nicht. Somit sind (5.2)1 und (5.6) wieder ein System von
expliziter Form . Darüber hinaus erhalten wir mit dem Zustandsvektor x = (x, s, ẋ, ṡ)T
⎡ ⎤ ⎡ ⎤• ⎡ ⎤⎡ ⎤ ⎡ ⎤
1 0 0 0 x 0 0 1 0 x 0
⎢ 0 1 0 0 ⎥⎢ s ⎥ ⎢ 0 0 0 1 ⎥ ⎢ ⎥ ⎢ 0 ⎥
⎢ ⎥⎢ ⎥ ⎢ ⎥⎢ s ⎥=⎢ ⎥ (5.10)
⎣ 0 0 m 0 ⎦ ⎣ ẋ ⎦ + ⎣ k −k 0 0 ⎦ ⎣ ẋ ⎦ ⎣ −mg ⎦
0 0 0 0 ṡ −k k + k0 0 0 ṡ − fD (ṡ)
eine Gleichung mit singulärer Matrix M = diag(1,1, m,0), sie entspricht (5.5) und
kann als differenzial-algebraisches Gleichungssystem interpretiert und behandelt wer-
den. Die Index-Ermittlung erfolgt im Beispiel 5.7. Berücksichtigen wir zusätzlich die
Masse der Traverse in (A) zwischen Feder und Feder-Dämpfer-Element, dann ist M
in (5.10) regulär – das letzte Hauptdiagonalelement ist von null verschieden –, so dass
wir mit (MM )−1 durchmultiplizieren und somit eine explizite Differenzialgleichung
von Typ (5.2) erhalten.
Anhand dieses recht einfachen Beispiels wird klar, dass wir ein und dasselbe Problem mit unter-
schiedlichen Methoden bearbeiten können. So kann (5.6) einerseits als implizites (5.7) oder mit
(5.9) als explizites Differenzialgleichungssystem, andererseits mit (5.10) als differenzial-algebra-
isches Gleichungssystem gelöst werden. Welche Form man letztendlich wählt, hängt auch von
Bild 5.2: Dämpferkennlinie aus DAE_i.m mit LATEX-Beschriftung
den zur Verfügung stehenden Integratoren sowie deren Stabilität gegenüber den einzelnen Formu-
lierungen ab. Zur numerischen Auswertung von (5.7) und (5.10) greifen wir das Beispiel später
noch einmal auf.
Differenzialgleichungen übergeordneter Systeme, z. B. mechanische Modelle mit zusätzli-
chen elektrischen und/oder hydraulischen sowie elektromagnetischen Komponenten, sind (5.1)
bzw. (5.2) zuzuordnen.
5.1.1 Beispiele für eine explizite Formulierung

Die klassischen Integratoren (z. B. explizite RUNGE -K UTTA-Formeln) bauen auf der expliziten
Standardform (5.2) auf. Sie zeigen gutes Stabilitätsverhalten und werden somit heute bevor-
zugt eingesetzt. Die aufgestellte Bewegungsgleichung muss zunächst auf diese explizite Form
gebracht werden. Wir zeigen dies anhand einiger Beispiele.
5.1.1.1 Lineare mechanische, elektrische und regelungstechnische Systeme

In einem kurzen Überblick soll auf die Aufbereitung linearer Bewegungsgleichungen eingegan-
gen werden. Haben die Bewegungsgleichungen konstante Koeffizienten, dann ist es in der Regel
vorteilhafter, mit Hilfe der Methoden der linearen Algebra – Eigenwertprobleme, lineare alge-
braische Gleichungen usw. – diese Gleichungen zu lösen, wie in Kapitel 3, in einigen Projekten
von Kapitel 8, u. a. in Abschn. 8.2 sowie dem Beitrag zum Levitron-Kreisel aus [52].
Mechanische und elektrische Systeme
Im Allgemeinen lassen sich die Bewegungsgleichungen mechanischer Systeme mit f Freiheits-
graden auf folgende Struktur bringen:
M ÿy +P
P ẏy +Q
Q y = pp(t). (5.11)
Dabei dürfen M , P , Q zeitabhängig sein. Unter der Voraussetzung: M regulär, det(M

M )
= 0 folgt
mit der Inversen M −1
M −1P ẏy +M
ÿy +M M −1Q y = M −1 p (t) (5.12)
und für die Zustandsraumdarstellung mit den Abkürzungen
x1 = y , x 2 = ẏy

ẋx1 0 E x1 0
= + p (t) (5.13)
ẋx2 M −1Q −M
−M M −1P x2 M −1

Systemmatrix A
oder kurz
ẋx = A x + W p (t) . (5.14)
Diese Vorgehensweise ist nur für Systeme mit diagonaler Massenmatrix oder Systeme niedriger
Ordnung und bei einmaliger Invertierung von M zweckmäßig. M ist positiv definit und symme-
trisch (dies lässt sich immer erreichen), so dass man eine C HOLESKY-Zerlegung (Funct. chol) der
Massenmatrix durchführen und damit eine explizite Inversion umgehen kann. Dies ist genauer
und mit weniger Rechenaufwand verbunden und damit schneller. Insbesondere für zeitabhängige
Massenmatrizen M = M (t), aber auch bei nichtlinearen Systemen mit lageabhängigen Massen-
matrizen M (t, y ), z. B. in Robotersystemen, ist diese Vorgehensweise zu empfehlen, da bei jedem
Integrationsschritt die Inverse M −1 (t) z. B. innerhalb des Intervalls [tk−1 , tk ] mehrfach zu bilden
ist.
Beispiel 5.2: Elektrisches Netzwerk
Als Beispiel eines strukturdiskreten, elektischen Systems betrachten wir das Netzwerk
in Bild 5.3 mit den diskreten Elementen O HMscher Widerstand R, Induktivität L und
Kapazität C sowie der Spannungsquelle u(t). Die jeweiligen Spannungsabfälle seien
uR

R
u(t) L uL
C
uC
Bild 5.3: Elektrisches System
uR , uL und uC , so dass u(t) = uR + uL + uC und damit die Spannungsdifferenzialglei-

chung
$t
1
u(t) = Ri + L(i)˙ + i dt; i(0) = i0 (5.15)
C
gilt. Um eine explizite Form von (5.15) zu erhalten, können unterschiedliche Möglich-
keiten zur Elimination des Integrals eingeschlagen werden:
• Durch zeitliche Ableitung von (5.15) folgt

1
L(i)¨ + R(i)˙ + i = u̇(t) (5.16)
C
die Differenzialgleichung 2. Ordnung für i(t), wobei die Anfangswerte i(0) = i0 ;
(i)˙(0) = (i)˙0 aus (5.15) gelten. (5.16) ist noch auf Zustandsform zu bringen.
• DurchEinführen einer Abkürzung (hier physikalisch die elektrische Ladung)
Q = t idt erhalten wir das Differenzialgleichungssystem 2. Ordnung in der
Form
R 1 1
(i)˙+ i+ Q = u(t) (5.17)
L CL L
Q̇ − i = 0 mit i(0) = i0 , Q(0) = Q0 (5.18)
für das zeitliche Verhalten von i = i(t) und Q = Q(t).
Lineare regelungstechnische Systeme
Bild 5.4: Linearer Regelkreis
Einen allgemeinen Aufbau eines geregelten deterministischen Systems in Zustandsraumdar-

stellung zeigt Bild 5.4. Der homogene Teil der Strecke wird durch die Blöcke Systemmatrix A
und Integrator dargestellt. Der Ausgangsblock C liefert die Messwerte y M (t), die bei sprungfä-
higen Systemen mit der über die Durchgangsmatrix D gewichteten Stellgröße ergänzt werden.
Die Durchgangsmatrix ist für die meisten Systeme eine Nullmatrix. Das Stellgesetz wird mit
der Messgröße gebildet, der ein Messrauschen überlagert sein kann. Die Eingangsmatrix B be-
schreibt die Stellorte, die Störmatrix W z. B. die Eingriffsorte einer äußeren Störung. Weitere
Beeinflussungen, z. B. über ein Führungssignal, können berücksichtigt werden. Der skizzierte
Regelkreis ist bei einer Ausgangsvektorrückführung durch das mathematische Modell in Zu-
standsform
ẋx(t) = A x (t) + B u (t) + W s (t)

y M (t) = C x (t) + D u (t) (5.19)
u (t) = −K K A y M (t)
beschrieben.
Hat das System mehrere Ein- und Ausgangsgrößen, dann spricht man von einer Mehrgrößen-
regelung (MIMO), im anderen Fall von einer Eingrößenregelung (SISO). Ist die Systemmatrix A
konstant, dann lässt sich eine exakte Lösung angeben. Ist A = A (t), dann ist dies in der Regel nicht
der Fall, wir sind auf eine dynamische Simulation mittels numerischer Integration angewiesen.
Für die Analyse linearer zeitinvarianter Systeme (LTI-Systeme) der Typen (SISO) und (MIMO)
stellt MATLAB mit der Control System Toolbox einige Functions bereit. Wir beschränken uns auf
die einer Zustandsraumdarstellung (State-Space, SS). In diesem Fall erzeugt MATLAB zunächst
ein Zustandsmodell, z. B. sys, mit
sys = ss(A,B,C,D).
Damit lassen sich beispielhaft folgende Antworten berechnen:
Anfangswertantwort initial(sys,x0,te)
Impulsantwort impulse(sys,te)
Sprungantwort step(sys,te)
Systemantwort auf beliebiges Eingangssignal lsim(sys,u,te,x0)
mit dem Anfangswertvektor x0, der beliebigen Eingangssignalmatrix u, dem Endzeitpunkt te.
Weitere Optionen sind möglich; vgl. Online-Hilfe.
Die Algorithmen basieren auf dem zugehörigen Lösungsansatz für lineare zeitinvariante Dif-
ferenzialgleichungen, wie in Kapitel 3.
Beispiel 5.3: Simulation eines Regelkreises

Für den in Bild 5.5 skizzierten Schwinger mit zwei Freiheitsgraden sollen die Be-
wegungsgleichungen aufgestellt und in eine explizite Form zur Simulation gebracht
werden. Die Masse m1 wird durch eine äußere Kraft q cos Ωt angeregt. Über den Stell-
zylinder an der Masse m2 wird die Stellkraft
$
u(t) = −k p y(t)M − kI yM (t) dt, Messgröße yM = y1
aus Proportional- und Integralanteil aufgebracht. Die Lage der Masse m1 liefert ein
Sensor. Damit liegt ein Eingrößensystem (SISO) vor. Die Bewegungsgleichung hat
die Form
M ÿy + D ẏy + K y = b u(t) + w cos Ωt

yM = c y ,
T
mit dem Lagevektor
y T = [y1 , y2 ]
Bild 5.5: Zweimassen-Schwinger als Regelstrecke
und seinen zeitlichen Ableitungen ẏy, ÿy, der Massenmatrix, der Dämpfungs- und Stei-
figkeitsmatrix

d1 + d2 −d2 k1 + k2 −k2
M = diag(m1 , m2 ), D = ; K = ,
−d2 d2 −k2 k2
den Eingangsmatrizen für die Stell- und Störgröße sowie der Messmatrix
b = [0, 1]T ; w = [q, 0]T ; c = [1, 0].

T
Für die explizite Schreibweise der Strecke bilden wir zunächst die Systemmatrix

0 2×2 E 2×2
A = ,
−M M −1K −M M −1D
die zugehörigen Eingangsmatrizen

T T
bT = 01×2 , M −1b ; wT = 01×2 , M −1w
und die angepasste Messmatrix

T
c T = c , 0, 0 = [1, 0, 0, 0] .
Mit dem Zustandsvektor x (t) = [x1 , x2 , ẋ1 , ẋ2 ]T = [yyT , ẏyT ]T folgt dann die Bewe-
gungsgleichung
ẋx(t) = Ax
Ax(t) + b u(t) + w cos Ωt
yM (t) = c Tx (t).
Soll das System mit gegebenem Stellgesetz u(t) simuliert werden, dann müssen wir
wegen des Integralanteils wieder eine Zwischengröße z. B. uI einführen
$
u(t) = −k p c Tx (t) − kI c Tx (t)dt = −k p c Tx (t) − kI uI (t) .

uI (t)
Fügen wir u̇I (t) = c Tx (t) zur Systemgleichung hinzu, dann folgt

ẋx(t) A O x (t) b
= + u(t)
u̇I (t) cT 0 uI (t) 0

x (t) 1 0 0 0 0 x (t)
y (t) = C = ,
uI (t) 0 0 0 0 1 uI (t)
bzw. für den geschlossenen Kreis

" #
ẋx(t) A − k p b c T −kI b x(t)
=
u̇I (t) cT 0 uI (t)

z (t)
y(t)M = 1 0 0 0 0 .
uI (t)
cT
Dies ist die für die numerische Integration benötigte explizite Form, vgl. Abschn. 8.1.
5.1.1.2 Nichtlineare Systeme

Die Umformung auf eine explizite Standardform und damit verbundene Probleme zeigen wir
an einigen einfachen Beispielen. In der Regel wird die Integration bezüglich der unabhängigen
Variablen der Zeit t ausgeführt. In besonderen Fällen kann es zweckmäßiger sein, eine neue
unabhängige Variable einzuführen. Dies kann physikalische wie rechentechnische Vorteile bieten.
Beispielorientiert sollen einige Vorgehensweisen erläutert werden.
Beispiel 5.4: Explizite Schreibweise im Zeitbereich
• Allgemeines Beispiel: Gegeben sei die Differenzialgleichung
ü + u̇v̇ = sin t
v̇ + v + u = cos t ,
gesucht die explizite Form (5.2). Führen wir hierfür die neuen Variablen
y1 = u, y2 = u̇, y3 = v
ein, so können wir die Differenzialgleichungen damit umschreiben:
ẏ1 = y2
ẏ2 = ü = sin t − y2 ẏ3
ẏ3 = cos t − y3 − y1 .
Um die Standardform ẏy = f (yy, t) zu erhalten, müssen wir ẏ3 in der zweiten Gleichung
eliminieren und erhalten
ẏ1 = y2
ẏ2 = sin t − y2 (cos t − y3 − y1 )
ẏ3 = cos t − y3 − y1 ; yi (0) = yi0 , i = 1, 2, 3.
Den letzten Schritt wird man für eine numerische Vorgehensweise wegen der seriellen
Arbeitsweise des Digitalrechners nicht unbedingt ausführen; man wird vielmehr die
Reihenfolge der abzuarbeitenden Differenzialgleichungen so umstellen, dass für den
folgenden Schritt jeweils die rechte Seite bekannt ist. Dies bedeutet für das vorliegende
Beispiel ein Vertauschen der Gleichungen ẏ2 = · · · und ẏ3 = · · ·.
• VAN - DER -P OL-Schwinger ohne/mit Erregung

0
ẍ − ε(1 − x2 )ẋ + x = (5.20)
q cos Ωt .
In der Elektrotechnik wurden früher stabile Oszillatoren (heute Quarz) in Form dis-
kreter Netzwerke aufgebaut, welche sich u. a. durch das VAN - DER -P OL-Modell mit
q = 0 beschreiben ließen. Für q = 0 ist (5.20) eine autonome Differenzialgleichung,
die Zeit tritt nicht explizit auf. Die Lösungen sind konstant und insbesondere peri-
odisch. Die Periodendauer T wird durch den Parameter ε festgeschrieben. Da die pe-
riodischen Schwingungen nur durch Energieaustausch (Dämpfung/Anfachung), also
ohne äußere Anregung, entstehen, spricht man von Selbsterregung bzw. selbsterregten
Schwingungen im Gegensatz zur Fremderregung. Heute dient (5.20) als Standardglei-
chung zur Beurteilung von Integrationsalgorithmen steifer Systeme. Für q
= 0 treten
Mitnahme -Effekte auf. Zu gegebenem q ist die periodische Lösung x(T + t) = x(t)
nur für bestimmte Ω stabil, diesen Bereich bezeichnet man als Mitnahmebereich, vgl.
Abschn. 4.6.1.
Die Standardform erhalten wir mit x1 = x, x2 = ẋ :
ẋ1 = x2

0
ẋ2 = ε(1 − x12 )x2 − x1 + .
q cos Ωt
• Mechanische Systeme mit Minimalgeschwindigkeiten: Bewegungsgleichungen ho-

lonomer Mehrkörpersysteme in Minimalkoordinaten q ∈ R f haben die allgemeine
Form
M (qq, t) q̈q + k (qq, q̇q, t) = Q (qq, q̇q, t), q (t0 ) = q 0 , q̇q(t0 ) = v 0 , (5.21)
wobei der Geschwindigkeitszustand, wie in (5.4), stets durch die zeitlichen Ablei-
tungen der Lagekoordinaten beschrieben wird. Die explizite Schreibweise entspricht
(5.3).
Definieren wir die Geschwindigkeitszustände ṡs als Linearkombinationen von q̇q mit
den i. allg. lageabhängigen Linearfaktoren als Elemente der regulären Matrix H ∈ R f , f ,
dann gelten die kinematischen Differenzialgleichungen
q̇q = H (qq)ṡs . (5.22)

Einsetzen von (5.22) und deren zeitlichen Ableitung
q̈q = H (qq)s̈s + h (qq, ṡs) mit h = Ḣ

H ṡs (5.23)
in (5.21) sowie Multiplikation mit H T von links liefern die Bewegungsgleichungen in

Minimalkoordinaten q und Minimalgeschwindigkeiten ṡs =: ω
ω
q̇q = H (qq)ω
(5.24)
ω̇ M (qq, t)−1 Q̄
ω = M̄ Q(qq, ω , t) − k̄k (qq, ω , t)
mit den Matrizen
M = H TMH
M̄ MH, k̄k = H T (Mh
Mh + k ), Q = H TQ .
Q̄
Vorteil gegenüber (5.21): Einfacherer Aufbau der Bewegungsgleichungen, vielfach

kürzere Integrationszeiten (Verläufe ṡs(t) glatter); Anwendung: Kreiselsysteme. Für
H = E erhalten wir die explizite Form von (5.21). Gleichung (5.23) ist die allgemeine-
re Form zur Beschreibung von Mehrkörpersystemen, sie wird auch im SimMechanics
Tool, vgl. Abschn. 7.1.6, zugrunde gelegt, vgl. Beispiel 5.10, S. 271.
Beispiel 5.5: Einführung einer neuen unabhängigen Variablen
Ist die Ausgangsgleichung eine autonome Bewegungsgleichung, dann lässt sich eine
andere unabhängige Variable als die Zeit t einführen. Wir zeigen dies anhand zweier
Beispiele mit jeweils einem Freiheitsgrad:
• Phasenebene (-raum); VAN - DER -P OL-Schwinger:
ẍ − ε(1 − x2 ) ẋ + x = 0 .
Für die autonome Differenzialgleichung ist es möglich, neben der Diskussion von x(t)
auch ẋ(x) als Phasenebenendarstellung zu betrachten. Setzen wir ẋ = v, dann folgt mit
dv dx
ẍ = = v v
dx dt
aus der Ausgangsgleichung des VAN - DER -P OL-
Schwingers eine Differenzialgleichung 1. Ordnung
für v(x)
dv x
= v = ε(1 − x2 ) − ; v
= 0 .
dx v
Allgemein gilt für nichtlineare Systeme:
dx dy
= P(x, y), = Q(x, y) ; P
= 0 , P, Q glatt,
dt dt
so dass
dy Q(x, y)
= .
dx P(x, y)
Bild 5.6: Van der Pol-Schwinger: Zeitverlauf x(t) und Phasenkurve ẋ(x)
• Drehschwingungssysteme: Hier lässt sich der Drehwinkel z. B. φ als Funktion der

Zeit t beschreiben oder, wenn in der Bewegungsgleichung die Zeit explizit nicht auf-
tritt, sie also autonom ist, die Winkelgeschwindigkeit ω = φ̇ als Funktion des Dreh-
winkels ω = ω(φ ). Um dies zu verdeutlichen, betrachten wir das einfache Beispiel
eines über das Moment
M(φ̇ ) = k(Ω − φ̇ ), k, Ω = const.
angetriebenen mathematischen Pendels mit der Punktmasse m und der masselosen

Koppelstange der Länge . Die zugehörige Bewegungsgleichung lautet:
k(Ω − φ̇ )
'$
g M(φ̇ )
φ̈ + sin φ = φ

m2 xm
&%
φ (0) = φ0 , φ̇ (0) = φ̇0 .
Beide oben angedeuteten Betrachtungsweisen wollen wir kurz erläutern:

• Diskussion von φ (t), φ̇ (t): Dieses Ergebnis erhalten wir unmittelbar durch nume-
rische Integration der oben angegebenen Bewegungsgleichung. Die zugehörigen
Zeitverläufe für
g k
= 5,0 1/s2 , = 5,5 1/s ; Ω = 1 rad/s
m2
sind in Bild 5.71,2 dargestellt.
• Da die Dgl. autonom ist, können wir aber auch φ̇ (φ ) diskutieren. Hierzu führen
wir die neue unabhängige Veränderliche φ ein und eliminieren mit
dω dω
= ω ; φ̇ = ω
dt dφ
5.2 Der grundsätzliche Aufbau eines Simulationsprogramms 237
die Zeit t und finden

g M(ω)
ω ω + sin φ = , ( ) = d /d φ
m2
bzw. nach Division mit ω (ω
= 0 vorausgesetzt) die Differenzialgleichung 1.
Ordnung für ω(φ )
g M(ω)
ω + sin φ = .
ω ωm2
Der Graph ω(φ ) ist in Bild 5.73 wiedergegeben. Man erkennt, dass einerseits nur
eine Differenzialgleichung erster Ordnung zu integrieren ist und andererseits der
Funktionsverlauf einfacher erscheint, so dass dadurch mit kürzerer Integrations-
zeit zu rechnen ist, zeitweilig rückläufige Bewegungen seien ausgeschlossen.
25 2 2
20
1.5 1.5
15
1 1
ω
ω
φ
10
0.5 0.5
5
0 0 0
0 20 40 0 20 40 0 10 20
Zeit t Zeit t φ
Bild 5.7: Funktionsverläufe φ (t) , ω(t) = φ̇ (t) und ω(φ )
5.2 Der grundsätzliche Aufbau eines Simulationsprogramms
Im einfachsten Fall setzt sich ein Simulationsprogramm aus dem Hauptprogramm, dem Pro-
grammcode des Integrationsverfahrens z. B. odexx und dem Unterprogramm (Function) z. B.
sys der zu bearbeitenden Differenzialgleichungen zusammen. Das Hauptprogramm umfasst min-
destens die Parametrisierung des zu simulierenden mathematischen Modells mit der Parameter-
übergabe (u. a. über die Global-Vereinbarung global...) an die Function der Differenzialglei-
chungen, den Integratoraufruf mit zugehörigen Optionen (z. B. Fehlertoleranz) sowie die Ergeb-
nisauswertung. Das Zusammenspiel der einzelnen Programme ist in Bild 5.8 veranschaulicht.
5.2.1 Möglichkeiten zum Integratoraufruf unter MATLAB
Unter MATLAB stehen die in Tabelle 5.1 aufgeführten Integratoren mit variabler Schrittweite
für den zugeordneten Differenzialgleichungstyp zur Verfügung. Die Methoden wurden in Ab-
Hauptprogramm
global... Parameter
[ta te], y 0 Parametrisierung
Integratoraufruf mit Optionen
- Ergebnisauswertung:
Signalanalyse
Ausgabe: plot, File
t,y
?
ODExx(’syst’,[ta te],y0,...) function[ydot] = sys(t,y,...)
global ..., Parameter
Integrationsverfahren ẏy = f (t, y )
6 6
tk , y k
ẏyk
Bild 5.8: Bausteine eines einfachen Simulationsprogramms
Tabelle 5.1: Integratoren mit variabler Schrittweite und deren Eigenschaften
Löser Problemkreis Methode
ode45 nicht steife Differenzialgleichungen Runge-Kutta

ode23 nicht steife Differenzialgleichungen Runge-Kutta
ode113 nicht steife Differenzialgleichungen Adams
ode15s steife Differenzialgleichungen und DAEs NDFs (BDFs)
ode23s steife Differenzialgleichungen Rosenbrock
ode23t moderat steife Differenzialgleichungen und DAEs Trapez-Formel
ode23tb steife Differenzialgleichungen Trapez-BDF2
ode15i implizite Differenzialgleichungen, ab R14 NDFs (BDFs)
schn. 4.2 beschrieben, vgl. auch: MATLAB-Handbücher und/oder Online-Hilfe. Es werden zu-
nächst einige Möglichkeiten der Integrationsaufrufe und Beispiele zugehöriger Optionen und
Steuerungen stichwortartig angegeben.
Syntax
[t,y] = ode..(@f,tspan,y0), % Ausgabevektoren t, y
loesung = ode..(@f,tspan,y0), % Ausgabe in Structure
[t,y] = ode..(@f,tspan,y0,options) % mit Optionen
[t,y] = ode..(@f,tspan,y0,options,p1,p2,...) % mit Parameterübergabe
[t,y,tE,yE,iE] = ode..(@f,tspan,y0,options) % System mit Ereignis
[t,y,tE,yE,iE] = ode15i(@f,tspan,y0,yp0,options) % Implizites Verf.
mit
5.2 Der grundsätzliche Aufbau eines Simulationsprogramms 239
f berechnet ẏy(tn ) der Dgl. ẏy = f (t, y ) zum Zeitpunkt tn oder

M ẏy = f (t, y ), M = const. oder
M (t, y )ẏy = f (t, y ) (außer ode23s) oder
M , M (t, y ) singulär, dann differenzial-algebraische
Gleichung vom Index 1; Löser: ode15s, ode23t
tspan [ t0 te ] oder [ t0 , t1 , . . . , te ], Zeitvektor: Anfang / Ende bzw. Zeitfolge
y0 Anfangswerte: [y1 (0); y2 (0); ...] zum Zeitpunkt t = 0
options Integratoroptionen kreiert mit odeset; vgl. Tabelle 5.2 (vgl. simset für Simulink)
p1, p2... Übergabe von Systemparametern, u. a. an f, nach Optionen bzw. mit [ ] ohne Opt.
t,y Lösung: Zeitv. t u. Zustandsv. y oder als Structure, z. B. loesung
5.2.1.1 Integrationsaufrufe mit Optionen

Anhand einiger Beispiele erläutern wir wesentliche Optionen aus Tabelle 5.2 und Integrations-
aufrufe, vgl. auch: help odeset und >> odeset % Eingabe im Command Window
Tabelle 5.2: Optionen
Parameter ode45 ode23 ode113 ode15s ode23s ode23t ode23tb ode15i
RelTol, AbsTol,
∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗
NormControl
OutputFcn, OutputSel,
∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗
Refine, Stats
Events ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗
MaxStep, InitialStep ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗
Jacobian, JPattern,
- - - ∗ ∗ ∗ ∗ ∗
Vectorized
Mass ∗ ∗ ∗ ∗ ∗ ∗ ∗ -
MStateDependence ∗ ∗ ∗ ∗ - ∗ ∗ -
MvPattern - - - ∗ - ∗ ∗ -
MassSingular - - - ∗ - ∗ - -
InitialSlope - - - ∗ - ∗ - -
MaxOrder, BDF - - - ∗ - - - -
• Vorgabe von relativer und absoluter Fehlertoleranz und maximaler Schrittweite

options = odeset(’RelTol’,1e-4, ’AbsTol’,[1e-4 1e-6 ...],...
’MaxStep’,1e-2);
[t,y] = ode45(@f,[0 10],[0 1 ...],options, p1, p2, ... );

Systemparameterübergabe
options kann leer sein, dann [ ] als Platzhalter einfügen
function out = f(t,y,p1,p2,..) % zugehöriger Function-Kopf
• Berechnung der Ableitungsfunktion in vektorisierter Form
options = odeset(’Vectorized’,’on’)
function dydt = f(t,y) % Function-Kopf der Dgl.

dydt = [0.5*y(1,:); ....] % für alle (:) Zeitpunkte definiert
• Steifes Problem mit analytisch ermittelter JACOBI-Matrix
options = odeset(’Jacobian’,@J) % Function J der JACOBI-M.
[t,y] = ode15s(@f,tspan,y0,options,p1) % Integrator-Aufruf
function dydt = f(t,y,p1,...) % Function-Kopf der Dgl.

function dfdy = J(t,y,p1,...) % Function-Kopf der JACOBI-Matrix
• System der Form M ẏy = f (t, y ), M konstant
options = odeset(’Mass’,M) % M=konst im Hauptprogramm definiert
• System der Form M (t, y )ẏy = f (t, y )
options = odeset(’Mass’,@mass) % M in der Function mass definiert
function M = mass(t,y,p1,...) % Function-Kopf der Massen-Matrix

M(1,1) = ... % Zeit- und/oder zustandsabhängige Massenmatrix
• System der Form M (t)ẏy = f (t, y )
options=odeset(’Mass’,@mass,’MStateDependence’,’none’,’Jacobian’,J)
function M = mass(t,p1) % Function-Kopf der zeitabhängigen Matrix M
M(1,1) = ...
% J im Hauptprogramm definiert, wenn konstant, sonst @J

• System mit Zustandsereignis, siehe Abschn. 5.6
options = odeset(’Events’,@event,..) % Schaltfunktion in
% Function event definiert
function dydt = f(t,y,p1,...) % Function-Kopf der Dgl.
function [q,isterminal,direction] = event(t,y,p1,...)% Funct.-Kopf

% des Ereignisses
q = schaltfunktion
isterminal = ...% Steuerung für Intgrationsabbruch, 0 (nein), 1 (ja)
direction = ...% Information zur Steigung von q bei Nulldurchgang,
% 0, 1, -1 (unbekannte, positive, negative Steigung)
• Integration impliziter Differenzialgleichungen, f (t, y , ẏy) = 0 , siehe Abschn. 5.5
konsistente Anfangsbedingungen, f (t0 , y 0 , ẏy0 ) = 0
[y0, yp0] = decic(f,t0,y0,[],yp0,[]); % konsistente Anfangswerte
[t,y] = ode15i(f,tspan,y0,yp0,options,p1) % Integration
function res = f(t,y,yp,p1) % Function der impliziten Dgl.

res = yp(1)-y(3); ....
Ausgabehilfsmittel, Optionsabfragen
Darüber hinaus lassen sich mit OutputFcn Ausgaben als Zeitverläufe odeplot – wie in Bei-
spiel 5.6 –, als 2D- und 3D-Phasenebenen odephas2, odephas3 und der numerischen Zwi-
schenwerte odeprint erreichen.
Abfragen benutzereigener Optionen oder Standardoptionen , z. B. meine_option können
mit odeget(meine_option,’AbsTol’) für die absolute Toleranz usw. zur Anzeige ge-
bracht werden.
5.3 Integration von Systemen in Standardform 241
Ermittlung der Lösung zur vorgegebenen Zeitfolge

Integration hält vorgegebene Zeitpunkte ein, z. B
[t,y]=ode45(@f,[0:1/Istep:1-1/Istep],y0,options)
Liegt das Integrationsergebnis in Structure-Form, z. B in der Structure loesung, vor, dann
lassen sich nach der Integration die Funktionswerte zu den vorgegebenen Zeitpunkten, z. B.
t=0:0.1:2, mit
y = deval(loesung,t)
ermitteln.
Anwendung: Kurvenglättung, FFT-Analyse, Animation für zeitgetreue Wiedergabe, siehe auch
interp1.
5.3 Integration von Systemen in Standardform

Es soll beispielhaft auf die Programmierung einer Bewegungsgleichung in expliziter Form nach
(5.2) bzw. nach (5.5) eingegangen werden, wobei wir auf die ebenfalls gebräuchliche Schreib-
weise in y
ẏy = f (t, y ), y (0) = y 0 , bzw. M ẏy = g (t, y )
übergehen, insbesondere dann, wenn nicht ausnahmslos mechanische Größen vorkommen. Auf-
bereitung und zweckmäßige Schreibweisen spielen dabei eine wesentliche Rolle, woraus sich
vielfach übersichtlichere Formulierungen ergeben.
Zunächst aber betrachten wir ein einfaches Beispiel einer Differenzialgleichung erster Ord-
nung mit dem sich u. a. das Anfangswertproblem grafisch veranschaulichen lässt.
Beispiel 5.6: Das Anfangswertproblem

Für die Differenzialgleichung 1. Ordnung
ẏ = 2 sin (y) cos (1.2t)
ist das Richtungsfeld in der y, t-Ebene sowie die numerische Lösung zu den Anfangs-
werten y(0) = 2 und y(0) = 3.5 für 0 ≤ t ≤ 2π zu visualisieren.
Da die Formulierung der Differenzialgleichung sehr einfach ist, schreiben wir hier
keine separate Function, sondern wie in Abschn. 1.5.4.3 eine Anonymous Function,
die im Script steht. Das Richtungsfeld wird mit der Built-in Function quiver erzeugt.
Einige Programmschritte aus dem Script Grafik_Elemente.m in [52] geben wir
an:
odefun=@(t,y) 2*sin(y).*cos(1.2*t); % Anonymous Function
figure % Grafikfenster
% ---- Punkte der Richtungselemente in der y,t-Ebene
[t,y]=meshgrid(linspace(0,2*pi,20),linspace(.5,5,20));
yp=odefun(t,y); % Ableitungsfunktionen yp
quiver(t,y,ones(size(yp)),yp); % Richtungsfeld
hold on
% ---- Anfangswertprobleme lösen: wir wählen 2 Integratoren

ode23(odefun,[0,2*pi],2); % Auswertung über odeplot
ode45(odefun,[0,2*pi],3.5);
Bild 5.9: Richtungsfeld mit zwei speziellen Trajektorien zu y(0) = 2, y(0) = 3.5
Die Anonymous Function gibt das Function Handle odefun zurück, so dass im
Gegensatz zur üblichen Formulierung mit einer Function als eigenes M-File, z. B.
function yp=odefun(t,y) % Function-Kopf
yp=2*sin(y)*cos(1.2*t); % Ableitungsfunktion
das @-Zeichen im Integratoraufruf odexx entfällt. Darüber hinaus werden keine Da-
ten von den Integrierern zurückgegeben (linke Seite fehlt) wodurch automatisch die
grafische Darstellung der Ergebnisse mit der Option: ’OutputFcn’,@odeplot
erfolgt.
Bild 5.9 zeigt das Ergebnis. Es ist deutlich erkennbar, dass durch die Anfangswerte
y(0) = 2 sowie y(0) = 3.5 jeweils eine Trajektorie ausgewählten Richtungselementen
zuzuordnen ist.
5.3.1 Unwuchtiger Motor auf elastischem Fundamentblock

Ein unwuchtiger Motor befindet sich auf einem elastisch abgestützten Fundament. Gegenüber
dem Projekt aus Abschn. 8.2 sei der Antrieb durch ein Modell eines Gleichstrommotors er-
setzt. Ziel soll es sein, Anfahrvorgänge mit Resonanzdurchgängen, also instationäre Zustände,
zu simulieren. Die Bewegungen des Fundamentblocks betrachten wir um die statische Gleich-
gewichtslage. Das Motorträgheitsmoment einschließlich der Unwucht mu e mit der Exzentrizität
e sei J = J0 + mu e2 . Mit dϕ ϕ̇ berücksichtigen wir eine winkelgeschwindigkeitsabhängige Dreh-
dämpfung z. B. infolge einer Lagerreibung. Der Gleichstrommotorkreis enthält die Induktivität
LA , den Widerstand RA + RAN , wobei RA der Widerstand des Ankerstromkreises und RAN der
Anfahrwiderstand ist. Die angelegte Motorgleichspannung ist ue , das Drehmoment wird mit dem
Momentenfaktor km gebildet; vgl. [30], [29]. Eine Drehzahländerung können wir einerseits durch
eine Widerstandsänderung, andererseits durch Veränderung des Flusses Φ oder der Klemmspan-
nung ue erreichen. Wir verfolgen hier den Weg über den Anfahrwiderstand RAN .
Bild 5.10: Fundament mit unwuchtigem Motor und Modell des Gleichstrommotors
Masse m = m0 + mu = 100 kg
Massenträgheitsmoment J = 0,2 kg m2
Federsteifigkeit k = 2,25 106 N/m
Dämpfungskonstante d = 225 Ns/m
Unwucht emu = 0,05 m kg, 0,01 m kg
Induktivität LA = 0,1 H
Ankerkreiswiderstand RA = 0,5 Ω, . . . 10 Ω
Widerstand (Maximalwert) RA = RA + RAN = 200 Ω
Widerstandsänderung rA (t) = RA (1 + rAmax (1 − t/th ))
bezogener Widerstand rAmax = RAN /RA
Zeitfenster der Widerst.-Änd. th = 40 s
Spannung ue = 200 V
Momentenfaktor km = 1 Nm/A
Drehdämpfung im Lager dϕ = 225 10−5 Nms/rad
5.3.1.1 Bewegungsgleichungen
Die Bewegungsgleichungen für die Vertikalbewegung formulieren wir mit Bild 5.11 nach dem
Prinzip von D’A LEMBERT, vgl. [55], womit folgt:
- Fundamentbewegung um die statische Gleichgewichtslage x0 = (m0 + mu )g/k
(m0 + mu )ẍ + d ẋ + kx = mu e(ϕ̇ 2 sin ϕ − ϕ̈ cos ϕ), (5.25)

- Drehbewegung und Antriebsmotor
(J0 + mu e2 )ϕ̈ + dϕ ϕ̇ + mu e(ẍ + g) cos ϕ = km iA (5.26)
LA (iA )˙+ RA (1 + ΔrA (t))iA = ue − km ϕ̇, ΔrA (t) Widerstandsänderung. (5.27)

Dies ist ein nichtlineares Differenzialgleichungssystem 5. Ordnung für x(t), ϕ(t), iA (t).
Bild 5.11: Schnittbild einschließlich der Trägheitsterme für die Vertikalbewegung
5.3.1.2 Aufbereitung der Bewegungsgleichungen
Die mathematische Modellierung des Systems setzt sich aus zwei nichtlinearen Differenzialglei-
chungen zweiter Ordnung für x(t), ϕ(t) sowie einer linearen Differenzialgleichung erster Ord-
nung für iA (t) zusammen. Die ersten beiden Gleichungen bringen wir zunächst auf eine angenä-
hert explizite Form. Hierzu dividieren wir jeweils durch m = m0 + mu bzw. J = J0 + mu e2 , führen
die Abkürzungen
(mu e)2
2δ = d/m; ω02 = k/m; 2δϕ = dϕ /J; mx = 1 − cos2 ϕ
mJ
ein und eliminieren in der ersten Gleichung ϕ̈ mit Hilfe der zweiten Gleichung. Danach erhalten
wir für die ersten beiden Gleichungen

1 mu e mu e km
ẍ = {−2δ ẋ − ω0 x +
2
2δϕ ϕ̇ + g cos ϕ − iA cos ϕ + ϕ̇ sin ϕ }
2
mx m J J
mu e km
ϕ̈ = −2δϕ ϕ̇ − (ẍ + g) cos ϕ + iA .
J J
Da ẍ auch auf der rechten Seite der Bewegungsgleichung der Drehung weiterhin auftritt, muss
bei der Programmierung sichergestellt werden, dass zunächst ẍ berechnet wird. D. h. nicht immer
wird eine strenge explizite Form der Bewegungsgleichung nötig. Wählen wir die Zustandsvaria-
blen des Zustandsvektors:
y = (y1 , y2 , y3 , y4 , y5 )T = (x, ϕ, ẋ, ϕ̇, iA )T ,
so folgt die für die numerische Integration erforderliche Standardform:

ẏ1 = y3
ẏ2 = y4
ẏ3 = {−2δ y3 − ω02 y1 +

mu e mu e km
2δϕ y4 + g cos y2 − y5 cos y2 + y24 sin y2 }/mx (5.28)
m J J
mu e km
ẏ4 = −2δϕ y4 − (ẏ3 + g) cos y2 + y5
J J
RA km 1
ẏ5 = − (1 + ΔrA (t))y5 − y4 + ue
LA LA LA
mit der Abkürzung mx = 1 − (mmJ

2
u e)
cos 2 y2 . Für einen Anfahrvorgang über die bezogene Wider-
standsänderung ΔrA (t) setzen wir

rAmax (1 − tt ) für t ≤ th
ΔrA (t) = h
0 für t > th .
5.3.1.3 Programmausschnitte und numerische Ergebnisse

Hier können wir nur wesentliche Teile der Programme gmotor.m, fgmotor.m [52] abdrucken
und kurz erläutern.
Tabelle 5.4: Parameterabkürzungen für Typ-Vereinbarung: global
dϕ mu e
m = 2δ m =ω , = 2δϕ ,
d k 2
p1 = , p2 = p3 = J p4 = m ,
mu e km km 1
p5 = J , p6 = J , p8 = LA , p9 = LA
Die Abkürzungen der Systemparameter p j sind in Tabelle 5.4 erklärt; sie werden als globale
Variable vereinbart, d. h. die Parameterliste mit den p j hinter dem Schlüsselwort global muss im
Hauptprogramm und in der Function der Differenzialgleichungen stehen. Nach der Parametrie-
rung sind die Abkürzungen aus Tabelle 5.4 zu bilden. Es folgen die gewählten Anfangswerte und
das Integrationsintervall. Da in Bezug auf die Differenzialgleichung keine Besonderheit, z. B.
Steifheit, erkennbar ist, wählen wir den Integrator ode45
Programmausschnitte von gmotor.m mit der Function fgmotor.m aus [52]
global p1 p2 p3 p4 p5 p6 p8 p9 g ue LA RA rAmax th
% ---- Parameter
m =100; % Masse kg
mue=0.05; % Unwucht kgm
k=2.25e+06; % Federst. N/m
d=225; % Dämpfung Ns/m
............
ue=200; % Klemmspannung V
th=40 % Hochfahrzeit
% ---- Parameterabkürzungen
p1=d/m; % siehe Tabelle
p2=k/m;
............
p9=1.0/LA;
% ---- Anfangswerte
i0=(ue-km*Om)/RAst; % Stromanfangswert
y0=[0;0;0;Om;i0]; % Anfangswertvektor
% ---- Integrationsintervall
tint=[0 50]; % Integrt. über 50 s
% ---- Optionen und Integratoraufruf
options = odeset(’RelTol’,1e-04);% Optionen
[t,y]=ode45(@fgmotor,tint,y0,options); % Integratoraufruf
% ---- grafische Auswertung
figure(1) % grafische Darstellung
subplot(311)
plot(t,y(:,4)) % Winkelgeschwindigkeit
............
Die Function der Differenzialgleichungen enthält (5.28) sowie die Ansteuerung des Motors.
function yp = fgmotor(t,y)
global p1 p2 p3 p4 p5 p6 p8 p9 g ue LA RA rAmax th
% ---- Anfahrsteuerung
p7=RA*(1.0+(t<=th)*rAmax*(1-t/th))/LA; % Anfahrwiderstand
co=cos(y(2)); % Abkürzung
mx=1.0-p4*p5*co^2; % Abkürzung
yp(1)=y(3); % Fundamentblock
yp(2)=y(4); % Drehbewegung
yp(3)=(-p1*y(3)-p2*y(1)+p4*((p3*y(4)+...
p5*g*co-p6*y(5))*co+y(4)^2*sin(y(2))))/mx;
yp(4)=-p3*y(4)-p5*(yp(3)+g)*co+p6*y(5);
yp(5)=-p7*y(5)-p8*y(4)+p9*ue; % Motor
yp=yp’;
Simulationsergebnisse
Die Simulation wurde mit den Standardparametern nach Tabelle 5.3 einerseits für e mu = 0.05
m kg, RA = 0.5 Ω und andererseits für e mu = 0.01 m kg, RA = 10 Ω durchgeführt. Die Ergeb-
nisse sind in Bild 5.12 grafisch dargestellt. Deutlich wird die Kopplung zwischen der Funda-
mentschwingung x(t) und der Drehbewegung ϕ̇(t) = Ω sowie dem damit zusammenhängenden
Einfluss auf den Strom. Dadurch neigt insbesondere das Modell mit der größeren Unwucht e mu
= 0,05 m kg zu stärkeren Resonanzüberhöhungen im Bereich 25 < t < 42 s zu Ω ≈ 150 rad/s.
Durch die damit verbundene hohe Drehbelastung gewinnt das System trotz starken Stromanstiegs
kaum an Winkelgeschwindigkeit. Es bleibt nahezu in der Resonanz hängen. Unmittelbar nach
dem erreichten Spitzenwert von x(t) bzw. iA (t) ändert sich Ω sprungartig und der Strom bricht
aufgrund des kleinen Ankerwiderstandes schnell zusammen. Betrachten wir demgegenüber die
Zeitverläufe bei kleinerer Unwucht und höherem Ankerwiderstand RA , dann fällt die mit e mu
zusammenhängende geringere Resonanzüberhöhung und somit die kleinere Motorbelastung auf

– Skalierung beachten. Der Widerstandseinfluss RA wird nach dem Resonanzdurchgang deutlich,
der Strom fällt erheblich langsamer ab.
a: e mu = 0,05 m kg, RA = 0,5 Ω b: e mu = 0,01 m kg, RA = 10 Ω
Bild 5.12: Anfahrvorgänge
5.3.1.4 Formulierung mit zustandsabhängiger Massenmatrix
Die oben eingeschlagene Vorgehensweise ist für Systeme niedriger Ordnung vertretbar, weil man
noch den Überblick behält. Zweckmäßiger ist eine Matrix/Vektor-Schreibweise. Dazu führen wir
den Beschleunigungsvektor (ẍ, ϕ̈)T ein, so dass wir für (5.25)-(5.27) schreiben können

m mu e cos ϕ ẍ −(d ẋ + kx) + mu eϕ̇ 2 sin ϕ
=
mu e cos ϕ J ϕ̈ −dϕ ϕ̇ − mu eg cos ϕ + km iA (5.29)
LA (iA )˙ = −RA (1 + ΔrA (t))iA − km ϕ̇ + ue ,
wobei weiterhin der Zustandsvektor y = (y1 , . . . , y5 )T = (x, ϕ, ẋ, ϕ̇, iA )T gilt. Die Massen-
matrix in (5.29) ist zustandsabhängig. Wollen wir das System als explizites Gleichungssystem
behandeln, dann müssen wir (5.29)1 von links mit der Inversen
−1
m mu e cos ϕ 1 J −mu e cos ϕ
=
mu e cos ϕ J m J − (mm e cos ϕ)2 −mu e cos ϕ m
durchmultiplizieren. Diese Inverse muss in der Regel zu jedem Integrationsschritt mehrfach nu-
merisch ermittelt werden, was bei Systemen höherer Ordnung sehr rechenintensiv ist. Es stellt
sich jetzt die Frage, ob man das System in der Form (5.5) oder sogar als implizite Differenzial-
gleichung lösen sollte. Wählen wir die Form (5.5)
M (yy)ẏy = Cy + f nl (yy), (5.30)

dann gehören hierzu

⎡ ⎤
1 0 0 0 0
⎢ 0 1 0 0 0 ⎥
⎢ ⎥
M = ⎢⎢ 0 0 m mu e cos y2 0 ⎥
⎥
⎣ 0 0 mu e cos y2 J 0 ⎦
0 0 0 0 LA
⎡ ⎤ ⎡ ⎤
0 0 1 0 0 0
⎢ 0 0 0 1 0 ⎥ ⎢ 0 ⎥
⎢ ⎥ ⎢ ⎥
C =⎢
⎢ −k 0 −d 0 0 ⎥,
⎥ f nl =⎢
⎢ mu e y24 sin y2 ⎥.
⎥
⎣ 0 0 0 −dϕ km ⎦ ⎣ −mu e g cos y2 ⎦
0 0 0 −km −RA (1 + ΔrA (t)) ue
Die Massenmatrix M ist separat zu programmieren – mgmotor.m. Die Function der Diffe-
renzialgleichung enthält nur die rechte Seite von (5.30). Eigenschaften zur Massenmatrix können
optional angegeben werden:
options=odeset(’Mass’,@mgmotor,’MassSingular’,’no’,...
’MStateDependence’,’weak’,’RelTol’,1.0e-04);
Neben dem Function-Namen mgmotor setzen wir die Regularität von M (yy(0)) zum Zeit-
punkt t = 0, sie ist eindeutig. Der Abhängigkeitsgrad von den Zustandsgrößen
MStateDependence |none|, |{weak}|, |strong|
ist nicht so einfach zu beantworten. Da nicht alle Elemente zustandsabhängig sind, wählen wir
weak (Standardwert). Die Eigenschaft none ist für eine reine zeitabhängige Matrix M (t) zu
setzen.
Welche der hier betrachteten Wege letztendlich der günstigste ist, kann nur mit einer Simu-
lation geklärt werden. Ist die Rechenzeit das wesentliche Kriterium, dann zeigen (5.29) trotz
Invertierung und (5.28) deutliche Vorteile. Dies liegt womöglich an der günstigen Invertierung
eines 2×2-Systems gegenüber der von M sowie dem vielfachen Aufruf der Function zur Mas-
senmatrix.
In dem Programm gmotor.m sowie in der Function fgmotor.m und mgmotor.m kann
mit Hilfe des Steuerparameters IST wahlweise (5.28) oder (5.30) ausgeführt werden.
Übungsvorschlag: Führen Sie für das Modell des Doppelpendels aus Bild 5.17 mit (5.61)-(5.63)
eine Simulation mit zustandsabhängiger Massenmatrix durch. Erstellen Sie ein einfaches Anima-
tionsmodell und zeigen Sie grafisch, dass die Summe aus kinetischer und potentieller Energie
des konservativen Systems stets konstant ist. Hilfe: doppelp.m in [52].
5.4 Differenzial-algebraische Gleichungen 249
5.4 Differenzial-algebraische Gleichungen
5.4.1 Mathematische Hintergründe
Die bisher betrachteten Bewegungsgleichungen basieren auf einem Satz von Minimalkoordina-
ten, sie führen auf gewöhnliche Differenzialgleichungen, die numerisch sehr effizient zu inte-
grieren sind. Es ist insbesondere bei mechanischen Mehrkörpersystemen nicht immer einfach
bzw. oft unmöglich, die Minimalkoordinaten anzugeben. Daher verwendet man Mischformen,
so genannte differenzial-algebraische2 Gleichungen, kurz DAEs 3 . D. h. aufgrund der algebrai-
schen Gleichungen, die keine Beschleunigungsterme enthalten, wird die Massenmatrix M in
(5.5) singulär. Neben der Mechanik findet man derartige Beschreibungen in Anwendungen der
Mechatronik, der Elektrotechnik und Elektronik sowie in der Chemischen Verfahrenstechnik.
Z. B.: Bei der Analyse elektrischer Netzwerke mit Spannungsquellen erhalten wir mit den Ma-
schengleichungen Differenzialgleichungen der Zweigströme, die Knotengleichungen ergeben al-
gebraische Bedingungen der Ströme.
Die wichtigste Invariante für die Analyse von differenzial-algebraischen Gleichungen ist der
so genannte Index. In der Literatur finden sich verschiedene Indexbegriffe, z. B. der Differenziati-
ons-Index nach [10], der Störungs-Index nach [27], usw. Am häufigsten wird der Differenziations-
Index (d-Index) benutzt, da er eine große Klasse von praxisrelevanten Problemen abdeckt und
in vielen Fällen relativ einfach zu berechnen ist. Im Wesentlichen ist der d-Index die Zahl, die
man an Ableitungen der algebraischen Gleichungen benötigt, um das differenzial-algebraische
Gleichungssystem in ein System gewöhnlicher Differenzialgleichungen (ODE) zu überführen.
Wir werden hier nur den d-Index verwenden und schreiben deshalb kurz Index.
Mathematisch betrachtet sind differenzial-algebraische Gleichungen (auch: Algebro-Differen-
zialgleichungen) Differenzialgleichungen mit Nebenbedingungen
duu
= f (uu, λ ), 0 = g (uu, λ ); u (t0 ) = u 0 ,
dt
man spricht auch von Differenzialgleichungen auf Mannigfaltigkeiten (z. B. Kurven oder Flä-
chen). Differenziert man die Nebenbedingungen 0 = g (uu, λ ) implizit nach t, so erhält man
∂gg(uu, λ ) duu λ
∂gg(uu, λ ) dλ
0 = + .
∂uu dt ∂λλ dt
Wenn die JACOBI-Matrix von g nach λ invertierbar ist, können wir die obige Gleichung formal
λ /dt auflösen. Man erhält
nach dλ
−1
λ
dλ ∂gg(uu, λ ) ∂gg(uu, λ )
=− f (uu, λ ).
dt ∂λλ ∂uu
Zusammen mit der Differenzialgleichung für u ergibt das ein gekoppeltes System von Differen-
zialgleichungen, welches für eine stetige rechte Seite eine eindeutige Lösung besitzt. Da die
Überführung mit einer Ableitung erreicht wurde, liegt ein Index-1-Problem vor. Falls die Index-
2 auch: differentiell-algebraische
3 DAEs Differential-Algebraic Equations
1-Bedingung verletzt ist, geht die Eindeutigkeit der Lösung verloren und Bifurkationen (Lösungs-
verzweigungen) können auftreten. Wir betrachten zur Erläuterung das System
du
= λ, u2 + λ 2 = 1.
dt
Für die konsistenten Anfangswerte u(0) = 0 und λ (0) = 1 ist die Index-1-Bedingung erfüllt. Die
lokal eindeutige Lösung lautet
u(t) = sin t, λ (t) = cos t
und existiert für alle t. Bei t = π/2 ist die Index-1-Bedingung
∂g
= 2λ = 2 cos (π/2) = 0
∂λ
zum ersten Mal verletzt und eine Bifurkation findet statt. Eine zweite Lösung durch (u, λ ) =
(1, 0) lautet
u ≡ 1, λ ≡ 0.
Beispiel 5.7: Zur Index-Ermittlung
Für den Einmassenschwinger nach Bild 5.1 mit nichtlinearer Dämpfercharakteristik

nach (5.8) konnten wir das differenzial-algebraische Gleichungssystem
⎡ ⎤ ⎡ ⎤• ⎡ ⎤⎡ ⎤ ⎡ ⎤
1 0 0 0 x 0 0 1 0 x 0
⎢ 0 1 0 0 ⎥⎢ s ⎥ ⎢ 0 0 0 1 ⎥ ⎢ ⎥ ⎢ 0 ⎥
⎢ ⎥⎢ ⎥ ⎢ ⎥⎢ s ⎥ = ⎢ ⎥
⎣ 0 0 m 0 ⎦ ⎣ ẋ ⎦ + ⎣ k −k 0 0 ⎦ ⎣ ẋ ⎦ ⎣ −mg ⎦
0 0 0 0 ṡ −k k + k0 0 0 ṡ − fD (ṡ)
formulieren. Die letzte Gleichung stellt die Nebenbedingung
g = −k(x − s) + k0 s + fD (ṡ)
dar, deren zeitliche Ableitung folgt zu
∂ fD
ġ = −k(ẋ − ṡ) + k0 ṡ + s̈ .
∂ ṡ
Unter der Voraussetzung ∂ fD /∂ ṡ
= 0 ist die Index-1-Bedingung erfüllt und (5.10)
kann unter MATLAB gelöst werden. Wird ∂ fD /∂ ṡ = 0, dann ist die Bedingung verletzt,
es kann zu numerischen Schwierigkeiten kommen.
Verwenden wir das quadratische Dämpfungsgesetz nach (5.8) mit Bild 5.2, dann ist
die Index-1-Bedingung stets erfüllt. Für d0 = 0 und ṡ = 0 ist sie verletzt.
5.4.2 Möglichkeiten unter MATLAB und Simulink

Die Löser ode15s und ode23t4 unter MATLAB (vgl. Tabelle 5.1, 5.2) sind z. Z. nur für Probleme
vom Index 1 mit zeit- und/oder zustandsabhängiger verallgemeinerter Massenmatrix M (t, y )
konzipiert. Der Code ode15s ist eine Variante der Backward Differentiation Formulas, BDFs und
wird in MATLAB als NDFs, Numerical Differentiation Formulas bezeichnet. Er ist zur Lösung
steifer Differenzialgleichungen (ODEs) der Form
M (t, y )ẏy = f (t, y ) (5.31)
entwickelt. Die klassische BDF-Methode kann optional (’BDF’,’on’) aufgerufen werden. Be-
rechnungen eines neuen Schrittes mit einem BDF oder NDF setzt keine reguläre Matrix M
voraus. Dies erlaubt die Berechnung einer direkten Näherung von DAEs vom Index 1. Ist M (t0 )
bzw. M (t0 , y0 ) zum Anfangszustand t0 , y0 singulär, dann wird (5.31) als DAE bearbeitet. Das
Lösen von DAEs ist komplizierter als das von ODEs. Eine DAE hat nur dann eine Lösung, wenn
die Anfangswerte y 0 konsistent bezüglich
M (t0 , y 0 )ẏy0 = f (t0 , y 0 ) (5.32)
sind, d. h. ẏy0 muss Lösung zum Startzeitpunkt t0 sein. Standardmäßig versucht der Integrator aus-
gehend von ẏy0 = 0 mit dem vorgegebenen y 0 konsistente Anfangswerte zu finden. Sind bezüglich
ẏy0 Informationen bekannt, so können diese mit der Eigenschaft InitialSlope in der odeset
Vereinbarung übergeben werden.
ode15s und ode23t-Code (Trapezformel) wurden so getrimmt, dass man DAEs vom Index 1
entsprechend einfach, d. h. wie ODEs lösen kann. Die Codes erkennen an der Singularität von
M zum Anfangszeitpunkt eine DAE und bestimmen selbstständig die konsistenten Anfangsbe-
dingungen. Die Singularitätsbestimmung von M kann vom Benutzer durch
’MassSingular’, ’yes’ | ’no’ | {’maybe’}
gesteuert werden.
Da die Singularitätsbestimmung einer Diagonalmatrix, u. a. M , unproblematisch ist, nehmen
diese Systeme eine Sonderstellung ein und können leicht auf die semi-explizite Form
u̇u = f D (t, u , λ ) explizites Differenzialgleichungssystem

(5.33)
0 = g (t, u , λ ) implizites algebraisches Gleichungssystem
vom Index 1, d. h. ∂gg/∂λ λ regulär, gebracht werden. Dies gilt insbesondere bei konstanter Mas-
senmatrix.
Unter Simulink können direkt keine differenzial-algebraische Gleichungen gelöst werden. Es
lässt sich aber zeigen, dass in (5.33) λ eliminiert werden kann – vgl. Abschn. 5.4.4 – und somit
eine ODE vorliegt, so dass alle MATLAB-Integratoren eingesetzt werden können, vgl. [62]. Dies
ist der Grundgedanke für ein Simulink-Modell, dessen Struktur in Bild 5.13 wiedergegeben ist.
Das Subsystem (DGL) beschreibt die Differenzialgleichung (5.33)1 , das Subsystem (algebr.
Gleichung) die algebraische Gleichung (5.33)2 , welche mit dem Algebraic Constraint Block
4 Public domain Codes unter C- bzw. FORTRAN: DASSL, LSODI, SPRINT

Bild 5.13: Simulink-Modell für semi-explizite DAE vom Index 1
gelöst wird. Für diese ODE-Näherung können alle Standard-ODE-Löser angesetzt werden. Der
Unterschied zum gewöhnlichen ODE-Löser ist, dass der Integrator zu jedem Zeitpunkt den Wert
von f D (t, u , λ ) für bekannte (t, u , λ ) benötigt, demzufolge muss die algebraische Gleichung
0 = g (t, u , λ ) zunächst nach λ aufgelöst werden. Dies erfolgt, ausgehend von Startwerten,
iterativ mit Hilfe der Fixpunktmethode; die Differenzialgleichung kann zum nächsten Zeitschritt
gelöst werden. Durch diese Formulierung entstehen algebraische Schleifen, die keine Probleme
bereiten solange das Verfahren konvergiert, vgl. auch algeb_gl.mdl in [52].
5.4.3 Mechanische Bewegungsgleichungen mit algebraischen Bindungsgleichungen

In mechanischen Systemen beschreiben die Differenzialgleichungen üblicherweise die Dynamik
der Teilsysteme, während die algebraischen Gleichungen die Zwangsbedingungen oder Bindun-
gen z. B. infolge von Gelenken charakterisieren. Darüber hinaus erfordert die Komplexität vieler
dynamischer Prozesse bei der Modellbildung eine verstärkte Modularität. Man führt deshalb
Subsysteme und ihre mathematische Formulierung ein. Ein solcher modularer Aufbau erleich-
tert die Modellbildung und vereinfacht u. a. die Überschaubarkeit des Gesamtsystems. Bei die-
sem verkopplungsorientierten Modellierungskonzept treten zwangsläufig redundante Koordina-
ten bei der Systembeschreibung auf. Typischerweise sind diese Systeme dann gekennzeichnet
durch Differenzialgleichungen, die die Dynamik beschreiben, und durch algebraische Gleichun-
gen, die die Kopplungen bzw. Bindungen5 festlegen. Die Gesamtbeschreibung erfolgt demnach
durch differenzial-algebraische Gleichungen.
5.4.3.1 Lagrange’sche Gleichung 1. Art

Die L AGRANGEschen Gleichungen 1. und 2. Art beschreiben das dynamische Verhalten mecha-
nischer Systeme mit endlich vielen Freiheitsgraden [56]. Die beiden Gleichungsarten unterschei-
den sich in der Behandlung von kinematischen Zwangsbedingungen. Falls die Systemkinematik
durch f verallgemeinerte Koordinaten q beschrieben wird, die die Zwangsbedingungen erfüllen,
dann können die L AGRANGEschen Gleichungen 2. Art angewandt werden, die ausschließlich auf
Differenzialgleichungen führen, vgl. Abschn. 2.5. Werden dagegen n p redundante Lagekoordina-
ten p verwendet, so müssen diese die nZ zweiseitigen6 , holonomen skleronomen bzw. rheonomen
5 Die Bewegungsfreiheit wird durch eine oder mehrere Lagegrößen eingeschränkt (mechanische Bindungen). Zeitin-
variante Bindungen heißen skleronome Bindungen, zeitvariante rheonome Bindungen. Bindungen, die nur von den
Lagekoordinaten p und nicht von den Geschwindigkeiten ṗp abhängen, bezeichnet man als holonom
6 Im Gegensatz zu einseitigen Bindungen, wie bei Abhebemöglichkeiten
Zwangsbedingungen
g (pp) = 0 , bzw. g (pp, t) = 0 (5.34)
explizit erfüllen, dies führt auf die L AGRANGEschen Gleichungen 1. Art [35]:
T T T
d ∂T ∂T ∂V
− + = Q + G T (pp) λ . (5.35)
dt ∂ ṗp ∂p ∂p
Hierbei ist T die kinetische und V die potentielle Energie und Q beschreibt die nichtkonservativen
Kräfte/Momente, wie in Abschn. 2.5, und G T (pp) λ die verallgemeinerten Reaktionskräfte, wobei
G die JACOBI-Matrix der Zwangsbedingungen
∂gg(pp, t)
G = G (pp, t) = (5.36)
∂p
und λ der nZ -Vektor der L AGRANGEschen Multiplikatoren (Koordinaten der verallgemeinerten

Reaktionskräfte) ist.
Da die zweiseitigen Bindungen (5.34) implizite Gleichungen in den Lagekoordinaten p sind,
werden sie auch als implizite Bindungen bezeichnet. Durch die Wahl unabhängiger Koordinaten,
siehe Abschn. 5.4.5, werden daraus explizite Bindungen. Anschaulich stellen (5.34) Bindungsflä-
chen (Hyperflächen) im Raum/Ebene der Lagekoordinaten p des Systems dar. Bei skleronomen
Bindungen sind die Flächen/Kurven zeitlich konstant, siehe u. a. Abschn. 5.4.3.4, bei rheonomen
zeitlich veränderlich, siehe Beispiele in Rheobind.pdf [52]. Demnach bilden die Zeilen von
G (pp, t) in (5.36) zu einem festen Zeitpunkt t eine Basis des orthogonalen Komplements des Tan-
gentialraums im Punkt p (t) der Bindungsfläche und geben somit die Richtungen vor, in denen
die Zwangskräfte wirken müssen, um eine Bewegung auf der Bindungsfläche zu erzwingen. Die
skalaren Werte der Zwangskräfte, gemessen in diesen Richtungen, sind die Komponenten von λ .
Anmerkung: Holonome Bindungen schränken die Lage- und Geschwindigkeit eines Mehrkörper-
systems ein, nichtholonome Bindungen, vgl. Abschn. 5.4.5.2, nur die Geschwindigkeitsgrößen.
Bei einseitigen holonomen Bindungen kann das System die Bindungsfläche nach einer Seite
verlassen, z. B. g ≥ 0 .
5.4.3.2 Strukturen differenzial-algebraischer Gleichungen mit holonomen Bindungen
Die L AGRANGEsche Gleichung (5.35) oder die N EWTON -E ULER-Methode nach Abschn. 2.4
führen auf Bewegungsgleichungen in Deskriptorform mit den holonomen Bindungen (5.34)
ṗp = v n p kinematische Differenzialgleichung

G (pp, t) λ
M (pp)v̇v = f (pp, v , t) +G T
n p kinetische Differenzialgleichung (5.37)
0 = g (pp, t) nZ algebraische Gleichung.
M (pp) ist die n p ×n p -Massenmatrix (symmetrisch, positiv definit) und f (pp, v , t) der n p -Vektor der
verallgemeinerten eingeprägten Kräfte, Kreisel- sowie Zentrifugalkräfte. (5.37) ist eine differen-
zial-algebraische Gleichung vom Index 3 eines mechanischen Systems.
Mit dem Hypervektor y = [ p T , v T , λ T ]T folgt für (5.37)

⎡ ⎤⎡ ⎤ ⎡ ⎤
E 0 0 ṗp v
⎣ 0 M (pp) 0 ⎦ ⎣ v̇v ⎦ = ⎣ f (pp, v , t) +G GT (pp, t) λ ⎦ . (5.38)
0 0 0 λ
λ̇ g (pp, t)
Dies ist die allgemeine Form gewöhnlicher differenzial-algebraischer Gleichungen
M (yy) ẏy = f (yy, t) (5.39)
mit der Deskriptorvariable y und der singulären Matrix M . Ist die Massenmatrix M invertierbar,
dann ist (5.39) darstellbar als semi-explizite differenzial-algebraische Gleichungen, vgl. (5.33):
u̇u = f D (uu, λ , t) Differenzialgleichungen in expliziter Form

(5.40)
0 = f A (uu, λ , t) algebraische Gleichungen, implizit
mit

v
u = [ p T , ṗpT ]T = [ p T , v T ]T ; f D (uu, λ , t) = , f A (uu, λ , t) = g (pp, t) .
M −1 ( f +GGT λ )
Gesucht sind die Lösungen y (t) = [ p T (t) v T (t) λ T (t) ]T des Anfangswertproblems (5.38) bzw.
entsprechend für (5.40) zu den Anfangsbedingungen y (t0 ) = y 0 d. h. [ p T (t0 ), v T (t0 ), λ T (t0 ) ]T =
[ p T0 , v T0 , λ T0 ]T . Die Anfangsbedingungen müssen auch die Bindungen (5.34) erfüllen.
5.4.3.3 Das Problem vom Index 1
Die Modellierung mechanischer Mehrkörpersysteme mit der L AGRANGEschen Gleichung ers-

ter Art oder dem E ULER -L AGRANGE-Ansatz ergeben stets Index-3-Probleme (5.37), wobei die
Bindungsgleichungen/Nebenbedingungen (5.34) auf Lageebene formuliert sind.
Allgemein unterscheidet man Bindungen auf Lage-, Geschwindigkeits- und Beschleunigungs-
ebene, denen jeweils 0 = g (pp), 0 = ġg(pp, ṗp), 0 = g̈g(pp, ṗp, p̈p) zuzuordnen ist.
Unter MATLAB können nur Systeme vom Index 1 bearbeitet werden. Um (5.37) in ein Index-
1-Problem zu überführen, muss nach Abschn. 5.4.1 die Bindungsgleichung (5.34) zweimal nach
t differenziert werden:
∂gg ∂gg ∂gg
ġg = ṗp + = G ṗp +
∂p ∂t ∂t

2
dg ∂gg ∂ ∂gg ∂ 2g ∂ 2g
g̈g = 2 = p̈p + ṗp ṗp + 2 ṗp + 2 (5.41)
dt ∂p ∂p ∂p ∂ p ∂t ∂t
= G p̈p + γ (pp, ṗp, t) und mit p̈p = v̇v aus (5.37)2
−1

= GM f +G G λ +γγ .
T
Das Index-1-Problem enthält damit Bindungen auf Beschleunigungsebene

ṗp = v
M (pp)v̇v = f (pp, v , t) +GGT (pp, t) λ
(5.42)
0 = G(pp, t)v̇v + γ (pp, v, t) und mit v̇v nach (5.42)2

M (pp)−1 f (pp, v , t) +G
!
= G (pp, t)M GT (pp, t) λ +γγ (pp, ṗp, t) .
Ausgehend von geeignet gewählten Anfangswerten p (t0 ) = p 0 , v (t0 ) = v 0 , λ (t0 ) = λ 0 existieren

Lösungen p (t), v (t), λ (t). Es sind aber nur solche Lösungen p (t), v (t), λ (t) von (5.42) zugleich
auch Lösungen der DAE (5.37), welche die in (5.42) nicht berücksichtigten versteckten Bindun-
gen auf Lage- und Geschwindigkeitsebene erfüllen, also
∂gg(pp, t)
0 = g (pp, t), 0 = G (pp, t)vv + . (5.43)
∂t
Die Anfangswerte p 0 , v 0 , λ 0 müssen einerseits diese Bedingungen erfüllen (konsistente Anfangs-
bedingungen):
0 = g (pp0 , t0 ) Bedingung für Anfangslage p 0

g (pp, t) (5.44)
0 = G (pp0 , t0 )vv0 + |p =pp0 , t=t0 Bedingung für Anfangsgeschw. v 0
∂t
andererseits aber auch die auf Beschleunigungsebene aus (5.42)3 in der Form

M (pp0 )−1 f (pp0 , v 0 , t0 ) +G
0 = G (pp0 , t0 )M GT (pp0 , t0 ) λ 0 +γγ (pp0 , ṗp0 , t0 ) . (5.45)
Unter MATLAB können die Integratoren ode15s, ode23t (implizite BDF- bzw. NDF-Mehrschritt-
verfahren) nur für Index-1-Probleme verwendet werden. Die Anfangswerte p 0 , v 0 müssen die
konsistenten Anfangswerte (5.44) erfüllen, (5.45) wird dagegen automatisch numerisch erfüllt.
Einen Überblick bezüglich Lösungsalgorithmen für höhere Index-Probleme finden wir in [3],
[15]. Implizite Integrations-Methoden lösen Index-1-Probleme, ohne die Zwangs- bzw. Neben-
bedingungen differenzieren zu müssen, vgl. Abschn. 5.5.
5.4.3.4 Erläuterung der Vorgehensweise am Beispiel
Bild 5.14: Mathematisches Pendel, Schnittbild, Anfangszustand

Die Vorgehensweise soll anhand des mathematischen Pendels (Punktmasse m, Pendellänge L)

aus Bild 5.14, als einfachster Vertreter einer offenen Schleife, erläutert werden. Das System hat
einen Freiheitsgrad. Mit den n p = 2 Lagekoordinaten p1 , p2 führen wir redundante Koordinaten
ein, deren Abhängigkeit in der Bindungsgleichung – Pendel muss sich auf einer Kreisbahn bewe-
gen – zum Ausdruck kommt. Ausgehend von der L AGRANGEschen Gleichung 1. Art (5.35) oder
vom Impulssatz (2.64) für den freigeschnittenen Körper in Bild 5.14 folgt mit p = [p1 , p2 ]T :
[ ṗ1 , ṗ2 ]T = [ v1 , v2 ]T → ṗp = v

m 0 v̇1 0 2p1
= + λ → M v̇v = f +G
GT (pp) λ (5.46)
0 m v̇2 −mgr 2p2
0 = p21 + p22 − L2 , Lageebene → 0 = g(pp) .
Physikalisch lassen sich die Ausdrücke ∂ g/∂ p j λ = 2p j λ deuten als die den generalisierten Ko-
ordinaten p j zugeordneten generalisierten Reaktionskräfte/momente, durch die die Einhaltung
der Bindungsgleichung erzwungen wird, vgl. Bild 5.14.
Das System (5.46) ist vom Index 3, was unter MATLAB so nicht direkt lösbar ist, wir überfüh-
ren es deshalb, wie in (5.41), durch zweimalige zeitliche Differenziation der Bindungsgleichung
in ein Index-1-Problem:
0 = G (pp)vv
= 2(p1 v1 + p2 v2 ), Index 2, Geschwindigkeits-Ebene
(5.47)
0 = G (pp)v̇v + γ(vv)
= 2( p1 v̇1 + p2 v̇2 + v21 + v22 ), Index 1, Beschleunigungs-Ebene .
Setzen wir v̇v = [v̇1 , v̇2 ]T aus (5.46)2 noch ein – entspricht (5.42)3 –, so folgt
2
M −1 f +G
0 = G (pp)M GT (pp) λ + γ(vv) = 2(− gr p2 + (p21 + p22 )λ + v21 + v22 ) . (5.48)
m
Damit liegt das Index-1-System vor:
ṗp = v
GT (pp) λ
M v̇v = f +G (5.49)
0 = G (pp)v̇v + γ(vv)
mit M , G (pp), f nach (5.46) sowie γ = 2( v21 + v22 ) nach (5.47)2 . Schließlich erhalten wir mit
y = [ y1 , y2 , y3 , y4 , y5 ]T = [ p1 , p2 , v1 , v2 , λ ]T die allgemeine Form
M ẏy = f (yy), M = diag(1 1 m m 0) singulär , (5.50)
bzw. mit
u = [ u1 , u2 , u3 , u4 ]T = [ p1 , p2 , ṗ1 , ṗ2 ]T , ṗ j = v j (5.51)

die semi-explizite Form (5.40)

T
2 2
u̇u = u3 , u4 , λ u1 , λ u2 − gr
m m
(5.52)
p2 + p22
0= u23 + u24 +2 1 λ − gr u2 , L =
2
p21 + p22 .
m
Ausgehend von dem allgemeinen Anfangszustand ϕ0 , ϕ̇0 nach Bild 5.14 ergeben sich die konsis-
tenten Anfangswerte

sin ϕ0 cos ϕ0
p0 = L ṗ 0 = 0 = Lϕ̇0
p v (5.53)
− cos ϕ0 sin ϕ0
sowie aus (5.52)2

1 gr
λ0 = − m cos ϕ0 + ϕ̇02 . (5.54)
2 L
(5.53), (5.54) erfüllen die Bindungen auf Lage-, Geschwindigkeits- und Beschleunigungsebene.
Numerische Vorgehensweisen
Die folgende numerische Auswertung soll einerseits skriptorientiert unter MATLAB und anderer-
seits als Simulink-Modell nach Bild 5.13 erfolgen.
Skriptoriente Vorgehensweise: Wir arbeiten mit (5.50), also ohne explizite Invertierung von
M . D. h. ẏy = f (yy) und M müssen separat programmiert werden. Da M konstant ist, erfolgt
deren Vereinbarung einmalig im Hauptprogramm mathp.m. Hinweis: Zweckmäßiger ist die
semi-explizite Form, es braucht v̇v in (5.49) nicht eliminiert werden, vgl. Beispiele in Rheo-
bind.pdf [52]. Für ẏy = f (yy) ist die Function fmathp.m angelegt. Die Anfangswerte müs-
sen die Bindungen (5.44), d. h. (5.46)3 und (5.47) zum Zeitpunkt t0 , erfüllen. Dies geschieht
mit (5.53), wobei ϕ0 , ϕ̇0 vorzugeben sind. Bindung (5.48) wird numerisch durch den Integra-
tor erfüllt, so dass für λ0 nur ein Näherungswert vorzugeben ist, z. B. y 0 = [ L, 0, 0, 0, 0.5 ]T ,
ẏy(0) = 0 . In mathp_1.pdf [52] wird gezeigt, wie sich mit der MATLAB Function decic – vgl.
Abschn. 5.5 – konsistente Anfangswerte berechnen lassen, vgl. auch mathp_10.m. Wesentli-
che Programmausschnitte des Hauptprogramms mathp.m und der Function fmathp.m, vgl.
[52], geben wir an:
Die Function fmathp.m enthält die rechte Seite der Differenzialgleichung (5.52).
Function: fmathp.m
function yp = fmathp(t, y, m, L, gr) % Function
yp = [ y(3); y(4); % Identität
+ 2 * y(1) * y(5) % Differenzialgl.
+ 2 * y(2) * y(5) - m * gr
y(3)ˆ2 + y(4)ˆ2...
- gr * y(2) + 2 * Lˆ2/m * y(5) ]; % Bindung
Hauptprogramm: mathp.m
clear, close all
m = 1; % Masse
L = 1; % Pendellänge
gr= 9.81; % Erdbeschl.
y0 = zeros(5,1); % spezielle
y0(1) = L; % Anfangswerte
M = diag([1 1 m m 0]); % ’Massenmatrix’
options =odeset(’Mass’,M,... % Optionen
’MassSingular’,’yes’...
,RelTol’,1.0e-5);
[t, x] = ode15s(@fmathp,[0 10], y0,... % Integrationsaufruf
options,m ,L, gr); % mit Parameterübergabe
plot(t,x(:,1:4) % Plot-Ausg.
Simulink-Modell: Parallel dazu erstellen wir das Simulink Modell mathp_S.mdl nach
Bild 5.13. Mit (5.52) lassen sich die darin enthaltenen Subsysteme modellieren. Das Subsys-
tem (DGL) in Bild 5.15 a beschreibt u̇u = M −1 f D (uu, λ ) (5.52)1 – die Zeit t (Eingang: In3) tritt
nicht explizit auf –, das Subsystem (algebr. Gleichung) in Bild 5.15 b die algebraische
Gleichung 0 = g̈(uu, λ ) (5.52)2 mit dem Algebraic Constraint Block. Als Anfangsvektor ist u (0),
er muss (5.46)3 und (5.47)1 zum Zeitpunkt t0 = 0 erfüllen, vorzugeben. λ (0) wird, ausgehend
von einem Startwert, der in der Dialogbox des Algebraic Constraint Block einzutragen ist, mit
(5.52)2 ermittelt. Damit sind die Anfangswerte konsistent, vgl. auch mathp_10.m in [52]. Zur
a: Differenzialgleichung b: Algebraische Gleichung
Bild 5.15: Subsysteme zum Simulink-Modell des Pendels; mathp_S.mdl, mathp_Sa.m
Simulation mit dem Simulink-Modell sind alle ODE-Integratoren zulässig. Das RUNGE -K UTTA-
Verfahren ode45 lieferte die stabilsten Ergebnisse.
Bild 5.16 zeigt für die Parameter: m=1 kg, L=1 m, gr =9,81 m/s2 und u (0) = (L,0,0,0)T ein
Simulationsergebnis in Form von p1 (t), p2 (t) sowie die Bindungskraft f (t) in der masselosen
Bild 5.16: Simulationsergebnisse mit Simulink-Modell
Verbindungsstange:
∂ g(pp) ∂ g(pp) !
f p1 = λ; f p2 = λ; f = − f p21 + f p22 .
∂ p1 ∂ p2
Beurteilung beider Modellierungen: Die Verfügbarkeit der Bindungskräfte ist ein wichtiger
Aspekt für eine derartige Vorgehensweise. Nachteilig ist aufgrund der redundanten Koordinaten
die höhere Ordnung des Gleichungssystems gegenüber einer Formulierung in Minimalkoordi-
naten (5.77). Darüber hinaus muss in der Regel mit kleineren Schrittweiten gearbeitet werden,
um die Bindungsgleichungen nicht zu verletzen. Wird nämlich in unserem Beispiel über einen
größeres Zeitintervall te > 10 s mit RelTol 1e-04 integriert, dann weisen die Ergebnisse –
abhängig von den Anfangsbedingungen – numerische Instabilität auf, insbesondere erkennbar in
x(5) = λ (t), d. h. aufgrund von Diskretisierungs- und Rundungsfehlern stellt sich eine Lösung
ein, die die Bindungsgleichungen (5.46)3 , (5.47) auf Lage-, Geschwindigkeits- und Beschleuni-
gungsebene nicht mehr erfüllt. Mit zunehmender Zeit wächst dieser Fehler rasch an. Dies ist ein
bekanntes Problem bei der Bearbeitung von DAEs. Insbesondere treten diese numerischen Insta-
bilitäten, so genannte Drift-Effekte, in Index-1-Problemen auf, bei denen die Bindungen auf Be-
schleunigungsebene formuliert sind, vgl. Bild 5.19. Abhilfe bietet eine größere Genauigkeit bei
der Integration, z. B. ’RelTol’,1.0e-05 und kleiner, oder das Einführen von Stabilisierungs-
Methoden [5], [15], [68] sowie Abschn. 5.4.4 und Kapitel 7.
Wenn möglich, ist deshalb eine Formulierung als ODE in Minimalkoordinaten anzustreben,
um einerseits numerisch stabilere Modelle zu integrieren und andererseits Rechenzeit zu sparen.
Muss das differenzial-algebraische System vom Index 1 dennoch unter MATLAB oder Simulink
integriert werden, so zeigen Systeme, in denen einerseits λ eliminiert, andererseits durch noch-
malige Differenziation der Bindungsgleichung ein gewöhnliches Differenzialgleichungssystem
erzeugt wird, teilweise eine etwas bessere Handhabung. Die Drift-Effekte können dadurch aber
nicht unterdrückt werden. Bezogen auf das Pendel bedeutet dies: Einerseits lässt sich aus der Bin-
dungsgleichung (5.48) λ ermitteln und somit in (5.46)1 eliminieren, es bleibt ein gewöhnliches
Differenzialgleichungssystem 4. Ordnung, andererseits kann die Bindungsgleichung nochmals
nach der Zeit differenziert werden, so dass wegen λ̇ ein System 5. Ordnung zu integrieren ist.
Übungsvorschlag: Durch Differenziation der Bindungsgleichung in (5.52) erhält man eine Dif-
ferenzialgleichung für λ̇ , so dass insgesamt ein gewöhnliches Differenzialgleichungssystem vor-
liegt. Erstellen Sie hierfür ein Simulink-Modell sowie ein Scriptfile und vergleichen Sie die er-
haltenen Ergebnisse mit denen aus der differenzial-algebraischen Gleichung (5.52) für einige
Integrationsintervalle und Toleranzangaben, vgl. Bemerkungen aus Abschn. 5.4.4.
Hilfe in: mathp_S1.mdl, mathp_1.m, mathp_10.m sowie mathp_1.pdf aus [52].
5.4.4 Überführung in gewöhnliche Differenzialgleichungen
Abschließend wollen wir die erwähnten Umformungen, mit denen sowohl eine MATLAB- als
auch eine Simulink-Modellierung möglich wird, verallgemeinern. Zur Simulation können alle
Integratoren eingesetzt werden. Die Drift-Effekte der Lösungen bleiben erhalten. Darüber hinaus
werden Parallelen zu der in Kapitel 7 skizzierten Arbeitsweise von SimMechanics sowie der
zugehörigen Parametereinstellungen erkennbar und verständlicher.
Der Betrachtung legen wir ein allgemeines mechanische Modell vom Index 1 zugrunde
∂gg(pp, t)
M p̈p = f (pp, ṗp, t) + G T (pp, t) λ , G (pp, t) =
∂qq (5.55)
0 = G (pp, t)p̈p +γγ (pp, ṗp, t) .
Mit (5.55) und v = ṗp erhalten wir unmittelbar ein für die numerische Vorgehensweise bedingt
geeignetes Gleichungssystem vom Index 1
⎡ ⎤⎡ ⎤ ⎡ ⎤
E 0 0 ṗp v
⎣ 0 M G T ⎦ ⎣ v̇v ⎦ = ⎣ f ⎦ , v = ṗp, E Einheitsmatrix . (5.56)
0 G 0 −λ λ −γγ
Falls die Massenmatrix M positiv definit ist und die Bindungen unabhängig sind, d. h. die JACOBI-
Matrix G vollen Rang hat, ist die Koeffizientenmatrix der linken Seite in (5.56) regulär und damit
invertierbar. Dieses Gleichungssystem ist im Prinzip ausreichend, um für konsistente Anfangsbe-
dingungen
$
p (0) = p 0 , v (0) = v 0 , − λ dt|(0)
T
die Trajektorien von p T , v T , − λ T dt zu ermitteln. Nachteil: Der Kraft- bzw. Momentenbe-
zug über λ ist nicht mehr direkt zugänglich.
Elimination des Multiplikators λ

In einem zweiten Schritt eliminieren wir daher λ in (5.55). Hierzu multiplizieren wir (5.55)1 von
links mit GM −1

Gv̇v = GM −1 f +G
G Tλ ,
so dass wir mit (5.55)2
GM −1 f +GM
GM −1G Tλ = −γγ
finden. Dabei ist GM −1G T regulär, wenn G den vollen Rang besitzt, so dass wir nach λ auflösen
können:
−1
λ = − GM −1G T γ +GGM −1 f . (5.57)
Setzen wir nun λ in die Ausgangsgleichung (5.55)1 ein, dann ergibt sich das explizite gewöhnli-
che Differenzialgleichungssystem (Index 0)
ṗp = v
−1 (5.58)
v̇v = M −1 { E −PGM
PGM −1 f −P
Pγ }, P = G T GM −1G T
für p (t), v (t), womit anschließend aus (5.57) λ (t) berechnet werden kann.
Alle Lösungen p (t), v (t), λ (t) aus (5.58) und (5.57) erfüllen die in (5.58) berücksichtigten
Bindungen auf Beschleunigungsebene (5.55)2 . Damit p (t), v (t) von (5.58) zugleich auch Lö-
sungen der DAE (5.55) sind, müssen auch hier die Anfangswerte p 0 , v 0 die Bindungen (5.44)
erfüllen.
Überführung in eine gewöhnliche Differenzialgleichung für λ

Bilden wir ausgehend von (5.41) die dritte zeitliche Ableitung von g , so erhalten wir zunächst
... ∂φφ ∂ ∂
g = GM −1G Tλ̇
λ+ p̈p + GM −1G Tλ +φφ )ṗp + (GM
(GM GM −1G Tλ +φφ ) = 0 (5.59)
∂ ṗp ∂p ∂t
mit φ = GM −1 f +γγ und damit das gewöhnliche Differenzialgleichungssystem vom Index 0

⎡ ⎤⎡ ⎤ ⎡ ⎤
E 0 0 ṗp v
⎣ 0 M 0 ⎦ ⎣ v̇v ⎦ = ⎣ f +G G λ
T ⎦ , (5.60)
∂φφ ∂ GM −1 T ∂ −1
0 ∂ ṗp GM −1G T λ
λ̇ − ∂ p (GM G λ +φφ )ṗp − ∂t (GM
GM G λ +φφ )
T
womit λ unmittelbar verfügbar ist. Mit (5.56) und insbesondere mit (5.58) und (5.60) wird eine
Simulink-Modellierung möglich. Vergleichbare Schritte müssen deshalb auch unter SimMecha-
nics verfolgt werden. Der Aufwand insbesondere in (5.60) steigt erheblich. Die zeitlichen Ab-
leitungen von g wird man zweckmäßigerweise symbolisch mit der Computeralgebra ausführen.
Die konsistenten Anfangswerte können, wie bereits erwähnt, ausgehend von g = 0 , ġg = 0 , g̈g = 0
mit der MATLAB Function decic aus Abschn. 5.5 iterativ berechnet werden. Dabei sind einige
Komponenten von p(0), ṗp(0) festzuschreiben, für die restlichen sind Schätzwerte vorzugeben.
Nicht jede Kombination führt zum Ziel.
Diesbezügliche Anwendungen zum Pendel nach Bild 5.14 sind mit mathp_1.m,
mathp_S1.mdl, mathp_10.m aus [52] durchführbar. In mathp_1.pdf sind einige Bemer-
kungen zu finden.
Beispiel 5.8: Anwendung auf ein Kurbeltrieb

Die Vorgehensweise bezüglich der Elimination von λ wenden wir auf den Schubkur-
beltrieb nach Bild 5.17 – er hat einen Freiheitsgrad – an.
Bild 5.17: I Doppelpendel, II Schubkurbeltrieb
Zur Beschreibung der Kinematik des Schubkurbeltriebs kann z. B. das Schubgelenk

geschnitten werden. Der so entstandene aufgespannte Baum bzw. das offene Schleifen-
system entspricht dem des Doppelpendels. Die Bewegungsgleichungen lassen sich mit
den Methoden aus Kapitel 2 herleiten. Wir erhalten
M (qq)q̈q +kk (qq, q̇q) = h (qq) (5.61)
mit der Massenmatrix

(m1 + m2 )21 −m2 1 2 cos (α + β )
M= (5.62)
−m2 1 2 cos (α + β ) m2 22
und den Vektoren

m2 1 2 β̇ 2 sin (α + β ) −(m1 + m2 )g1 sin α
k= ; h= (5.63)
m2 1 2 α̇ 2 sin (α + β ) −m2 g2 sin β
sowie dem Koordinatenvektor
q T = (α, β ), Minimalkoordinaten für das Doppelpendel. (5.64)
Da der Schubkurbeltrieb nur einen Freiheitsgrad hat, führen wir mit α, β redundan-
te Koordinaten p T = [α, β ] ein. Dies ist mit der zusätzlichen holonomen Schleifen-
Schließbedingung s = 0 nach Bild 5.17 (Zwangsbedingung, Bindung), der algebrai-
schen Gleichung (s → g)
g(α, β ) = 1 sin α − 2 sin β = 0, (5.65)
zu berücksichtigen. Es sind nun zwei Vorgehensweisen denkbar:

• Beschreibung in Minimalkoordinaten: Wir arbeiten die Abhängigkeit von α und
β , z. B. durch Elimination von β , in die Bewegungsgleichung ein. Es folgt ei-

ne gewöhnliche Differenzialgleichung – mit länglichen Termen – für α(t). Bei
Systemen höherer Ordnung ist dies kaum durchführbar, vgl. Abschn. 5.4.5.
• Wir arbeiten mit den modifizierten Bewegungsgleichungen (5.61), die dann nicht
in Minimalkoordinaten formuliert sind, und den algebraischen Gleichungen
(5.65). Hierzu bedarf es einer speziellen Aufbereitung, die wir bezogen auf das
Beispiel stichwortartig angeben wollen.
Man führt formal die Bindungs-JACOBI-Matrix
∂ g(pp)
G (pp) = = [1 cos α, −2 cos β ] , p = (α, β )T (5.66)
∂p
der Schließbedingung mittels L AGRANGEschem Multiplikator λ (im Allgemeinen

Vektoren), der die Reaktionskräfte im geschnittenen Gelenk berücksichtigt, (5.61) hin-
zu und beachtet die Index-1-Bedingung, so dass
M (pp)p̈p +kk (pp, ṗp) −G

GT (pp) λ = h (pp) (5.67)

∂ ∂ g(pp)
G (pp)p̈p = −γ(pp, ṗp), γ= ṗp ṗp (5.68)
p ∂p
folgt. Die zulässigen Anfangswerte p 0 , ṗp0 , λ0 müssen die Bindungen (5.44) und (5.45)
erfüllen. Damit ist das System als DAE vollständig beschrieben.
Wir wollen hier das Problem als gewöhnliches Differenzialgleichungssystem be-
handeln. Dafür bieten sich die Formulierungen (5.56), (5.58) und (5.60) an, wobei
wir hier (5.58) programmieren. Die Anfangswerte α(0) = α0 , β (0) = β0 , α̇(0) = α̇0 ,
β̇ (0) = β̇0 müssen die beiden Bindungsgleichungen
0 = g(pp0 ) = 1 sin α0 − 2 sin β0

α̇0
0 = G T (pp0 ) ṗp0 = [1 cos α0 , −2 cos β0 ]
β̇0
erfüllen. Geben wir α0 und α̇0 vor, dann genügen β0 und β̇0 den Bedingungen
1 1 cos α0
β0 = arcsin( sin α0 ), β̇0 = α̇0 .
2 2 cos β0
Als Integrationsverfahren wählen wir ode45. Das Hauptprogrammsegment aus DAE_K,

[52] mit der Berechnung der Anfangswerte und des Integratoraufrufs enthält folgende
Befehle
Hauptprogramm: DAE_K.m zu IST=3

t0=0; te=pi; % Anfangs-, Endzeitpunkt
a0=pi/4; % Anfangswerte: a0:=α(0)
b0=asin(l1/l2*sin(a0)); % bo:= β (0)
ap0=12.59995; % ap0:=α̇(0)
bp0=l1/l2*ap0*cos(a0)/cos(b0); % bp0:=β̇ (0)
y0=[a0; b0; ap0; bp0]; % Anfangswertvektor
ode45(@fdae_k,[t0 te],y0) % Integratoraufruf
Dabei ist α̇ ≥ 12,59995 rad/s zu wählen, wenn vollständige Kurbeldrehungen erreicht

werden sollen. Die zugehörige Function des Differenzialgleichungssystems (5.58) lau-
tet mit γ = −1 sin α α̇ 2 + 2 sin β β̇ 2 : Function: fdae_k.m zu IST=3
function [yp] = fdae_k(t,y) % y:=[p’,v’]’
global m1 m2 l1 l2 g
cab=cos(y(1)+y(2)); % Abkürzungen
sab=sin(y(1)+y(2));
M=[(m1+m2)*l1ˆ2 -m2*l1*l2*cab; % Massenmatrix
-m2*l1*l2*cab m2*l2ˆ2];
k=[m2*l1*l2*y(4)ˆ2*sab; % k-Vektor
m2*l1*l2*y(3)ˆ2*sab];
h=[-(m1+m2)*g*l1*sin(y(1)); % h-Vektor
-m2*g*l2*sin(y(2))];
G=[l1*cos(y(1))-l2*cos(y(2))]; % Bindungs-JACOBI-Matrix
gam=l2*y(4)ˆ2*sin(y(2))...
-l1*y(3)ˆ2*sin(y(1)); % gam:=γ
M_1=inv(M); % Inverse von M
P=G’*inv(G*M_1*G’); % Abkürzung
yp=[y(3:4); M_1*((eye(2)- ... % Ableitungsfunktion
P*G*M_1)*(h-k)-P*gam)]; % (5.58)
In DAE_K.m aus [52] sind die hier vorgestellten Wege programmiert. Sie sind mit
dem Steuerparameter IST auszuwählen:
−1
IST = 1: M ẏy = f (yy), (5.56), IST = 2: ẏy = M f (yy), (5.56)
IST = 3: (5.58), λ eliminiert, IST = 4: gew. Dgl. (5.60) mit λ̇ .
In Bild 5.18 ist ein Ergebnis dargestellt. Danach läuft infolge der vorgegebenen An-
fangswerte die Kurbel um, wobei im unteren Totpunkt aufgrund von α̇(0) Kurbel und
Pleuel nahezu zur Ruhe kommen, vgl. α̇, β̇ und die Animation mit Kurbel_q0.m
in [52]. Beim Durchgang der oberen Totpunktlage sind α̇, β̇ maximal. Hierzu ge-
hört auch eine starke Änderung der Normalkraft (λ ) am Gleitschuh. Weitere Bei-
spielrechnungen zeigen wieder Drift-Effekte, wenn mit ’RelTol’,10e-04 gerech-
net wird. Die Bindungsgleichungen werden mit fortschreitender Zeit immer schlech-
ter erfüllt. Abhilfe bietet wieder nur eine Integration mit kleiner Fehlertoleranz, z. B.
’RelTol’,
1e-05...1e-06. Die stabilsten Ergebnisse wurden mit (5.58), IST=3 erreicht.
Bild 5.18: Simulationsergebnisse zum Kurbeltrieb
5.4.4.1 Bemerkung zur Drift-Unterdrückung
Aufgrund der numerischen Drift bei der Lösung sowohl von Index-1-DAEs (5.42) als auch der
überführten ODEs (5.58), (5.60) müssen in der Regel zur abgesicherten Integration numerische
Stabilisierungsmethoden, wie u. a. in [5], [15] und [67] beschrieben, eingeführt werden. Es sollen
die beiden Methoden: 1. BAUMGARTE-Stabilisierung, 2. Projektionsmethode skizziert werden.
Bild 5.19: Drift der Lösung
Die BAUMGARTE-Stabilisierung nach [5] versucht die Schließbedingungen durch hinzufügen

von Termen zu stabilisieren, so dass trotz Integrationsfehler u. a. g → 0 näherungsweise eingehal-
ten wird. D. h. verlässt die Lösung p (t) die Bindungsmannigfaltigkeit g (pp), wie in Bild 5.19 für
eine Bindungsfläche g(pp) = 0 angedeutet, so wird durch geeignet eingeführte Zusatzterme die-
se zurückgeführt. Bezogen auf die Index-1-DAE (5.42) mit holonomen skleronomen Bindungen
bedeutet dies:
ṗp = v
M (pp)v̇v = f (pp, v , t) +G
GT (pp) λ
(5.69)
0 = G (pp)v̇v + γ (t, v , p ) +2d G (pp)vv + ω 2g (pp) .

g̈g ġg
Nachteil: Es gibt keine allgemein gültigen Regeln für die Wahl von d und ω in den Zusatztermen.
Darüber hinaus verfälschen diese Terme die Systemdynamik geringfügig.
Für das Pendel und den Kurbeltrieb bedeutet dies:
g̈ + 2d ġ + ω 2 g = 0; d > 0 , (5.70)
mit geeignet gewähltem d und ω. Dies ist für sich eine homogene Schwingungsgleichung für g
mit asymptotisch stabilem Lösungsverhalten. Setzen wir ġ und g̈ nach (5.41) noch ein, dann folgt
(5.69)3 . Das Hauptproblem ist die Wahl von d und ω in Abhängigkeit von der Fehlertoleranz. In
mathp_St.m [52] ist für das mathematische Pendel aus Abschn. 5.4.3.4 (5.69)3 eingearbeitet.
Bei der Projektionsmethode wird nach jedem Integrationsschritt, dem Prädiktorschritt, die Lö-
sung p Pk+1 zum Zeitpunkt tk+1 wieder auf die Bindungsmanigfaltigkeit projiziert, so dass sich die
Näherungslösung p k+1 , v k+1 einstellt. Dies führt z. B. auf ein iteratives Minimierungs-Problem
mit nichtlinearen Nebenbedingungen in Form der Bindungen:
2 2
1. p k+1 − p Pk+1 = → min, 2. v k+1 −vvPk+1 = → min
g (ppk+1 ) = 0 G (ppk+1 )vvk+1 = 0 .
Beide Stabilisierungsmethoden sind in SimMechanics, siehe Kapitel 7, implementiert.

Differenzial-algebraische Gleichungen unterliegen also speziellen Vorgehensweisen. U. a. in
[6], [15] findet man einige Ansätze zur Behandlung von DAEs unterschiedlichster Struktur.
5.4.5 Übergang auf Minimalkoordinaten
5.4.5.1 Systeme mit holonomen Bindungen
In der Regel führen differenzial-algebraische Gleichungen auf einfache Strukturen höherer Ord-
nung, verursachen aber bei der Lösung ohne zusätzliche Stabilisierung einige numerische Proble-
me. Man wird deshalb versuchen, durch Einführen f unabhängiger Koordinaten (Minimalkoor-
dinaten) q und Elimination der Reaktionskräfte/momente G Tλ auf gewöhnliche Differenzialglei-
chungen mit f = n p − nZ Freiheitsgraden überzugehen. Dies lässt sich systematisieren, wenn die
n p Lagekoordinaten
p = p (qq, t) (5.71)
durch q ausgedrückt werden; (5.71) werden als explizite Bindungen für die nZ + f Lagekoordi-
naten p bezeichnet, sie erfüllen natürlich die nZ impliziten Bindungen g (pp(qq, t)) = 0 und deren
zeitlichen Ableitungen. Für den übergeordneten Fall der rheonomen Bindungen gilt:
p = p (qq, t)
∂ p (qq, t) ∂ p (qq, t) ∂ p (qq, t)
ṗp = q̇q + = J (pp(qq, t)) q̇q +
∂qq ∂t ∂t (5.72)
∂ 2 p (q
q , t) ∂ 2 p (qq, t)
p̈p = J (pp(qq, t)) q̈q + J˙(pp(qq, t)) q̇q + q̇q + ,
∂qq∂t ∂t 2
vgl. Kapitel 2 und insbesondere Abschn. 2.3.1.3. Sind die Bindungen g (pp) skleronom, dann ent-
fallen auf der rechten Seite in (5.72) die partiellen Ableitungen nach t. Mit (5.72) folgt aus (5.42)2
bei gleichzeitiger Linksmultiplikation mit J T

∂ 2 p (qq, t) ∂ 2 p (qq, t)
J M J q̈q = J
T T
f (qq, q̇q, t) −M
M J q̇q +
˙ q̇q + + J TG Tλ . (5.73)
∂qq∂t ∂t 2
GJ)T = J TG T = 0 ausgeblendet, es bleibt:

Die Bindungskräfte/momente werden wegen (GJ
GJ
Mq q̈q = f q (qq, q̇q, t) (5.74)
mit

∂ 2 p (qq, t) ∂ 2 p (qq, t)
Mq = J M J ,
T
f q = J f (qq, q̇q, t) −JJ M J˙q̇q +
T T
q̇q + .
∂qq∂t ∂t 2
Bei baumstrukturierten Systemen, wie Einfach- und Doppelpendel, lassen sich explizite Bindun-
gen (5.72) auswerten. Bei Schleifensystemen, z. B. Kurbelsystem nach Bild 5.17, ist der Über-
gang auf explizite Bindungen schwieriger, vgl. MinM_pdf.pdf in [52].
Die Bewegungsgleichungen als DAE, insbesondere aber mit anschließendem Übergang auf
eine als ODE für einen Satz von Minimalkoordinaten q , stellen neben der Vorgehensweise aus
Kapitel 2 einen ergänzenden, systematischen Weg zur mathematischen Modellerstellung dar. Es
soll deshalb anhand des Pendels aus Abschn. 5.4.3.4 sowie dreier Varianten eines Systems mit
rheonomen Bindungen diese Methode vertieft werden, siehe auch Kapitel 8, Abschn. 8.8 Balan-
cierender Roboter.
Beispiel 5.9: Mathematisches Pendel: Übergang auf Minimalkoordinaten

Ausgehend von der differenzial-algebraischen Gleichung (5.46) des Pendels nach
Bild 5.14 mit skleronomer Bindung ist die gewöhnliche Differenzialgleichung für die
Minimalkoordinate q = ϕ herzuleiten. Mit ϕ nach Bild 5.14 gilt die explizite Bindung

L sin ϕ
p (ϕ) = , (5.75)
−L cos ϕ
womit sich die JACOBI-Matrix (hier Spaltenvektor) zu

∂ p (ϕ) L cos ϕ
J (ϕ) = = (5.76)
∂ϕ L sin ϕ
berechnet. Aus (5.46)2 folgt mit (5.73) unmittelbar

gr
mL2 ϕ̈ = −mgr L sin ϕ → ϕ̈ = − sin ϕ . (5.77)
L
Übungsvorschlag: Wie lautet die gewöhnliche Differenzialgleichung für die Minimalkoordinate

α(t) des Kurbeltriebs aus Bild 5.17? Hinweise in: MinM_pdf.pdf und Kurbel_q0.m mit
fKurbel_q.m aus [52].
Übungsvorschlag: Die Modelle des mathematischen (Masse m) und physikalischen (Masse m,

Massenträgheitsmoment I (S) ) Pendels (Länge a) sind an einem mit konstanter Winkelgeschwin-
digkeit Ω rotierenden Stab (Lände L) angekoppelt. An den Pendelkörpern soll der Luftwider-
stand (Ansatz nach Abschn. 5.6.4.1) berücksichtigt werden.
• Für beide Systeme mit rheonomen Bindungen sind die Bewegungsgleichungen für die ver-
allgemeinerten Koordinaten p = [x, y]T bzw. p = [x, y, φ ]T aufzustellen und numerisch aus-
zuwerten.
• Wie lauten die Minimalkoordinaten und die zugehörigen Bewegungsgleichungen?
• Warum eignet sich das Pendelmodell zum drehzahladaptiven Drehschwingungstilger? Be-
trachte hierzu die linearisierte Bewegungsgleichung um die gestreckte Lage.
Hinweise in: Rheo_bind.pdf.
Bild 5.20: Übungsvorschlag: Modelle mit rheonomen Bindungen
5.4.5.2 Systeme mit nichtholonomen Bindungen

Neben den Systemen mit holonomen Bindungen in den vorangegangenen Abschnitten können zu-
sätzliche/ausschließliche nichtholonome Bindungen, sie gehören zu den kinematischen Bindun-
gen, auftreten. Holonome Bindungen schränken die Bewegungsfreiheit von Lagegrößen und Ge-
schwindigkeitsgrößen, nichtholonome Bindungen nur die Geschwindigkeitsgrößen ein. Mecha-
nische Modelle sind: rollende starre Räder, Münzen, balancierender Roboter, vgl. Abschn, 8.8.
Die Zahl f der Freiheitsgrade eines Systems aus N starren Körpern mit jeweils sechs Frei-
heitsgraden und r holonomen sowie s nichtholonomen Bindungen reduziert sich auf
f = 6N − r − s. (5.78)
Die s nichtholonomen (Index nh) skleronomen und/oder rheonom Bindungen sind implizit durch
die nichtintegrierbare s × 1 Vektorgleichung
ġgnh (pp, ṗp) = 0 bzw. ġgnh (pp, ṗp, t) (5.79)
mit den redundanten bzw. verallgemeinerten Koordinaten p ṗp beschrieben. Die r holonomen
(Index h) Bindungen formulieren wir hier auf Geschwindigkeitsebene
ġgh (pp, ṗp) = 0 bzw. ġgh (pp, ṗp, t). (5.80)
Holonome und nichtholonome Bindungen werden vektoriell zu

⎡ ⎤
∂ggh (pp, t) ∂ggh
ġgh (pp, ṗp, t) p
ṗ +
ġg = =⎣ ∂p ∂t ⎦ (5.81)
ġgnh (pp, ṗp, t)
ġgnh (pp, ṗp, t)
zusammengefasst und damit die JACOBI-Matrix der Bindungen

⎡ ∂gg (pp, t) ⎤
h
∂ ġg ⎢ ⎥
G = = ⎣ ∂∂ġgp ⎦ (5.82)
∂ ṗp nh
∂ ṗp
gebildet. Hiermit ist schließlich die differenzial-algebraische Gleichung (5.37) auszuwerten.
Anwendung: Kapitel 8, Abschn. 8.8 Balancierender Roboter.
Übergang auf Minimalkoordinaten:

Vorausgesetzt es lassen sich p und ṗp durch die Minimalkoordinaten q , q̇q ausdrücken, dann gilt
ṗp = ṗp(qq, q̇q, t)

∂ ṗp ∂ ṗp ∂ ṗp
p̈p = q̈q + q̇q +
∂ q̇q ∂qq ∂t (5.83)
∂ ṗp
= J q p q̈q + J q q̇q + .
∂t
Setzen wir dies in die zugehörige Bewegungsgleichung
λ + Q nk
M (pp)p̈p = f (pp, ṗp, t) + G T (pp, ṗp)λ (5.84)
ein und multiplizieren von links mit J qTp durch, dann folgt

∂ ṗp
J qTp M (qq) J q p q̈q + J q q̇q + − f (qq, q̇q, t) = J qTp G T λ + J qTp Q nk (5.85)
∂t
wobei J qTp G T = 0 wieder verschwindet – die Zwangskräfte stehen senkrecht auf der Geschwindig-
keitsebene. Der Term Q nk enthält alle nichtkonservativen Kräfte/Momente, einschließlich solcher
aus einem Regeleingriff, vgl. Balancierender Roboter in Abschn. 8.8.
Beispiel 5.10: Die rollende Kugel, Beispiel mit nichtholonomen Bindungen
Bild 5.21: Rollende Kugel und Bezeichnungen, MATLAB-Grafik
Es sind die Bewegungen einer rollenden Kugel/Ball nach Bild 5.21 ( Masse m,
Massenträgheitsmoment Ix bezüglich beliebiger Drehachsen, Radius R) auf einer Ebe-
ne zu untersuchen, d. h. die Relativgeschwindigkeit im Berührungspunkt P ist null, es
tritt kein Schlupf auf. Es handelt sich um einen starren Körper mit einer holonomen
(Kontaktpunkt) und zwei nichtholonomen (Rollbedingung) Bindungen mit
f =6−1−2=3
Freiheitsgraden, vgl: (5.78).

Die (x, y)-Ebene des I-Systems liegt nach Bild 5.21 in der Rollebene. Die Bewe-
gung der freien Kugel beschreiben wir zunächst mit den Translationen I xS , I yS , I zS
des Schwerpunktes S im I-System und den drei K ARDAN-Winkel α, β , γ, vgl. Ab-
schn. 2.3.1.1. Damit lauten die verallgemeinerten Koordinaten und deren zeitlichen
Ableitungen der freien Kugel
T
p = [I xS , I yS , I zS , α, β , γ]T , ṗp = I ẋS , I ẏS , I żS , α̇, β̇ , γ̇ . (5.86)
Die Anbindung der Kugel an die Rollebene erfolgt durch die holonomen, skleronomen
Bindung
!
gh = I zS − R = 0. (5.87)
Nach (2.24) gilt für die verallgemeinerte Geschwindigkeiten

⎡ ⎤ ⎡ ⎤
α̇ α̇
I ω = e 1 , T α e 2 , T α T β e 3 ⎣ β̇ ⎦ = H R ⎣ β̇ ⎦ .
T T T
(5.88)
γ̇ γ̇
Die Rollbedingung ist erfüllt, wenn die Geschwindigkeit der freien Kugel in P
⎡ ⎤ ⎡ ⎤ ⎡ ⎤
I ẋS 0 0
r
ṙ
I 0P = ⎣ ẏ
I S ⎦ + I ω × ⎣ 0 ⎦ ! ⎣
= 0 ⎦
ż
I S −R 0 (5.89)
!
ω I r SP = 0
= I v S + I ω̃
verschwindet. Dies sind zusätzliche nichtholonome Bindungen
ġgnh (pp, ṗp) = 0 . (5.90)
Entsprechend (5.81) fassen wir (5.87) und (5.89) zusammen.

Die Bewegungsgleichung erhalten wir schließlich mit der L AGRANGEschen Glei-
chungen 1. Art (5.35) in der symbolisch auswertbaren Form
T
∂ ∂T ∂ ∂T T ∂T T ∂V T ∂ ∂T T
p̈p + ṗp − + + = G Tλ (5.91)
∂ ṗp ∂ ṗp ∂ p ∂ ṗp ∂p ∂p ∂t ∂ ṗp
die in R_Kugel.m aus [52] ausgewertet ist. Dabei kann die kinetische Energie der
Rotation TR (T = TT + TR ) wegen des geometriebedingten konstanten Trägheitstensors
wahlweise im I- oder K-Systems angeschrieben werden.
Nach symbolischer Auswertung von (5.91) erhalten wir die Massenmatrix M p , die
Vektorfunktion f p und die JACOBI-Matrix G entsprechend (5.84). Diese Ausdrücke
sind recht übersichtlich, sollen hier aber nicht abgedruckt werden, lassen sich jedoch
mit R_Kugel.m anzeigen.
Der Übergang auf die Minimalkoordinaten bzw. die generalisierten Koordinaten
T
q = [α, β , γ]T , q̇q α̇, β̇ , γ̇ (5.92)
erfolgt mit (5.83) durch Auswertung von (5.85), was wiederum in R_Kugel.m zu
finden ist. Als Ergebnis geben wir die Vektorfunktion
" #T
β̇ (γ̇ − α̇ sin β ) β̇ (α̇ − γ̇ sin β )
f (qq, q̇q) = M −1
q fq = − , α̇ γ̇ cos β , −
cos β cos β
der Bewegungsgleichung
q̈q = f (qq, q̇q) (5.93)
an. Die Ausdrücke sind nichtlinear, unübersichtlich und somit schwer interpretierbar
jedoch unabhängig von den Kugelparametern m, Ix , R.
Abschließend soll (5.93) in der Basis des Inertialsystems angeschrieben werden.
Hierzu bilden wir von (5.88) die zeitliche Ableitung

I ω̇ H R q̇q → q̈q = H −1
ω = H R q̈q + Ḣ R ω − Ḣ
I ω̇ H Rq̇q , (5.94)
setzen dies in (5.93) ein und formen um, es bleibt die lineare Differenzialgleichung
ω
I ω̇ =0 (5.95)
mit der Lösung
Iω = I [ωx , ωy , ωz ]T = konstant. (5.96)
D. h. abhängig von den Anfangsgeschwindigkeiten aber unabhängig von den System-

parametern rollt die Kugel mit unveränderten Geschwindigkeiten auf der Ebene.
Seien ζ , η, ϑ die zugehörigen Drehwinkel um die positiven I x, I y, I z Achsen des
I-Systems – vgl. Seite 100 –, so dass
T
Iω = ζ̇ , η̇, ϑ̇ , (5.97)
dann gilt für die Rollbedingungen bzw. Bindungen
I ẋ = −Rη̇, I ẏ = Rζ̇ , (5.98)
die nun integrierbar sind
Ix = −Rη, Iy = Rζ (5.99)
und somit im Gegensatz zur vorangegangenen Betrachtung (5.95) holonome Bindun-

gen sind.
Diese speziellen Vereinfachungen der Bewegungsgleichungen eines starren Kör-
pers mit seinen Bindungen ist auf die Kugelsymmetrie zurückzuführen. Alle Achsen
durch S sind Hauptträgheitsachsen mit Ix als Massenträgheitsmoment. Wir werden auf
das Ergebnis in Abschn. 8.8 zurückgreifen.
5.5 Implizite Differenzialgleichungen
Die Function ode15i löst implizite Differenzialgleichungen und differenzial-algebraische Glei-

chungen vom Index 1
f (t, ẏy, y ) = 0 (5.100)
ausgehend von konsistenten Anfangswerten y 0 , ẏy0 zum Zeitpunkt t0 , d. h. sie erfüllen
f (t0 , ẏy0 , y 0 ) = 0 , ẏy0 = ẏy(t0 ), y 0 = y (t0 ) . (5.101)
Die Berechnung konsistenter Anfangswerte führt in der Regel auf nichtlineare algebraische Glei-
chungen. Meist wird man einige Komponenten von ẏy0 , y 0 aus physikalischen Gründen vorgeben,
die restlichen müssen dann (5.101) erfüllen.
Die Built-In Function decic berechnet konsistente Anfangsbedingungen mit Hilfe der Function
der Differenzialgleichung.
5.5 Implizite Differenzialgleichungen 273
Syntax:
[y0mod, ypmod ,res]=decic(@fode,t0,y0, fixed_y0,yp0,fixed_yp0 ,p1,p2,..)
mit dem optionalen Maß res (Residuum, Defekt) der erreichten Genauigkeit, so dass
f (t0 , ẏy0mod , y 0mod ) ≈ 0 .
Die festgeschriebenen Komponenten von ẏy0 , y0 sind mit fixed_y0(i)=1 und/oder

fixed_yp0(i)=1, die übrigen mit 0 zu kennzeichnen. Mit fixed_y0=[ ] werden alle Kom-
ponenten berechnet. Es sollten allerdings nicht mehr Größen als unbedingt nötig festgeschrieben
werden. Mit welcher Genauigkeit (5.101) erfüllt werden soll, kann optional vorgegeben werden
(default: RelTol 1e-3). p1,p2,... sind zusätzliche Übergabeparameter.
Wir zeigen den Ablauf einer Simulation anhand des anfänglich eingeführten Einmassen-
schwingers aus Beispiel 5.1 mit nichtlinearem Dämpfer. Die Bewegungsgleichungen (5.7) mit
der quadratischen Dämpfercharakteristik (5.8) lauten in impliziter Form
ẏ1 − y3 = 0, y = [y1 , y2 , y3 ]T = [x, s, ẋ]T

mẏ3 + k(y1 − y2 ) + mg = 0 (5.102)
ẏ2 (d |ẏ2 | + d0 ) + k0 y2 − k(y1 − y2 ) = 0 .
Dies ist eine implizite Differenzialgleichung 3. Ordnung. Wir gehen davon aus, dass die An-
fangswerte y 0 = (y1 (0), y2 (0), y3 (0))T gegeben seien, die Ableitungen ẏy0 müssen dann so be-
stimmt werden, dass sie (5.102) genügen. Ausgehend von der Function der Differenzialgleichun-
gen (5.102)
function res = fDAE_i(t,y,yp)

global m k k0 d d0 g
res=[yp(1)-y(3);
m*yp(3)+k*(y(1)-y(2))+m*g;
yp(2)*(d*abs(yp(2))+d0) - k*(y(1)-y(2))+k0*y(2)];
wobei die Parameter im Hauptprogramm DAE_i.m festgeschrieben sind, ermitteln wir zunächst
die konsistenten Anfangswerte, dabei sind y1 (0), y2 (0) die Gleichgewichtslage und y3 (0) ge-
wählt.
%---- Konsistente Anfangswerte berechnen

y0=[-0.0986; -0.0981; 10.0]; % Anfangswertvektor, Vorgabe
yp0=zeros(size(y0)); % zeitl. Ableitung, Vorgabe
[y0,yp0] = decic(@fDAE_i,0,y0,ones(size(y0)),yp0,[]) % Anfangswerte
Ergebnis: yi (0), ẏi (0), i = 1, 2 ,3
y0 = -0.0986 yp0 = 10.0000

-0.0981 -0.0000
10.0000 0.0000
Da zur Lösung mit ode15i in jedem Schritt ein nichtlineares Gleichungssystem zu lösen ist,
müssen die hierzu benötigten JACOBI-Matrizen näherungsweise ermittelt werden, sofern sie
nicht analytisch angebbar sind. Wir berechnen sie für das Beispiel:
⎡ ⎤ ⎡ ⎤
0 0 −1 1 0 0
∂f ∂ f
Jy = =⎣ k −k 0 ⎦, J ẏ = =⎣ 0 0 m ⎦ . (5.103)
∂yy ∂ ẏy
−k k0 + k 0 0 d0 + 2d|ẏ2 | 0
Weil J ẏ zustandsabhängig ist, müssen wir eine Function anlegen:

function [dfdy,dfdyp]=fJAC_i(t,y,yp) % Jacobi-Matrizen
global k k0 d d0 nu
dfdy=[0 0 -1; k -k 0; -k k+k0 0];
dfdyp=[1 0 0; 0 0 1; 0 d0+2*d*abs(yp(2)) 0];
Schließlich sind die Optionen zu setzen und den Löser aufzurufen:
%----- Löser-Optionen und -Aufruf
options = odeset(’Jacobian’,@fJAC_i,’AbsTol’,1e-05);
[t,y]=ode15i(@fDAE_i,[t0 te],y0,yp0,options); % Löser
Alle Einzelschritte sind in DAE_i.m, [52] nachzulesen. Darüber hinaus ist die explizite Form
mit (5.9) sowie die DAE-Formulierung (5.10) dort programmiert. In Bild 5.22 ist für die Parame-
ter
m=10 kg, k=2·105 N/m, k0=103 N/m d0=0,5 Ns/m d=6 Ns2 /m2
ein Einschwingvorgang dargestellt. Man erkennt, dass aufgrund des nichtlinearen Terms der
Dämpferkennlinie (5.8) die anfänglichen großen Schwingungen schnell, die Schwingung für
t > 5 nur durch den linearen Term (d0 ) langsam gedämpft werden. Als Hilfsgrößen werden
Bild 5.22: Einschwingvorgang eines Einmassenschwingers mit nichtlinearer Dämpferkennlinie
in DAE_i.m die Gleichgewichtslagen y10 , y20 von (5.102)
k0 + k mg
y10 = x0 = −mg ; y20 = s0 = − ; y30 = 0
k0 k k0
und deren Stabilität, festgeschrieben durch die Eigenwerte der linearen Bewegungsgleichung
Δẏ1 = Δy3 , wobei yi = yi0 + Δyi , i = 1,2,3

m Δẏ3 + k(Δy1 + Δy2 ) = 0
d0 Δẏ2 + k0 Δy2 − k(Δy1 − Δy2 ) = 0 ,
herangezogen.
5.6 Integration gewöhnlicher Differenzialgleichungen mit Unstetigkeiten 275
Übungsvorschlag: Integrieren Sie das differenzial-algebraische Gleichungssystem des Kurbel-

triebs (5.67), (5.68) als implizites System. Hilfe: DAE_Ki.m in [52].
5.6 Integration gewöhnlicher Differenzialgleichungen mit

Unstetigkeiten
Simulationen dynamischer Systeme basieren zunehmend auf einer immer feineren Modellierung
der zu untersuchenden Systeme. Dies beinhaltet auch die Formulierung von Unstetigkeiten, z. B.
verursacht durch Getriebelose oder durch hochfrequente Schaltvorgänge elektronischer Kompo-
nenten in mechatronischen Systemen [55]. Damit wird eine detailliertere Simulation möglich, so
dass sich zusammenhängende Phänomene vollständiger und damit besser klären lassen.
Diode sehr genaues Modell Modell nach [11] ideales Modell
Bild 5.23: Modellgegenüberstellung am Beispiel einer Diode
Unstetigkeiten ergeben sich in den meisten Fällen aus vereinfachten Annahmen, denn bei
genügend genauer Modellierung treten keine Unstetigkeiten auf, wie das sehr genaue Diodenmo-
dell in Bild 5.23 aus [45] verdeutlichen soll. Allerdings erhöht sich der Aufwand zur Parameter-
ermittlung solch sehr genauer Modellelemente erheblich. Darüber hinaus ist mit wesentlich län-
geren Rechenzeiten zu rechnen, da die Integratoren zur Simulation dieser Modellkomponenten,
z. B. mit sehr steilen Kennlinien und zusätzlichen Dynamikanteilen, mit sehr kleinen Schrittwei-
ten arbeiten müssen. Nach [23] wird das ideale Diodenmodell gegenüber dem sehr genauen ca.
10-50 mal schneller simuliert. In [11] wird eine Modellierung mit stückweise stetigen Elementen,
u. a. Geraden, und ausrunden der Übergänge zur Einhaltung der Stetigkeit vorgeschlagen, siehe
Bild 5.23. Die Steilheit der Kennlinien bleibt erhalten.
Wir wollen mit einer beispielorientierten Vorgehensweise aufzeigen, wie Probleme mit Un-
stetigkeiten unter MATLAB und Simulink gelöst werden können.
5.6.1 Beispiele für Unstetigkeiten in den Bewegungsgleichungen

Wir betrachten Differenzialgleichung
ẏy(t) = f (t, y (t)), y (t0 ) = y 0 (5.104)
mit stückweise stetiger Vektorfunktion f , so dass Unstetigkeiten, ausgelöst durch formulierbare

Ereignisse, sich auf f beziehen und dadurch auf die Lösung y (t) auswirken. Man spricht auch
von ereignis- (event-) gesteuerten Systemen. Wir unterscheiden Zustands- und Zeitereignisse.
Typische Elemente, die zu Unstetigkeiten, insbesondere in den Zustandsgrößen eines dynami-

schen Systems, führen, sind:
• Reibung: Gleit- und Haftreibung weisen in den Übergängen sprunghafte Unstetigkeiten auf.
• Stoßvorgänge: Stöße führen zu sprunghafter Änderung in der Geschwindigkeit, z. B. Lose
in Getrieben.
• Approximationen von Charakteristiken mit stückweise stetigen Funktionen, z. B. progressi-
ve oder degressive Kennlinien.
• Strukturvariable Systeme: Die Anzahl der Freiheitsgrade ändert sich; z. B. Übergang von
Gleit- in Haftreibung, Abheben eines Fahrzeugrades wie in Abschn. 8.6.
• Hysteresis: Systeme, die von der Vorgeschichte der Bewegung abhängig sind.
• Digital geregelte Systeme: Die während eines Abtastschritts konstante Stellgröße ändert
sich sprunghaft an den Grenzen der Abtastintervalle.
• Schaltende elektronische Komponenten: Dioden, Transistoren usw.
• Getaktete Endstufen: Die erzeugte Spannung wechselt pulsweitenmoduliert ihr Vorzeichen.
Die Schaltpunkte werden z. B. als Nullstellen eines Dreiecksignals mit der Istgröße des
Prozesses bestimmt oder direkt von einem Mikrokontroller erzeugt.
• Zeitabhängige Eingangsfunktionen: Systemerregungen werden oft als zeitabhängige
Funktionen modelliert, die zu bekannten Zeitpunkten Unstetigkeiten aufweisen, es liegt ein
Zeitereignis vor.
Die Fälle, bei denen die Unstetigkeiten zu bekannten Zeitpunkten auftreten, sind unproblema-
tisch, da die Integration zu diesen Zeitpunkten gestoppt und mit neu generierten Anfangswerten
wieder gestartet werden kann. Weitaus komplizierter sind zustandsabhängige Unstetigkeiten. Es
müssen die Unstetigkeitsstellen zweckmäßigerweise als Nullstellen zu formulierender Schalt-
funktionen parallel zur Integration ermittelt und ausgewertet werden.
In der Praxis werden Systeme mit Unstetigkeiten vielfach ohne dessen Lokalisierung bearbei-
tet; d. h. es wird über die Unstetigkeitsstelle hinwegintegriert. Bezogen auf Systeme mit C OU -
LOMBscher Reibung bedeutet dies, dass man von einem System mit Gleitreibung, also mit nicht
verschwindender Relativgeschwindigkeit zwischen der Reibpaarung, ausgeht. In Zeitabschnit-
ten möglicher Haftung neigt die numerische Lösung dann zu hochfrequenten Schwingungen um
die so genannte Schaltmannigfaltigkeit; es existiert bei dieser Formulierung keine zugehörige
Lösung. Diese Stellen sind somit sehr uneffizient zu integrieren. D. h. liegt eine Unstetigkeit in
dem Integrationsintervall [tn , tn + h] vor, dann wird die vorgegebene Fehlerschranke eines schritt-
weitengesteuerten Integrationsverfahrens trotz sehr kleiner Schrittweite h nicht einzuhalten sein.
In Bild 5.24 ist die Situation für das Beispiel des einfachen Fahrzeugmodells aus Abschn. 4.4
wiedergegeben. Dabei ist die Relativgeschwindigkeit zwischen Rad und Aufbau dargestellt. Ins-
besondere der Zeitausschnitt (rechts) weist auf das oszillierende Verhalten um vrel = 0 hin. Um
überhaupt eine Lösung zu erhalten, musste mit einem RUNGE -K UTTA-Verfahren 4. Ordnung
ohne Schrittweitensteuerung (h=0,0005) integriert werden. Solche Systeme lassen sich nur dann
effizient numerisch integrieren, wenn die Bewegungsgleichungen an die stückweise stetigen Inter-
valle angepasst werden. Wir wollen hier die Formulierung der Schaltfunktion, mit der die Bewe-
gungsgleichungen umgeschaltet werden, diskutieren und eine Möglichkeit der Nullstellensuche
skizzieren – vgl. auch [15] –, um solche Systeme numerisch zu lösen und besser zu verstehen.
Beispiele verdeutlichen die Vorgehensweise unter MATLAB und Simulink und später mit Hilfe
des Stateflow-Tools im Kapitel 6.
−3
x 10
0.06 2
0.04
1
0.02
vrel [m/s]
vrel [m/s]
0 0
−0.02
−1
−0.04
−0.06 −2
−0.08
0 0.2 0.4 0.6 0.8 1 0.28 0.3 0.32 0.34 0.36
Zeit t[s] Zeit t[s]
Bild 5.24: Relativgeschwindigkeit eines Zwei-Massen-Reibschwingers mit Ausschnitt um die Nullage
5.6.2 Formulierung von Schaltfunktionen

Wir setzen voraus, dass die Bedingungen, unter denen die Unstetigkeiten eintreten könnten, be-
kannt sind und als Nullstellen der vektoriellen Schaltfunktion
T
q (t, y (t)) = q1 (t, y (t)), . . . , qnq (t, y (t)) (5.105)
formuliert werden können. Führen wir mit Hilfe der sign-Funktion den Schaltvektor der Schalt-
koeffizienten sk
T T
s = s1 , s2 , . . . , snq = sign(q1 ), sign(q2 ), . . . , sign(qnq ) , (5.106)
der bei einer Zweipunkt-Schaltlogik nur die Zustände s j = ±1 annimmt, ein, dann hat die Bewe-
gungsgleichung (5.104) die Form
ẏy(t) = f (t, y (t), s ). (5.107)
Elemente der Schaltfunktion können einfache Zeitfunktionen

q1 (t) t − t1
q (t) = = (5.108)
q2 (t) t − t2
mit den Zeitereignissen zu den Zeitpunkten t1 , t2 oder vom Zustand abhängig sein, wie in
ẏ = |y|, (5.109)
wofür wir

y für s = sign q = 1
ẏ = mit q(t, y) = y, → ẏ = s y (5.110)
−y für s = sign q = −1
schreiben können.
Unstetigkeiten können somit nur dann auftreten, wenn mindestens eine Komponente von q ihr
Vorzeichen wechselt.
Die Lösung kann Sprünge aufweisen. So ändert sich bei Stoßvorgängen zwischen zwei Kör-
pern die Geschwindigkeitsvariable sprunghaft. Die Zeit t des eintretenden Ereignisses ist somit
immer Nullstelle der i-ten Schaltfunktion
qi (t , y − (t )) = 0 (5.111)
mit der zeitlichen Änderung y − (t) vor dem Ereignis. Die Lösung y + (t) nach dem Ereignis setzt
Bild 5.25: Sprunghafte Lösungskomponente
sich dann aus dem Funktionswert vor dem Ereignis y − (t ) und der durch das Ereignis (z. B. Stoß)
verursachten sprunghaften Änderung
y + (t ) = y − (t ) +ξξ (t , y − (t )) (5.112)
zusammen, vgl. auch Bild 5.25. y + (t ) ist der Anfangswert für das neue Integrationsintervall.
Damit setzt sich die Lösung wie folgt zusammen:
−
y (t) für t ≤ t
y (t) = (5.113)
y + (t) für t ≥ t .
5.6.3 Lokalisierung der Schaltpunkte

Die Unstetigkeitsstelle zu lokalisieren entspricht der Suche nach der Nullstelle der Schaltfunkti-
on
q(t , y (t )) = 0; q := q j (5.114)
zum Zeitpunkt t ∈ [tn , tn+1 ]. Da die exakte Lösung y (t) nicht bekannt ist, muss die Nullstelle
der Schaltfunktion numerisch ermittelt werden. Hierzu benötigen wir eine eindimensionale Null-
stellensuche. Dies ist im Allgemeinen ein nichtlineares Problem, welches iterativ zu lösen ist.
Dabei ist es nicht ausreichend, die Funktionswerte der Schaltfunktion und der Variablen y j zu
den aufeinander folgenden diskreten Zeitpunkten tn , tn+1 zu kennen, sondern auch innerhalb des
Intervalls [tn , tn+1 ].
Zur Bestimmung der Nullstellen bieten sich ableitungsbehaftete, z. B. N EWTON-Methode,
oder ableitungsfreie Methoden, z. B. Bisection [15], an. Zweckmäßiger sind ableitungsfreie Vor-
gehensweisen, die auf einer einfachen Nullstellensuche mit anschließender Intervallverkleine-
rung basieren. Die Methode muss sicherstellen, dass ein erfolgreicher Neustart nach der Un-
stetigkeitsstelle möglich wird. D. h. nach der Lokalisierung der Schaltstelle zum Zeitpunkt t ist
darauf zu achten, dass die Integration unmittelbar hinter der Schaltstelle im Punkt t˜ mit t˜ > t neu
gestartet wird. Damit ist sichergestellt, dass kein erneuter Vorzeichenwechsel der Schaltfunktion
für die gleiche Nullstelle auftritt.
Es ist also wichtig, nicht nur eine Folge von approximierten Nullstellen τ von t , sondern
eine Folge von Intervallen I j – die stets t beinhalten – zu bestimmen, so dass
I j = [τ j , τ j+1 ] ⊂ I j−1 , t ∈ I j . (5.115)
Die Bedingung t ∈ I j stellt sicher, dass q(τ j )q(τ j+1 ) ≤ 0 ist. Der Neustart ist dann mit τ̃ = τ j+1
auszuführen, wenn τ j+1 − τ j genügend klein ist.
Bild 5.26 demonstriert anhand der Dgl. ẏ = f (t, y) eine solche Nullstellensuche mittels Regula
Falsi7 .
Allgemein unterscheiden wir zwischen einer Zweipunkt-, Dreipunkt- und Mehrpunkt-Schalt-
logik. Bei der Zweipunkt-Schaltlogik (s = ±1) existiert ein eindeutiger Schaltvorgang an der
Ereignisgrenze, d. h. die Schaltfunktion q ändert das Vorzeichen; vgl. Beispiel in Abschn. 5.6.4.2.
Die Dreipunkt-Schaltlogik (s ± 1 oder s = 0) zeichnet sich dadurch aus, dass möglicherweise an
der Ereignisgrenze ein weiterer Zustand eintreten kann. Dies tritt z. B. beim Übergang von einer
Gleitreibungsphase in die Haftung auf.
5.6.4 Beispiele zur Zwei-Punkt-Schaltlogik

In MATLAB und Simulink lassen sich Zeit- und Zustandsereignisse bei der Integration von Be-
wegungsgleichungen einarbeiten. Das Ereignis wird unter MATLAB der Nullstelle zum approxi-
mierten Zeitpunkt τ zugeordnet. Schalten wir beim Eintreten eines Ereignisses direkt auf einen
neuen Zustand um (s = ±1), dann sprechen wir von einer Zwei-Punkt-Schaltlogik. Wir wollen
dies anhand einfacher Beispiele erläutern.
5.6.4.1 Der springende Ball im umgebenen Medium

Den Grundgedanken der Vorgehensweise zeigen wir anhand der Bewegungsgleichung – in einer
x, y-Ebene – eines Ballwurfes im umgebenen Medium, z. B. Luft,
ẍ + cw v ẋ = 0 Horizontalbewegung; ÿ + cw v ẏ = −g Vertikalbewegung
mit den Anfangswerten und Systemgrößen

Abwurfgeschwindigkeit v0 = 25 m/sec Ballgeschwindigkeit v = (ẋ2 + ẏ2 )
Abwurfhöhe h=1m Widerstandsbeiwert cw =0,01
Abwurfwinkel α = 15° Stoßfaktor εs = 0,9.
Bild 5.27 gibt die Simulink-Modellierung wieder, auf S. 283 ist der bezüglich der Ereignisse
erweiterte MATLAB Code angegeben. Das gemeinsame Zustandsereignis ist das Auftreffen des
Balls zur Höhe y(t ) = 0, so dass die Schaltfunktion
q(t) = y(t)
7 Man bewegt sich nur von einer Seite auf die Nullstelle zu; deshalb gleichzeitig Intervallteilung einarbeiten.
Stichwortartige Erklärung zur Vorgehensweise mittels Regula Falsi für die Dgl. ẏ = f (t, y):
• Integrator berechnet yn (tn ), yn+1 (tn+1 ) (•) mit der Schrittweite h
• Berechnung der Schaltfunktionen: q j (tn , yn ) und q j (tn+1 , yn+1 ), j = 1, 2, (◦)
?
• Nulldurchgang prüfen (q j (tn , yn ) q j (tn+1 , yn+1 ) < 0): q2 (t, y) besitzt Nullstelle
• 1. Iterationsschritt
– Regula Falsi: Näherungsweise Bestimmung der Nullstelle → τ1
– Integration ausgehend von tn , yn führt auf → τ1 = tn + h1 , y(τ1 ) = y
– Komponente q2 der Schaltfunktion berechnen: q21 (τ1 , y )
? ?
– Nullstellenprüfung: q21 (τ1 , y ) q21 (τ1 , yn ) < 0 oder q21 (τ1 , y ) q21 (τ2 , yn+1 ) < 0
– Zeitintervall neu abstecken: → [τ2 , τ3 ]
• 2. Iterationsschritt
– ....................
Bild 5.26: Erläuterung zur Nullstellensuche des Schaltfunktionvektors q = (q1 , q2 )T
anzusetzen ist. D. h. parallel zur Integration muss q auf mögliche Nullstellen untersucht werden.
Diese kann hier nur bei fallender Bewegung von y bzw. von q auftreten, was zusätzlich genutzt
wird.
Bild 5.27: Simulink-Realisierung mit Stoßfaktor εs = 0,9
Simulink-Modell: Wir gehen nur auf die wesentlichen Beschaltungen der Modellkomponenten
in Bild 5.27 ein. Horizontal- und Vertikalbewegungen sind über den (Luft-) Widerstand gekop-
pelt, sie werden jeweils mit zwei Integrierer gelöst. Die Anfangswerte werden teilweise extern
vorgegeben, hierzu ist der zugehörige Port am Integrierer anzuzeigen. Das Ereignis bezieht sich
nur auf y(t). Die Nullstellensuche bezüglich q(t) wird mittels Trigger- bzw. Reset-Eingang des
Integrator 1, der auf fallende Eingangsfunktion reagiert, durchgeführt. Dadurch lassen sich
nicht interessierende Nullstellen, insbesondere unmittelbar aufeinander folgende, ausschließen.
Die Triggerschwelle ist wegen q(t ) = 0 auf null zu setzen, wodurch die Integration beim Null-
durchgang zum Zeitpunkt τ gestoppt wird. Der Abprall entspricht einem Neustart in τ mit
veränderter Geschwindigkeitskomponente
ẏ+ (τ ) = −0,9 ẏ− (τ ), εs = 0,9 Stoßfaktor.

D. h. ẏ+ (τ ) muss auf den IC Block8 , der im Anfangszustand den eingestellten, später den an-
gelegten Wert durchschaltet, zurückgekoppelt werden. Um algebraische Schleifen zu vermeiden,
müssen wir das State Port Signal y_p(T) nutzen.
Die Signalbegrenzung auf ymin = 0 am Integrator 2 verhindert bei sehr kleinen Amplitu-
den y mögliche Fehlentscheidungen bei der Nullstellenbestimmung. Für y → 0 ist dieses Modell
nicht mehr geeignet. Die Bewegungsgleichung ändert sich, es liegt ein strukturvariables System
vor, vgl. Abschn. 6.3.
MATLAB Script und Function: Das Programmpaket besteht aus dem Hauptprogramm wurf.m,
der Function der Differenzialgleichung fwurf.m, sowie der der Schaltfunktionen ewurf.m,
sie sind auf S. 283 aufgeführt. Zunächst betrachten wir nur Bewegungen bis zum ersten Auf-
treffen. Neu gegenüber den bisherigen Betrachtungen ist in wurf.m die Aktivierung der Option
’Events’,@ewurf in wurf.m – vgl. Abschn. 5.2.1. Danach muss in der Function ewurf.m
u. a. die Schaltfunktion q = y programmiert werden, auf die bei der Nullstellensuche zurückge-
griffen wird. Darüber hinaus sind die Steuerparameter:

1 Abbruch bei Nullstelle
isterminal =
0 kein Abbruch
⎧
⎨ 1 Nullstellensuche bei steigender Funktion q(t)
direction = 0 Nullstellensuche in jedem Fall
⎩
−1 Nullstellensuche bei fallender Funktion q(t)
anzugeben; vgl. ewurf.m. Der MATLAB Code sucht infolge direction=-1 nur bei fallender
Funktion q(t) nach Nullstellen und bricht die Integration infolge isterminal=1 nach der ers-
ten Nullstelle q(τ ) ≈ 0 ab. Ergänzend zur bisherigen Betrachtung, der Detektierung des Auftreff-
punkts durch q1 (t) = y(t), soll der höchste Punkt der Wurfbahn mit der Schaltfunktion q2 (t) =
ẏ(t) sowie die Zeit, bei dem der Ball die Höhe h durchfällt, mit der Schaltfunktion q3 (t) = h−y(t)
ermittelt werden. Jeder Schaltfunktionskomponente q j ist ein isterminal/direction Wert
vektoriell zuzuordnen. Die Vereinbarungen sind in der Function ewurf.m nachzulesen.
Tabelle 5.5: Ereignispunkte zum Ballwurf unter MATLAB
Ereignis Zeit t x y ẋ ẏ
iE = tE = yE =
2 5.0347e-001 9.4602e+000 2.4671e+000 1.4941e+001 -1.0880e-014
3 1.0839e+000 1.6649e+001 1.0000e+000 1.0321e+001 -4.7998e+000
1 1.2680e+000 1.8455e+001 -1.1102e-016 9.3081e+000 -6.0453e+000
Tabelle 5.5 zeigt die über tE, yE, iE zusätzlich ausgegebenen numerischen Werte zu den
gefundenen Ereignissen bis zum ersten Auftreffpunkt. tE ist der Zeitpunkt des Ereignisses,
yE die zugehörigen Zustandswerte und iE der Index der Komponente des Schaltvektors q =
(y, ẏ, h − y) zum detektierten Ereignis.
Soll die weiterführende Ballbewegung wie in Bild 5.27 berechnet werden, dann muss im
Hauptprogramm ein Neustart mit geeigneten Anfangswerten organisiert werden, z. B.:
8 Initial Condition
tout=[]; yout=[]; % Ausgabedaten, leer

while te > t0 % Zeitschleife
[t,y,tE,yE,iE]=ode23(@fwurf,[t0 te],y0,options);
tout=[tout;t]; % Datenübernahme
yout=[yout; y];
y0=y(end,:); % Startwerte für
y0(4)=-0.9*y0(4);
t0=t(end); % nächstes Intervall
end
vgl. auch wurf.m in [52]. Die Integration wird bis zum Zeitpunkt te fortgesetzt.
In jedem Fall ist neben der Formulierung der Schaltfunktion q(t) auch die Steigung (direc-
tion) von q(t), für die die Nullstellensuche erfolgen soll, entscheidend. Da nach Bild 5.5 ein
Neustart kurz hinter dem Ereignis erfolgt, müssen wir direction=-1 setzen, so dass die im
aufsteigenden Ast evtl. unmittelbar folgende Nullstelle kein Ereignis darstellt. Dies wird erkannt
und in den Ausgaben tE, yE, iE angezeigt. Will man die Information der auftretenden Ereig-
nisse über iE steuern, so müssen die überflüssigen Daten zunächst herausgefiltert werden. Eine
eindeutige Vorgabe mit direction ist somit vorteilhaft.
Alternativ kommen wir mit direction=0 zum Ziel, wenn wir statt mit der berechneten
!
Nullstelle y(τ ) ≈ 0 mit y(τ ) = 0 den Neustart beginnen. D. h. wir korrigieren den Ort der
Nullstelle bei unveränderter Zeit und umgehen somit eine Nullstelle im aufsteigenden Ast von y.
Nachteil: Es wird bei steigender wie fallender Funktion nach Nullstellen gesucht.
Hauptprogramm: wurf.m aus [52]

% Wurf-Trajektorie (im umgebenen Medium)
% -----------------
%-- Initialisierung
global g h c_w
g=9.81; % Erdbeschleunigung m/s2
c_w=0.05; % Widerstandsbeiwert
%-- Anfangswerte
h=1; % Höhe [m]
v0=25; % Geschw. [m/s]
alpha=pi/180*15; % Winkel [rad]
y0=[0,h,v0*cos(alpha),v0*sin(alpha)] % Anfangswert
te=3.; % Flugzeit geschätzt!
%-- Optionen für Integrator
ref=4; % Kurvenglättung
options=odeset(’Events’,@ewurf,’Refine’,ref);
%-- Lösung
[t,y,tE,yE,iE]=ode23(@fwurf,[0 te],y0,options);
Function der Differenzialgleichung und der Schaltfunktion: fwurf.m, ewurf.m aus [52]
function ydot = fwurf(t,y)
global g c_w
v=sqrt(y(3)ˆ2+y(4)ˆ2) % Ballgeschwindigkeit
ydot=[y(3); y(4);-c_w*v*y(3); -g-c_w*v*y(4)]; % Dgl.
function[q,isterminal,direction] = ewurf(t,y)
global h
q=[y(2) y(4) h-y(2)] % Vektor der Schaltfunktionen
isterminal=[1 0 0]; % Stopp (1) nach Nullstelle
direction=[-1 0 1]; % Nullstellensuche nur bei
% fallender/steigender/immer
% (-1)/(1)/(0) Funkt. q(t)
5.6.4.2 Unstetige Kennlinie und das Stoßproblem

Zur Vertiefung der Schaltfunktionsformulierung betrachten wir das einfache Beispiel nach
Bild 5.28 mit unstetiger Federkennlinie sowie den Parametern aus Tabelle 5.6. Die Masse m
setzt bei Auslenkungen von |x| > xs (xs ≥ 0) auf eine weitere masselose Feder (k2 ) auf. Im Fall
sehr großer Steifigkeit der parallel geschalteten Feder (k2 ) führen wir einen Stoßvorgang ein.
Bild 5.28: Schwinger mit Schaltstellen
Masse m 5,0 kg Dämpfung d k1 /100 = 9,81 N s/m

Steifigkeit k1 981 N/m Erregeramplitude Q 400 N
Steifigkeit k2 = αk1 Erregerkreisfr. Ω 20 rad/s
Steifigk.-Koeff. α 300 . . . 3000 Schaltpunkt xs 0,04 m
Für den Einmassenschwinger mit stückweise linearer Federkennlinie soll das Aufsetzen der Mas-
se auf die zweite Feder (k2 = αk1 ) am Ort |x| = xs über eine Schaltfunktion formuliert und die
Simulation mit Nullstellensuche durchführt werden. Die zugehörige Bewegungsgleichung lautet
mẍ + d ẋ + f (x) = m g + Q cos Ωt (5.116)
mit der stückweise linearen Federkraft

k1 x für − xs ≤ x ≤ xs
f (x) = (5.117)
k1 x + k1 α(x − xs sign(x)) für − xs > x > xs ,
wobei x = 0 zur entspannten Federlage gehört.

Die Schaltfunktion
Für die Schaltfunktion bieten sich auf den ersten Blick mit (5.117) zwei Formulierungen an:
• q = x − xs sign(x)
• q = |x| − xs ,
wobei unter MATLAB sign(0) = 0 gesetzt wird. Die erste Schaltfunktion weist, wie in Bild 5.29
dargestellt, Sprünge infolge der Vorzeichenwechsel um x ≈ 0 auf, so dass sie wegen des zusätz-
lichen Vorzeichenwechsels von q damit ungeeignet ist. Wir arbeiten mit q = |x| − xs . Führen wir
0.05 0.05
q q
0 0
t t
−0.05 −0.05
0 0.05 0.1 0.15 0.2 0.25 0 0.05 0.1 0.15 0.2 0.25
q = x − xs sign(x) q = |x| − xs
Bild 5.29: Zeitlicher Verlauf der Schaltfunktionen
noch den zugehörigen Schaltkoeffizienten s = sign(q) ein, dann gilt für die Federkraft
f (x) = k1 x + 0,5(1 + s)k1 α(x − xs sign(x)), s = ±1

(5.118)
= k1 x + 0,5(1 + s)k1 α sign(x)(|x| − xs ) ;
es liegt ein Zwei-Punkt-Schaltproblem vor.

Numerische Vorgehensweise und Programmcodes
Die Bewegungsgleichungen sind stückweise linear, so dass wir diese mit analytischen Metho-
den des Kapitels 3 lösen könnten, trotzdem kommen wir zum Anstückeln der Bewegungen aber
nicht um die Nullstellensuche herum. Da die Unstetigkeiten insbesondere auch bei nichtlinearen
Bewegungsgleichungen eine wesentliche Rolle spielen, wollen wir die Vorgehensweise auf die
numerische Integration beschränken.
Parallel zur numerischen Integration ist nun jedes Intervall [tn , tn+1 ] auf mögliche Nullstellen
von q zu untersuchen, um dementsprechend die zugehörige Federcharakteristik zu aktivieren.
Da die Federkraftkomponente erst nach einer erfolgreichen Nullstellensuche umgeschaltet wird,
ist gewährleistet, dass selbst kurz aufeinanderfolgende Nullstellen gefunden werden. Die Um-
schaltung organisieren wir einfachheitshalber im Hauptprogramm schaltp.m über den Schalt-
koeffizienten s. Ausgehend von einem definierten Anfangszustand, z. B. mit s=1, schalten wir
nach jeder Nullstelle durch Vorzeichenwechsel von s um; vgl. die Programmcodes schaltp.m,
fschaltp.m und eschaltp.m [52]. Diese einfache Umschaltung s → −s ist nicht immer
ausreichend, so dass vielfach weitere programmseitige Kontrollen eingearbeitet werden müssen.
Programmbeschreibung: Die Systemparameter werden in schaltp.m als Structure p verein-
bart und hinter options im Integrationsaufruf aufgelistet und damit an die anderen Function
übergeben, wenn sie ebenfalls im Function-Kopf stehen. Die Structure-Vereinbarung empfiehlt
sich immer bei einer größeren Parameteranzahl, vgl. auch Abschn. 8.6. Die Ausgabe von p ist
sehr übersichtlich:
p =
m: 5
k1: 981
alpha: 3000
d: 9.8100e+000
xs: 4.0000e-002
Q: 0
OM: 20
Im Folgenden ist das verkürzte Hauptprogramm schaltp.m sowie die Function der Diffe-
renzialgleichung fschaltp.m und die der Schaltfunktion q eschaltp.m mit dem Zustands-
vektor y = (x, ẋ)T abgedruckt. Es können wahlweise die freien oder erzwungenen Schwingungen
von (5.116), vgl. Kapitel 3, berechnet werden.
Hauptprogramm schaltp.m aus [52]:
% Parameter als Structure
p.m=5.0; % Masse [kg]
p.k1=981.; % Federsteifigkeit [N/m]
............ weitere Parameter
p.OM=20.; % Anregungskreisfrequenz [rad/sec]
%..................................... Initialisierung
t0=0; % Anfangszeitpunkt
ier=input(’ freie oder erzwungene Schwingungen f oder e ’,’s’);
if ier==’f’
p.Q=0.; te=1.75; y0=[-0.; 2]; % Endzeitpunkt, Anfangswerte
else
te=0.7; y0=[-0.; 0]; % Endzeitpunkt, Anfangswerte
end
s = sign(abs(y0(1))-p.xs); % Schalter für Start
% .................................... Integrationinitialisierung
options=odeset(’Events’,@eschaltp,’RelTol’,1.0e-8,’Refine’,4);
tout=t0; yout=y0.’; % Ausgabedaten
while te > t0 % Zeitschleife
[t,y,tE,yE,iE]=ode23(@fschaltp,[t0 te],y0,options,p,s);
% tE, yE, iE optionale Ausgabe
tout=[tout;t(2:end)]; % Datenübernahme
yout=[yout; y(2:end,:)];
y0=y(end,:); % Startwerte für

t0=t(end); % nächstes Intervall
s=-s; % Intervallwechsel
end
%...............................................................
figure(1), clf % grafische Ausg.
subplot(311), . . . . . . . . .
Function der Bewegungsgleichung: fschaltp.m aus [52]:

function yp = fschaltp(t,y,p,s)
%---- Federkraft
fx= p.k1*(y(1)+0.5*(1+s)*p.alpha*(y(1)-p.xs*sign(y(1))));
yp=[y(2);
(-fx-p.d*y(2)+p.Q*cos(p.OM*t))/p.m-9.81*0]; \% ohne Gewicht
Function des Ereignisses: eschaltp.m aus [52]:

function [q,isterminal,direction] = eschaltp(t,y,p,s)
q =abs(y(1))-p.xs; % Schaltfunktion
isterminal= 1; % Stopp nach Nullstelle
direction= -s; % Flanke
In Bild 5.30 ist ein Simulationsergebnis der erzwungenen Schwingungen zu α = 3000 und
g=0 m/s2 , also mit einer relativ steifen zweiten Feder aber ohne Gewichtseinfluss, ausgehend
von den Anfangswerten x(0) = 0 m, ẋ(0) = 0 m/s dargestellt. Das Aufsetzen auf die zweite Feder
entspricht elastischen Stoßvorgängen. Dies kommt insbesondere durch die Geschwindigkeitsän-
derungen ẋ(t) sowie die kurz aufeinanderfolgenden Nullstellen von q zum Ausdruck. Bild 5.32 a
zeigt die freien Schwingungen zu α = 3000 und den Anfangswerten (x(0), ẋ(0))T = (0, 2)T ,
denen in Bild 5.32 b ein noch zu erläuternden Stoßvorgang gegenübergestellt ist.
Parameter: Q = 400 N; Ω = 20 rad/s; α = 3000; Anfangswerte: x(0) = ẋ(0) = 0
Bild 5.30: Aufsetzen auf eine relativ steife zweite Feder; erzwungene Schwingungen ohne Gewicht
Übungsvorschlag: Die beiden Massen m1 , m2 des Schwingers nach Bild 5.31 bewegen sich auf
glatter Ebene. Die harmonische Erreger-Kraft f (Ωt) = 48 cos Ωt N greift an m1 an. Die Puffer
seien masselos, die Federelemente haben die Steifigkeiten kk1 , kk2 und die entspannte Pufferlänge
0 . Der Massenabstand in der kontaktfreien Ausgangslage beträgt Δ .
Bild 5.31: Kollision zweier Massen durch harmonische Erregung, Ausgangslage
Gegeben: m1 = m2 = 1 kg k1 = k2 = 981 N/m

kk1 = kk2 = 500 k1
d1 = d2 = 0,981 Ns/m Ω = 0,7,... 2,0 k1 /m1 Δ − 20 = 0,1 m
1. Formulieren Sie die Bewegungsgleichungen und die Schaltfunktion q für den Kontakt.
2. Führen Sie eine Simulation unter MATLAB und Simulink durch.
Hinweise in: diskont.pdf in [52].

Der Stoßvorgang
Erhöhen wir die Steifigkeit der zweiten Feder mit α >> 3000, dann kann es zweckmäßig sein,
einen Stoßvorgang zu formulieren, wobei der Geschwindigkeitssprung durch
ẋ+ (t) = −εs ẋ− (t), 0 < εs ≤ 1
mit dem Stoßfaktor εs gegeben sei. Der Schaltzeitpunkt müsste jetzt durch den linken Intervall-
rand der Nullstellensuche τ −Δτ (Δτ << 1), d. h. kurz vor der eigentlichen Nullstelle, festgelegt
werden. Mit der geänderten Anfangsgeschwindigkeit wäre dann ein Neustart erfolgreich. Dies ist
in MATLAB anders organisiert. Um dennoch aufeinanderfolgende Nullstellen auseinander zu hal-
ten, kann einerseits die Steigung von q zur gezielten Nullstellensuche (direction=1, siehe
Bild 5.29), andererseits ein korrigierter Ort x(τ ) herangezogen werden. D. h. die Auslenkung
!
x(τ ) zur Nullstelle ist durch den exakten Wert x(τ ) = xs sign(x(τ )) zu ersetzen – vgl. Alter-
nativvorschlag zum Beispiel des Ballwurfs –, wobei direction=0/1 zulässig ist. Dies ist im
Programm stoss.m (Function-Formulierung) in [52] nachzulesen.
Wie schon erwähnt, ist in Bild 5.32 b ein solcher Vorgang für den Schwinger ohne Erregung
und Gewichtseinfluss mit dem Stoßfaktor εs = 0,9 dargestellt. Die Anregung erfolgte, wie in
Bild 5.32 a, über die gleichen Anfangswerte [x(0), ẋ(0)]T = [0, 2]T , d. h. über einen Anfangsim-
puls. Aufgrund der Dämpfung klingt der Schwingungsvorgang langsam ab, so dass keine Schalt-
vorgänge mehr auftreten. Beide Einschwingvorgänge in Bild 5.32 unterscheiden sich durch die
Anzahl der Kontakte mit der Feder k2 . Infolge des gewählten Stoßfaktors εs wird durch den Stoß
mehr Energie absorbiert.
a: Q = 0 N; α = 3000; x(0) = 0 m, ẋ(0) = 2 b: Q = 0 N; εs = 0,9; x(0) = 0 m, ẋ(0) = 2

m/s m/s
Bild 5.32: Freie Schwingungen: Aufsetzen auf eine relativ steife zweite Feder und das Stoßproblem
Bemerkung: Bei massebehafteter Feder k2 bzw. massebehaftetem Anschlag wird das Schwin-
gungsverhalten erheblich komplexer. Das Federsystem bildet dann ebenfalls ein schwingungsfä-
higes System.
5.6.5 Dreipunkt-Schaltlogik am Beispiel eines Zwei-Massen-Schwingers mit Reibung

5.6.5.1 Zur Modellierung der Reibkraft
In der Literatur findet man viele Modellierungen zur Reibkraft. Wir wollen zwei Unterschei-
dungsmerkmale kurz ansprechen.
Die Haftreibungskraft wird einerseits als Zwangskraft und andererseits als eingeprägte Kraft
modelliert. Die Beschreibung über eine eingeprägte Kraft basiert auf der Deformation der Rau-
higkeitsspitzen aufgrund mikroskopisch kleiner tangentialer Verlagerungen der Oberflächen. Zur
Modellierung verwendet man u. a. Dämpfer mit großen Dämpfungskonstanten (statisches Mo-
dell) oder Bürstenmodelle (dynamisches Modell), siehe [46] und LuGre.pdf in [52]. Demge-
genüber resultiert die Zwangskraft aus dem Verschwinden der Relativgeschwindigkeit im Kon-
taktpunkt.
Die Gleitreibungskraft ist eine eingeprägte Kraft, z. B. C OULOMB-Gesetz, das für kleine Re-
lativgeschwindigkeiten gilt. Bei größeren Relativgeschwindigkeiten wird die Gleitreibungskraft
vielfach durch die S TRIBECK-Kurven beschrieben; sie steigt mit zunehmender Relativgeschwin-
digkeit, vgl. Bild 5.33III , an.
Der Übergang zwischen Haften und Gleiten ist somit vom Modellansatz abhängig. Im Fall
der Modellierung über eingeprägte Kräfte erhalten wir stetige Beschleunigungsübergänge, bei
der Modellierung über Zwangskräfte Beschleunigungssprünge.
Die Wahl des Kraftansatzes beeinflusst also den Modellierungs- und den Simulationsaufwand.
Da wir uns mit der Integration von Systemen mit Unstetigkeiten befassen, betrachten wir die
Haftreibungskraft als eine Zwangskraft. Weitere Vorgehensweise und Literaturangaben findet
man in [23] und [48].
Die Gleit-Reibkraft fR ist von der Relativgeschwindigkeit vrel , der Normalkraft fN und dem
Reibkoeffizienten μ(|vrel |) im Kontaktpunkt abhängig:
fR (vrel ) = sign(vrel ) fN μ(|vrel |), vrel

= 0, (5.119)
wobei unterschiedliche Ansätze für μ(|vvrel |) aus der Literatur bekannt sind, drei nennen wir:

μ |vrel | =

0
I: μ(|vrel |) = für C OULOMB
μ0 > μ |vrel | = 0
μ0 − μ
II: μ(|vrel |) = + μ, b>0 (5.120)
1 + b |vrel |
μ0 − μ
III: μ(|vrel |) = + μ + a|vrel |2 , b > 0, a > 0 .
1 + b |vrel |
Die zugehörigen unstetigen Reibkräfte sind in Bild 5.33 dargestellt. Darüber hinaus wird, wie
Bild 5.33: Reibkräfte in Abhängigkeit von der Relativgeschwindigkeit vrel
oben erwähnt, die Haftzone gerne durch ein Geradenelement mit genügend großer Steigung
(Dämpfer) oder durch kontinuierliche Reibkraftverläufe, wie in Bild 5.34, verarbeitet. In die-
sen Fällen sind die Bewegungsgleichungen steife Differenzialgleichungen, was bei der Auswahl
des Integrationsverfahren berücksichtigt werden muss. Die Reibkräfte sind eingeprägte Kräfte.
Beispiel:
vrel v
fR = k1 + k2 tanh( rel )
|vrel |2 + k3 k4
Reibkraftverlauf mit:
k1 = 0,56, k2 = 0,3,
k3 = 0,001, k4 = 0,5
Bild 5.34: Stetiger Reibkraftverlauf
5.6.5.2 Reibmodell mit einem Reibkontakt

Wir wollen die Reibproblematik mit Hilfe einer relativ einfachen Dreipunkt-Schaltlogik9 anhand
des in Bild 5.35 dargestellten Reibschwingers – zunächst nur mit einem Reibkontakt – lösen. Die
beiden Massen m1 , m2 sind über die Federn (k1 , k2 , x1 = x2 = 0 entspannte Feder) an die Umge-
bung gekoppelt. Die Masse m2 bewegt sich reibungsfrei auf der Unterlage. Zwischen den Massen
9 Untersuchung mit Fünfpunkt-Schaltlogik vgl. [23]

Reibmodell (C OULOMB)
x1 - rauh (μ , μ0 )
x2 - fR 6
f1 (t)
m1 -
k1 s -
m2 - f2 (t) vrel
k2 s
glatt
Bild 5.35: Reibschwinger und Reibmodell
wirkt die C OULOMBsche-Reibkraft mit dem Reibkoeffizienten μ für Gleiten und μ0 für Haften
(μ0 ≥ μ). An jeder Masse greift eine äußere Anregung f1 (t) bzw. f2 (t) an. Setzen wir entgegen
der Bewegungsrichtung ẋ1 > ẋ2 die Reibkraft fR an, dann gelten die Bewegungsgleichungen
m1 ẍ1 + k1 x1 = f1 (t) − fR
(5.121)
m2 ẍ2 + k2 x2 = f2 (t) + fR .
Wir unterscheiden die Zeitabschnitte der Gleit- und Haftreibung. Zunächst betrachten wir die
Gleitbewegungen mit vrel = ẋ1 − ẋ2
= 0. Hierfür gilt das Reibgesetz
fR = μ fN sign(ẋ1 − ẋ2 ); fN = m1 g (5.122)
und somit die Bewegungsgleichungen
m1 ẍ1 + k1 x1 = f1 (t) − μ fN sign(q)

(5.123)
m2 ẍ2 + k2 x2 = f2 (t) + μ fN sign(q)
mit der Schaltfunktion q, die der Relativgeschwindigkeit in den Kontaktpunkten der beiden Mas-
sen entspricht

1 für q > 0
q = ẋ1 − ẋ2 ; sign(q) = , (5.124)
−1 für q < 0
wobei sign(0), d. h. Haften, nicht definiert ist.

Für die numerische Bearbeitung von (5.123) ist es zweckmäßig, den Schaltkoeffizienten s
einzuführen und
⎡ ⎤
⎡ ⎤ k1 1
− x + ( f (t) − μ f s)
ẍ1 ⎢ m1 1 m1 1 N
⎥
⎣ ⎦=⎢ ⎢
⎥
⎥ ; s = sign(q) (5.125)
⎣ k2 1 ⎦
ẍ2
− x2 + ( f2 (t) + μ fN s)
m2 m2
oder kurz

f + (t, ẋx, x ) für s = 1
ẍx = f (t, ẋx, x, s) = , mit x = (x1 , x2 )T (5.126)
f − (t, ẋx, x ) für s = −1
zu schreiben.
Verschwindet die Relativgeschwindigkeit zwischen den Massen, dann liegt Haftung vor und
es gilt das Reibgesetz
| f R0 | < μ0 f N . (5.127)
Beide Massen bewegen sich mit ẍ1 = ẍ2 und ẋ1 = ẋ2 , so dass aus (5.121) die Bewegungsglei-
chungen
(m1 + m2 )ẍ1 + k1 x1 + k2 x2 = f1 (t) + f2 (t)

(5.128)
ẍ2 = ẍ1 ; ẋ2 = ẋ1
folgen.
Um die Lösungen numerisch zu ermitteln, müssen wir weitere Schaltbedingungen einführen,
die den aktuellen Zustand erkennen, um somit die eine oder andere Bewegungsgleichung zu
integrieren.
Schaltlogik
Die zentrale Schaltfunktion ist weiterhin (5.124). Deren Nullstelle alleine gibt allerdings keine
Aussage darüber, welche Gleichung aktiviert werden muss. Wir unterscheiden hier drei Bewe-
gungsphasen:
• Übergang von einer Bewegung mit positiver Relativgeschwindigkeit (s = 1) in eine Be-

wegung mit negativer Relativgeschwindigkeit (s = −1) und in umgekehrter Reihenfolge;
Annahme: Durchschwingen ohne Haftung.
• Übergang von einer Bewegung mit positiver Relativgeschwindigkeit (s = 1) in den Haftrei-
bungsbereich und umgekehrt.
• Übergang von einer Bewegung mit negativer Relativgeschwindigkeit (s = −1) in den Haft-
reibungsbereich und umgekehrt.
D. h. es muss zwischen diesen drei Zuständen hin und her geschaltet werden. Um diese einzel-
nen Phasen gezielt anzusteuern, führen wir, wie in [15], Hilfs-Schaltfunktionen ein, die auf der
zeitlichen Ableitung von q, also
dq
= qẋx ẍx + qt = qẋx f + qt für q = q(t, ẋx), hier: qt = 0 (5.129)
dt
aufbauen. (5.129) ist hier die Relativbeschleunigung. Mit den hieraus abzuleitenden Hilfs-Schalt-
funktionen wollen wir, ausgehend von q → 0, entscheiden, ob beim Eintreten des Ereignisses
q = 0 das System im Haftreibungsbereich verharrt oder ob es diesen nur durchläuft, so dass
wieder q
= 0 vorliegt. Diese Möglichkeiten sind nur abhängig von den Kraftverhältnissen im
Haftreibungsbereich, wobei beide Vorzeichen der Relativgeschwindigkeit eingearbeitet werden
müssen. Beides erreichen wir mit q̇ nach (5.129), wenn wir
S+ = qẋx f +
0 + qt
(5.130)
S− = qẋx f −
0 + qt
einführen, wobei sich f ±

0 aus der rechten Seite von (5.125) ergibt, wenn wir für μ den Haftrei-
bungskoeffizienten μ0 setzen
⎡ ⎤
k1 1
− x1 + ( f1 (t) ∓ μ0 fN )
⎢ m1 m1 ⎥
f± ⎢ ⎥
0 = ⎣ ⎦ (5.131)
k2 1
− x2 + ( f2 (t) ± μ0 fN )
m2 m2
und damit die Situation während der Haftung beurteilen. S+ und S− können, wie in Bild 5.36
dargestellt, als Richtungselemente bezüglich q ≡ 0 in der q, t-Ebene aufgefasst werden. Nehmen
q
6
q
S+
S @ Q X
S @
w s X
R Q z -

7

7

t
S−
Bild 5.36: Richtungsfeld
wir an, für t = t gilt q(t , ẋx(t )) = 0 und beide Richtungselemente
S+ < 0 und S− > 0, S± := S± (t )
streben gegen q ≡ 0, dann kann dieser Zustand nicht mehr verlassen werden. Es liegt Haftrei-
bung vor; es muss auf (5.128) umgeschaltet werden. Dieser Zustand q ≡ 0 wird erst dann wieder
verlassen, wenn eine der Richtungen von S+ oder S− das Vorzeichen wechselt. Ähnliche Inter-
pretation findet man bereits in [33]. Damit können wir die Schaltbedingungen mittels der Hilfs-
Schaltfunktionen für den Übergang aus der Haftreibungsphase in die Gleitreibung mit positiver
(s = 1) bzw. negativer (s = −1) Relativgeschwindigkeit formulieren:
Die zugehörigen Schaltbedingungen für einen direkten Übergang von einer Gleitphase in die an-
dere ohne kurzzeitiges Haften lassen sich anschaulich mit Hilfe des Richtungsfeldes in Bild 5.36
finden. Danach erfolgt ein Wechsel von einer Bewegung mit positiver Relativgeschwindigkeit zu
einer mit negativer Relativgeschwindigkeit (s = 1 → s = −1), wenn
q = 0 ∧ S− ≤ 0 (5.132)
und in umgekehrter Richtung, wenn
q = 0 ∧ S+ ≥ 0. (5.133)
Definieren wir noch den Haftreibungsbereich
q=0 ∧ S+ < 0 ∧ S− > 0 durch s = 0, (5.134)
dann liegt insgesamt folgender Satz von Bewegungsgleichungen
1
ẍ1 = ( f1 (t) − μ fN s − k1 x1 )
m1
1
ẍ2 = ( f2 (t) + μ fN s − k2 x2 ) für s = ±1 (5.135)
m2
1
ẍ1 = ẍ2 = ( f1 (t) + f2 (t) − k1 x1 − k2 x2 ) für s = 0
m1 + m2
für das einfache Reibschwingungsproblem zugrunde, es ist ein strukturvariables System. Die
Hilfs-Schaltfunktionen S± ergeben sich mit (5.130) zu
1 1
S± = ( f1 (t) ∓ m1 gμ0 − k1 x1 ) − ( f2 (t) ± m1 gμ0 − k2 x2 ) , (5.136)
m1 m2
sie sind für q = 0 auszuwerten. Die zugehörige Dreipunkt-Schaltlogik ist in Bild 5.37 zusammen-
gefasst.
# #
q = 0 ∧ S− ≤ 0 -
s=1 s = −1
"! +
I q=0 ∧ S ≥0 "!
q=0∧ S+ = 0 q=0∧
S+ < 0 ∧ S − > 0 S− = 0 S+ < 0 ∧ S− > 0
#
R
s=0
"!
Bild 5.37: Dreipunkt-Schaltlogik
Anschauliche Deutung der Schaltzustände

Es soll die erarbeitete Schaltlogik mit Hilfe der Kraftverhältnisse während der Haftphase an-
schaulich erläutert werden. Dies bezieht sich insbesondere auf die Hilfs-Schaltfunktionen. Dazu
gehen wir vom Haftzustand mit der Reibkraft | fR0 | ≤ μ0 fN aus; d. h. fR0 kann beliebige Werte
aus dem Intervall [−μ0 fN , +μ0 fN ] annehmen. Voraussetzung des Haftens ist
! !
q = ẋ1 − ẋ2 = 0 ∧ q̇ = ẍ1 − ẍ2 = 0. (5.137)
Die zugehörige Kraftbilanz erhalten wir mit (5.137) aus (5.135)1,2 , wenn wir für die Reibkraft
μ fN s die Haftkraft fR0 setzen
1 1 m1 + m2 !
ẍ1 − ẍ2 = ( f1 (t) − k1 x1 ) − ( f2 (t) − k2 x2 ) − fR0 = 0. (5.138)
m1 m2 m1 m2
Da nach (5.137) die Beschleunigungsdifferenz verschwindet, können wir nach der Haftkraft auf-
lösen
1
fR0 = [m2 ( f1 (t) − k1 x1 ) − m1 ( f2 (t) − k2 x2 )] =: F(t), (5.139)
m1 + m2
d. h. Haften liegt vor, wenn
−μ0 fN < fR0 < μ0 fN , d. h. − μ0 fN < F(t) < μ0 fN , hier: fN = m1 g. (5.140)
Die der Reibkraft entgegenwirkende Kraft F(t) setzt sich aus den Anregungskräften und den Fe-
derkräften zusammen und ist unabhängig von den Beschleunigungen. Mit F(t) und der betrags-
mäßig größten Haftreibungskraft | fR0 | = μ0 fN lässt sich eine Kraftdifferenz, wie in Bild 5.38 dar-
gestellt, bilden, die Aufschluss bezüglich der Fortsetzung der Bewegungszustände liefert. Nach
f
6
μ0 fN
μ0 fN > F(t)
F(t)
6
Haften: -
vrel
−μ0 fN < F(t)
- μ0 f N
Bild 5.38: Kräfte im Haftreibungsbereich
Bild 5.38 hängt es von der jeweiligen Kraftdifferenz ab, ob es beim Haftzustand bleibt oder ob
ein Verlassen oder ein Durchschwingen auftreten kann. Dies wollen wir in drei Schritten erläu-
tern.
1. Befindet sich der Schwinger im Haftzustand (s = 0), dann kann dieser nach (5.140) nur
verlassen werden, wenn F(t ) = | fR0 |. Dies ist der Fall
wenn, F(t ) − μ0 fN = 0 s=0 → s=1

S̄+
oder wenn, F(t ) + μ0 fN = 0 s = 0 → s = −1,

S̄−
wobei wir die Kraftdifferenzen entsprechend der in (5.136) eingeführten Hilfs-Schaltfunk-

tionen S± mit S̄± abkürzen, sie unterscheiden sich nur durch einen unwesentlichen positiven
Faktor (m1 + m2 )/(m1 m2 ).
2. Bewegen sich die Massen vor dem Eintreten des Ereignisses q(t ) = 0 mit q
= 0, d. h.
s = ±1, dann wird sich nach dem Ereignis Haften einstellen, wenn mit (5.140)
−μ0 fN < F(t ) < μ0 fN
gilt, woraus wir
F(t ) − μ0 fN < 0 ∧ F(t ) + μ0 fN > 0
ablesen, d. h.
S̄+ < 0 ∧ S̄− > 0.
3. Bewegen sich die Massen vor und nach dem Eintreten des Ereignisses q(t ) = 0 mit q
= 0,
d. h. s = ±1 → s = ∓1, tritt also Durchschwingen – ohne Haftung – ein, dann muss gelten
−μ0 fN > F(t ) > μ0 fN ,
woraus
F(t ) − μ0 fN ≥ 0; d. h. S̄+ ≥ 0, s = −1 → s = 1
und
F(t ) + μ0 fN ≤ 0, d. h. S̄− ≤ 0, s = 1 → s = −1
folgt.
Damit sind alle zuvor eingeführten Schaltzustände auch mit Hilfe der aktuellen Kraft F(t) in der
Haftreibungsphase und dem Schwellwert der Haftung | fR0 | = μ0 fN zu erklären.
Die Schaltzustände sind somit von der Gleitreibungscharakteristik unabhängig und beschrän-
ken sich nicht auf die C OULOMB-Reibkennlinie unseres Beispiels, d. h. auch die aus Bild 5.33
können hier eingearbeitet werden.
Numerische Umsetzung, Programmausschnitte
Bezüglich der Programmierung wollen wir die Programmstruktur nach Bild 5.39 angeben und
daraus einzelne Programmsegmente besprechen. Die vollständigen Codes reib_12.m (Haupt-
programm), freib_12.m (Function der Bewegungsgleichungen), ereib_12.m (Function
der Ereignisse q, S) sowie spm_12.m (Function der Hilfs-Schaltfunktionen, S± ) sind der Pro-
grammsammlung [52] zu entnehmen.
Zunächst muss aus den Anfangswerten der momentane Zustand (Haften/Gleiten) ermittelt
werden. Die Initialisierung des Schaltkoeffizienten s lassen sich mit zugehörigem q aus der
Dreipunkt-Schaltlogik nach Bild 5.37 ablesen:
t0=0.0; % Startzeitpunkt
y0=[0.; 0.; 0.; 0.]; % Anfangswerte
Bild 5.39: Struktur des Programmpakets reib_12.m
q=y0(3)-y0(4); % Schaltfunktion (Relativgeschw.)
[sp,sm]=spm_12(t0,y0.’); % Hilfs-Schaltfunktion für Start

if q == 0 ; % Initialisierung zum Start
if sm < 0 s=-1;
elseif sp > 0 s=1;
else s=0; % sp < 0 & sm > 0
end
else
if q < 0 s=-1;
else
s =1;
end
end
wobei Nullstellen von S± ausgeschlossen sind. Zur Integration benutzen wir das RUNGE -K UTTA-
Verfahren ode45 mit den Optionen und dem Integrationsaufruf:
options=odeset(’Events’,@ereib_12,’RelTol’,1.0e-6);
[t,y,tE,yE,iE]=ode45(@freib_12,[t0 te],y0,options);
Wesentlich ist auch die Programmierung der Schaltlogik nach Bild 5.37 mit der die neue
Situation nach einem Ereignis bestimmt wird. Insbesondere ist eine Fehlergrenze (hier: feps)
für die numerische Null der Relativgeschwindigkeit und der Hilfs-Schaltfunktionen sp := S+ ,
sm := S− abzuschätzen. Dies ist problemabhängig; Anhaltswert: feps ≈ 10*AbsTol. Die
Umsetzung der Schaltlogik nach Bild 5.37 könnte folgende Struktur haben:
%....................................... Schaltlogik-Anfang
if s==0 % Haftung
[x,I]=min(abs([sp, sm])); % betragsmäßiger Minimalwert
if x <= feps
if I == 1, s=1;
else s=-1;
end
end
else
if abs(q) <= feps % Nullstelle der Relativ-Geschw.
if s==1 % aus Gleitphase
if sm < 0, s=-1;
elseif sp < 0 && sm > 0, s=0;
end
elseif s == -1
if sp > 0, s = 1;
elseif sp < 0 && sm > 0, s = 0;
end
end
end
end
%...................................... Schaltlogik-Ende
Die Bewegungsgleichungen sind in der Function freib_12.m, die Schaltfunktionen q, S±

zur Nullstellensuche in der Function ereib_12.m zu programmieren. Die Integrationsroutine
(hier: ode45) ruft nacheinander freib_12 und ereib_12 – vgl. Bild 5.39 – ab. Die Function
der Bewegungsgleichungen sowie die der Hilfs-Schaltfunktionen S± enthalten keine Besonder-
heiten, so dass wir hier nur die Function der Ereignisermittlung angeben wollen.
function [q,isterminal,direction] = ereib_12(t,y)
if s==0 % Schaltparameter
[sp,sm]=spm_12(t,y.’); % Schaltfunktionen S+, S-
q=[sp; sm]; % Nullstelle von S+, S-
isterminal= [1; 1]; % Stopp nach Nullstelle
direction= [0; 0]; % Flanke
else
q=[y(3)-y(4)]; % Nullstelle der Relativgeschw.
isterminal= 1; % Stopp nach Nullstelle
direction= -s; % Flanke
end
Erläuterung: Liegt Haftung (s = 0) vor, dann ermitteln wir zunächst zu den aktuellen Wer-
ten t, y die Hilfs-Schaltfunktionen S± mit der Function spm_12.m und untersuchen diese auf
Nulldurchgänge. Über die Steigung im Nulldurchgang (Flanke der Hilfs-Schaltfunktion) können
wir keine Angabe machen, so dass jeweils direction=0 zu setzen ist. Für s
=0 ist die Schalt-
funktion die Relativgeschwindigkeit an dem Reibkontakt. Da mit dieser Nullstelle das Durch-
schwingen (s = 1 → s = −1 und umgekehrt) entschieden wird, können wir die Steigung von q
im Nulldurchgang zu −s angeben. Nach jedem Ereignis wird die Integration unterbrochen.
Numerische Ergebnisse
Abschließend führen wir mit reib_12.m für das anfänglich eingeführte Beispiel nach Bild 5.35
mit den beiden Parametersätzen nach Tabelle 5.7 Simulationen durch. Aufgrund der harmoni-
schen Anregung sind periodische Schwingungen zu erwarten, wenn die Erregerkräfte groß genug
oder die Reibkräfte klein genug sind. Ansonsten wird der Schwinger in der Haftung verharren.
Ausgehend von den allgemeinen Anfangswerten
x1 (0) = 0, x2 (0) = 0, ẋ1 (0) = 0, x˙2 (0) = 0,
die nicht einer möglichen periodischen Bewegung genügen, betrachten wir zunächst einen Ein-
schwingvorgang zum Parametersatz des 1. Beispiels. In Bild 5.40 sind die Zeitverläufe der Aus-
Tabelle 5.7: Beispiel-Parameter des Zwei-Massen-Reibschwingers mit einem Reibkontakt
Beispiel 1 2 Einheit
Masse m1 1,0 1,0 kg
Masse m2 1,5 1,5 kg
Steifigkeit k1 10 10 N/m
Gleitreibkoeffizient μ 0,040 0,04 –
Haftreibkoeffizient μ0 0,080 0,06 –
Erdbeschleunigung g 9,81 9,81 m/s2
Erregerkraft f1 5 sin t sin t N
Erregerkraft f2 0 2 cos (t + π4 ) N
lenkungen x1 (t) , x2 (t), der Geschwindigkeiten xp1 := ẋ1 (t) , xp2 := ẋ2 (t), der Relativgeschwin-
digkeit zwischen den Massen vrel = ẋ1 − ẋ2 und der Hilfs-Schaltfunktionen S+ , S− zusammenge-
stellt. Man erkennt, dass die Haftreibungszeitabschnitte nur dann verlassen werden, wenn Null-
stellen von S+ oder S− vorliegen, was auch den Geschwindigkeitsverläufen abzulesen ist. Ob ein
Übergang vom Gleiten in die Haftung erfolgt, wird durch die Nullstelle von q = vrel und durch
die unterschiedlichen Vorzeichen von S+ und S− festgelegt; vgl. Bild 5.40. Ein direktes Durch-
schwingen (s = 1 → s = −1), so dass sich zwei Gleitreibungsphasen aneinanderreihen, tritt bei
t ≈ 1.6 sec auf; es ist q = 0 ∧ S− < 0. Insbesondere fällt auf, dass einerseits die einzelnen Zeit-
abschnitte ohne jede Überlappung aneinanderstoßen, und andererseits, dass die Ruhelage exakt
eingehalten wird. Dies ermöglicht eine effiziente numerische Integration. In Tabelle 5.8 sind in
Auslenkungen Relativgeschwindigkeit
1
x1 0.6
vrel=xp1−xp2 [m/sec]
0.5 x2 0.4
x1, x2 [m]
0.2
0 0
−0.2
−0.5 −0.4
−0.6
−1 −0.8
0 2 4 6 8 10 0 2 4 6 8 10
t [sec] t [sec]
Geschwindigkeiten Hilfs−Schaltfunktionen
1 4
xp1 S+
3
xp2 S−
0.5
xp1, xp2 [m/sec]
1
S+, S−
0
0
−1
−0.5
−2
−1 −3
0 2 4 6 8 10 0 2 4 6 8 10
t [sec] t [sec]
Bild 5.40: Beispiel 1: Zeitverläufe des Zwei-Massen-Reibschwingers mit einem Reibkontakt

einem Schaltprotokoll ausgehend von den Startwerten alle Ereignisfälle in Form des Schaltkoef-
fizienten s, des Ereigniszeitpunkts τ (Näherung von t ), der Schaltfunktion q sowie der beiden
Hilfs-Schaltfunktionen S+ , S− aufgeführt. Mit diesem Schaltprotokoll sowie Bild 5.37, Bild 5.40
sind alle Schaltvorgänge nachvollziehbar.
Tabelle 5.8: Beispiel 1: Schaltzustände
Schaltprotokoll:
s tau* q sp sm
--------------------------------------------------------------------
0 0 0 1.3080e+000 -1.3080e+000
0 2.6902e-001 0 -1.6154e-014 2.6160e+000
1 1.6076e+000 -1.8041e-016 -2.8366e+000 -2.2056e-001
-1 4.4139e+000 4.9960e-015 -2.7078e-001 2.3452e+000
0 5.1583e+000 4.9960e-015 8.9817e-014 2.6160e+000
1 7.6160e+000 -1.0036e-013 -1.5734e+000 1.0426e+000
0 8.5177e+000 -1.0036e-013 -2.6160e+000 -2.4636e-013
-1 1.0000e+001 -6.1217e-001 -1.4189e+000 1.1971e+000
Für den zweiten Parametersatz nach Tabelle 5.7 – Beispiel 2 – gehen wir von den Anfangs-
werten
x1 (0) = −0.073269, x2 (0) = 0.17881, ẋ1 (0) = −0.15717, ẋ2 (0) = −0.17973,
die einer periodischen Lösung genügen, aus. Sie ergaben sich, ausgehend von beliebigen An-
fangswerten, aus einer Integration über mehrere Perioden (Periodendauer T = 2π), wobei am
Ende die freien Schwingungen abgeklungen sein müssen; vgl. Bild 5.41, Bild 5.42.
Die periodischen Lösungen in Bild 5.41 zeichnen sich dadurch aus, dass sich die Lösungen
nach der Periodendauer T = 2π wiederholen,
x j (T + t) = x j (t), ẋ j (T + t) = ẋ j (t), j = 1, 2; S± (T + t) = S± (t) usw..
Für die Phasenkurven in Bild 5.42 bedeutet dies geschlossene Kurvenzüge. Der Mehrfachum-
lauf (fetter Linienzug) weist auf eine erste Oberschwingung hin. Dies bestätigt Bild 5.411 für
x1 (t). Typische Merkmale für Haft-Gleit-Systeme sind Sprünge und Knicke in den Phasenkur-
ven ẍ j (ẋ j ), j = 1, 2 von Bild 5.422 . Zustandsübergänge zum Haften sowie Wechsel in der Glei-
trichtung führen zu Sprüngen in den Beschleunigungen. Übergänge vom Haften zum Gleiten
sind wegen der Reibkennlinie mit einem Knick in den Beschleunigungen verbunden. Für die Ge-
schwindigkeiten bedeutet dies, dass sie zwar stetig aber nicht differenzierbar sind, vgl. Bild 5.413 .
Die Lagegrößen x1 , x2 sind dagegen immer glatt. Die gegenseitige Beeinflussung durch die Tan-
gentialkraft drückt sich durch die Knicke und Sprünge in beiden Koordinaten gleichzeitig aus.
Die sich abwechselnden Haft- und Gleitbewegungen bezeichnet man auch als Stick-Slip-Schwin-
gungen.
Das in Abschn. 4.4 behandelte 1/4-Fahrzeug mit Reibelement kann mit den hier besproche-
nen Methoden auch unter MATLAB gelöst werden. Hierzu dient das Programm reib_F.m der
Auslenkungen Relativgeschwindigkeit
0.3 0.6
0.2 0.4
vrel=xp1−xp2 [m/sec]
x1, x2 [m] 0.1 0.2
0 0
−0.1 −0.2
−0.2 −0.4
x1
−0.3 x −0.6
2
−0.4 −0.8
0 2 4 6 8 0 2 4 6 8
t [sec] t [sec]
Geschwindigkeiten Hilfs−Schaltfunktionen
0.4 3
xp1 S+
xp2 2 S
−
0.2
xp1, xp2 [m/sec]
−
S ,S
0 0
+ −1
−0.2
−2
−0.4 −3
0 2 4 6 8 0 2 4 6 8
t [sec] t [sec]
Bild 5.41: Beispiel 2: Periodische Schwingungen des Zwei-Massen-Schwingers mit einem Reibkontakt
0.4 1.5
m1
1
m2
0.2
0.5
2
xpp , xpp
xp1, xp2
0 0 m2
1
−0.5
−0.2
−1
m1
−0.4 −1.5
−0.2 −0.1 0 0.1 0.2 0.3 −0.4 −0.2 0 0.2 0.4
x1, x2 xp1, xp2
Bild 5.42: Beispiel 2: Phasendiagramme der periodischen Schwingungen des Zwei-Massen-

Reibschwingers mit einem Reibkontakt
Programmsammlung [52], in das das Zeitereignis – Auffahrt über die Rampe – und das Zustand-
sereignis – Haft- und Gleitreibung – realisiert sind. Darüber hinaus wird in Abschn. 4.4.1 die
Modellierung des Beispiels unter Simulink mit dem Stateflow Tool gezeigt.
Übungsvorschlag: Die Masse m des skizzierten Schwingers bewegt sich infolge Reibung auf
dem mit v0 umlaufenden Band. Die Fesselung von m erfolgt über eine Feder (Federsteifigkeit k)
und einen Dämpfer (Dämpfungskoeffizient d). Beide Kraftcharakteristiken sind linear (FF = kx,
FD = d ẋ).
Gegeben: m = 1,5 kg D = 0,... 0,01 μ = 0,08 g= 9,81 m/s2
k = 2 N/m v0 = 1,0 m/s μ0 = 1,5 μ
Bild 5.43: Reibschwinger und Kennlinie
1. Formulieren Sie die Bewegungsgleichungen für die Gleit- und Haftphase.

2. Formulieren Sie die Schaltfunktionen und Hilfs-Schaltfunktionen für eine numerische Inte-
gration.
3. Erstellen Sie die Programme für die Simulation der selbsterregten Schwingungen.
4. Führen Sie für die Anfangswerte
x 0 = (−0,1, −2,0 v0 )T x 0 = (−0,1, 2,0 v0 )T
T
x 0 = (−0,1, −1,5 v0 ) x 0 = (−0,1, 1,5 v0 )T
eine Simulation durch und stellen Sie die Ergebnisse in der Phasenebene ẋ(x) dar.
Hinweise in: s_reib.pdf in [52].
5.6.5.3 Reibschwinger mit zwei Reibkontakten

Generell steigt der Aufwand, wenn in einem Modell mehrere Ereignisse zum selben Zeitpunkt
eintreten. Dies ist z. B. der Fall, wenn mehrere Reibkontakte in einem Modell vorhanden sind.
Die Mannigfaltigkeit der möglichen Bewegungsformen und der Schaltzustände erhöht sich erheb-
lich. Das Auffinden der richtigen Kontaktzustände resultiert in einem kombinatorischen Problem.
Tabelle 5.9: Beispiel-Parameter des Zwei-Massen-Reibschwingers mit zwei Reibkontakten
Beispiel 3 4 Einheit
Masse m1 1,0 1,0 kg
Masse m2 1,5 1,0 kg
Gleitreibkoeffizient μ1 0,040 1 –
Haftreibkoeffizient μ10 0,060 1 –
Gleitreibkoeffizient μ2 0,002 1 –
Haftreibkoeffizient μ20 0,004 1 –
Erdbeschleunigung g 9,81 10 m/s2
Erregerkraft f1 sin t 15 cos (2πt + π) N
Erregerkraft f2 0 60 cos (2πt) N
Dieses lässt sich am Reibschwinger nach Bild 5.35 mit der hier eingeführten Vorgehensweise
verdeutlichen, wenn wir in beiden Kontaktflächen Reibung zulassen. Die Reibkoeffizienten zwi-
schen den beiden Massen bezeichnen wir mit μ1 , μ10 und zwischen der Masse m2 und der
Auflage mit μ2 , μ20 .
5.7 Randwertprobleme gewöhnlicher Differenzialgleichungen 303
Um die vorgeschriebene Seitenzahl des Buches einzuhalten, müssen wir diese Vorgehenswei-
se auslagern. Der entsprechende Beitrag (reibung_2.pdf) ist in der Programmsammlung [52] zu
Kapitel 5 enthalten. Wir diskutieren dort die Ergebnisse der Beispiele 3 und 4 mit den Parametern
nach Tabelle 5.9. Beispielrechnungen sind mit dem in [52] abgelegten Programm reib_34.m
durchzuführen. Die Parameter zum dritten Beispiel sind [23] entnommen.
Zusammenfassend lässt sich festhalten: Treten mehrere Ereignisse in einem System und dar-
über hinaus zum gleichen Zeitpunkt auf, dann wird die Betrachtung erheblich komplexer und
umfangreicher. Bezüglich der Reibung existiert im SimMechanics Tool, Kapitel 7, ein Block,
mit dem Reibung in Gelenken unter Simulink recht einfach modellierbar wird. Dies bezieht sich
auch auf die angesprochenen Mehrfachkontaktprobleme. Wir zeigen im Abschn. 7.2 diese Mo-
dellierung anhand der Beispiele 3 und 4.
5.7 Randwertprobleme gewöhnlicher Differenzialgleichungen
Bei den bisher betrachteten Simulationen waren Anfangswertprobleme bzw. Anfangswertaufga-

ben zu lösen, d. h. neben der Differenzialgleichung müssen Anfangswerte, Zeit t0 und entspre-
chend der Ordnung der Differenzialgleichung Anfangszustände y (t0 ) = y 0 , gegeben sein. Im Ge-
gensatz dazu sind bei Randwertproblemen bzw. Randwertaufgaben [60] Werte der abhängigen
Variablen am Anfang und Ende eines Intervalls bezüglich der unabhängigen Variable zu erfüllen.
5.7.1 Grundlagen
In diesem Abschnitt soll gezeigt werden, wie Randwertprobleme (Boundary Value Problem,
BVP) mit MATLAB gelöst werden können. Bei derartigen Problemen ist die einzige unabhängi-
ge Variable (im Gegensatz zu partiellen Differentialgleichungen) u. a. der Ort x oder wie bisher
die Zeit t. Man formuliert, wie auch in MATLAB, die Probleme gerne mit x
dyy
y (x) = = f (x, y ) auch y (x) = f (x, y , p )
dx (5.141)
g (yy(a), y (b)) = 0 auch g (yy(a), y (b), p ) = 0 ,
d. h. neben der Differenzialgleichung n-ter Ordnung sind zugehörige Randbedingungen an den

Rändern des Intervalls [a, b] zu formulieren. Darüber hinaus sind unbekannte Parameter im Vek-
tor p zulässig. Gesucht ist eine Funktion y (x) bzw. y (x, p ), die zum einen die Differentialglei-
chung erfüllt, zum anderen die Bedingung g (..) = 0 für die Funktionswerte (oder Ableitungen)
zu den Intervallgrenzen a, b. Es ist ein Zweipunkt-Randwertproblem zu lösen. Es können, im
Gegensatz zum Anfangswertproblem, eine, mehrere oder gar keine Lösung existieren.
Zur Lösung derartiger Probleme stehen die MATLAB-Routinen bvp4c und bvp5c zur Verfü-
gung. Sie basieren auf dem Kollokationsverfahren, welches wir kurz für y(x) beschreiben. Die
Lösung y des Randwertproblems (5.141) wird durch stetige, stückweise kubische Funktionen
S(x) approximiert. Dazu wird das Intervall [a, b] diskretisiert. Es setzt sich [a, b] aus N − 1 Sub-
intervallen [xi , xi+1 ] mit
a = x1 < x2 < .... < xN−1 < xN = b (5.142)

zusammen, wobei auf jedem Intervall [xi , xi+1 ] die Lösung des Randwertproblems durch ein
kubisches Polynom Si (x) (x ∈ [xi , xi+1 ]) approximiert wird. Si wird so ermittelt, dass am An-
fang, dem Ende und in der Mitte des Intervalls die Differenzialgleichung (5.141)1 exakt erfüllt
wird. Zusätzlich sind Stetigkeitsbedingungen zu formulieren, so dass die aus den Teillösungen
zusammengesetzte Lösungsfunktion S(x) auf [a, b] ebenfalls stetig ist. Gleichzeitig müssen die
Randbedingungen (5.141)2 erfüllt sein. Insgesamt ergibt sich nach [60] ein nichtlineares Glei-
chungssystem, das in MATLAB iterativ durch Linearisierung (N EWTON) gelöst wird. Hierzu
ist die JACOBI-Matrix J = ∂ f /∂yy für jeden Schritt näherungsweise zu ermitteln oder die vom
Benutzer erstellte Matrix auszuwerten. Nach [60] ist S(x) eine Approximation 4. (bvp4c) bzw.
5. (bvp5c) Ordnung an eine isolierte Lösung y(x), d. h. es gilt für bvp4c
y(x) − S(x) ≤ Ch4 mit h = max (xi+1 − xi ) und C = konstant. (5.143)

i=1,..,N
Zur Lösung des Randwertproblems muss danach eine Ortsdiskretisierung (ggf. von MAT-
LAB geändert) und Startwerte für die gesuchte Lösung auf dem Intervall [a, b] vorliegen.
Wie später gezeigt, können zusätzliche unbekannte Parameter im Vektor p zu ermitteln sein.
In diesem Fall muss die Anzahl der Bedingungen (5.141)2 um die von p erhöht werden.
Darüber hinaus kann das Vorgehen auch für Probleme mit Punktbedingungen im Innern [a, b]
(Multipoint boundary value problems) angewendet werden. Dazu wird z. B. die Stetigkeitsbedin-
gung Si−1 (xi ) = Si (xi ) in den unstetigen Komponenten u. a. durch Sprungbedingungen ersetzt.
Entsprechend der n − 1 Punktbedingungen wird das Intervall [a, b] in n Bereiche (Regionen)
unterteilt
[[a, a1 ] , [a1 , a2 ] , [a2 , a3 ] , · · · , [an−1 , b], (5.144)
d. h. die k-te (k = 1,2, ..) Differenzialgleichung y k = f (yyk ) hat ihre Gültigkeit im Bereich [ak−1 , ak ],
wobei a0 = a, an = b. Zu den inneren, zusammenfallenden Bereichsgrenzen gehört der gleiche x-
Wert. Unter MATLAB werden alle Funktionswerte der linken bzw. rechten Ränder zu Matrizen
zusammengefasst. Für Systeme zweiter Ordnung und n Bereichen bedeutet dies:

y1 (a) y2 (a1 ) .. yn (an−1 ) y1 (a1 ) y2 (a2 ) .. yn (b)
Y links = , Y = . (5.145)
y 1 (a) y 2 (a1 ) .. y n (an−1 ) rechts
y 1 (a1 ) y 2 (a2 ) .. y n (b)
Die Vorgehensweise derartiger Probleme wird zunächst an einfachen Beispielen erläutert. Dar-
auf aufbauend sollen systematisch periodische Schwingungen behandelt werden.
Ausführliche Information mit vielen Beispielen sind dem Handbuch und der Online-Hilfe bzw.
>> odeexample –Aufruf aus dem Command Window– zu entnehmen.
5.7.2 Standardproblem am Beispiel der Kettenlinie
Befestigt man eine Kette an den freien Enden in einem vorgegebenen Abstand w0 , dann ergibt
sich ein eindeutiger Durchhang, den man Kettenlinie, siehe Bild 5.44, nennt. Die zugehörige
Differenzialgleichung 2. Ordnung 10 lautet

!
d(.)
y (x) = d 1 + y (x)2 , (.) = (5.146)
dx
und mit
y 1 = y2
diff
y1 = y −→
(5.147)
y2 = y y 2 = y = d
diff
−→ 1 + y2 (x)2
in vektorieller Form

y2
y = = f (yy) , (5.148)
d 1 + y2 (x)2
d ist ein Systemparameter. Hinzu kommen die Randbedingungen

linker Rand y(a) = yL y(a) − yL
=⇒ g (y(a), y(b)) = = 0, (5.149)
rechter Rand y(b) = yR y(b) − yR
wobei yL , yR vorgegeben. Sind ya , y a , yb , y b Näherungen während des Lösungsablaufs von y(a),

y (a) y(b) y (a), dann ist das Residuum r res und die Randzustände ya , yb :

ya − yL T
r es = , ya = ya , y a , yb = yb , y b . (5.150)
yb − yR
Damit ist das MATLAB Script zu schreiben. Da (5.148) und (5.150) sehr übersichtliche Aus-
drücke sind, legen wir hierfür Anonymous Functions Kette_dgl, Kette_res an.
1 yL=0.2; yR=0.1; % Randwert links / rechts

2 w0=4.0; % Randpunkt-Abstand
3 d=1/15; % Systemparameter
4 % ---- Function Handle, Anonymous Function
5 Kette_dgl=@(x,y) ([y(2); d*sqrt(1.0+y(2)^2)]);% Differenzialgl.
6 Kette_res=@(ya,yb) ([ya(1)-yL; yb(1)-yR]); % Residuum
7 % ---- Function Aufruf
8 options = bvpset(’stats’,’on’); % Option
9 solinit=bvpinit(linspace(0,w0,10),[1;1]); % Initialisierung
10 sol = bvp4c(Kette_dgl,Kette_res,solinit,options);% Randwertproblem
Das Ergebnis steht in der Structure:
sol = solver: ’bvp4c’

x: [0 0.4444 0.8889 1.3333 1.7778 2.2222 2.6667 3.1111 3.5556 4]
y: [2x10 double]
yp: [2x10 double]
stats: [1x1 struct]
10 http://mathsrv.ku-eichstaett.de/MGF/homes/grothmann/Projekte/Kettenlinie/
Die obigen Function-Namen sol, solinit sind beliebig, die Feldnamen x, y dagegen fest-
geschrieben.
Erläuterungen und Ergänzungen: In den Zeilen 1-4 werden Randwerte und Parameter ver-
einbart, in Zeile 5 die Function der Differenzialgleichung (5.148) mit den festgeschriebenen
Argumenten (x,y), in 6 das Residuum (5.150) aus ermittelter Näherung der Randwerte ya(1),
yb(1) und den Vorgaben yL, yR erstellt.
Da (5.148) eine Differenzialgleichung 2. Ordnung, enthält y , wie in (5.147), die beiden Kom-
ponenten des Durchhangs y1 = y → y(1) am Ort x und die zugehörige Neigung y2 = y → y(2).
Entsprechendes gilt für die Randwerte y (a) → (ya(1); ya(2)), y (b) → (yb(1); yb(2)).
In Zeile 8 werden mit bvpset die ausgewählten Optionen gesetzt. Hier wird mit ’stats’,
’on’ eine Ausgabe von Informationen aus dem Lösungsweg erreicht. Unabhängig davon sind
sie stets in der Structure sol (Zeile 10) unter sol.stats enthalten.
Mit der Hilfs-Function bvpinit in Zeile 9 wird die Structure solinit mit den Initialisie-
rungsdaten: Gitterpunkte von x, z. B. x=linspace(0,w0,10), abgelegt im Feld solinit.x,
sowie den Schätzwerten der Lösung y an den Gitterpunkten, abgelegt in solinit.y, erstellt.
Die Argumente von bvpinit sind einerseits, wie in Zeile 9, die gewählten Gitterpunkte x(1),
x(2),...x(10) und die zugewiesenen konstanten Schätzkomponenten, z. B. [1;1] entspre-
chend Durchhang und Neigung für alle x (sehr grobe Näherung); andererseits kann das zweite
Argument von bvpinit ein Function Handle sein. Die Function wertet dann eine programmierte
Schätzfunktion an den Gitterpunkten x aus.
Beispiel: Approximieren wir den Durchhang durch eine Verbindungsgerade zwischen den Rand-
werten yL , yR , dann gilt für die Schätzfunktion
⎡ ⎤
yR − yL
y + x Geradengleichung
y ⎢ L ⎥
y = ≈ ⎣ yR − yL w0 ⎦ (5.151)
y
konstante Steigung.
w0
Legen wir hierfür wieder eine Anonymous Function an, dann ist das obige Programmsegment um
die unten angegebene Zeile 6a für die Schätzfunktion zu ergänzen sowie die Zeile 9 zu ersetzen.
6a Kette_init=@(x) ([yL+(yR-yL)/w0*x;(yR-yL)/w0]);% Initial.

9 solinit=bvpinit(linspace(0,w0,10),Kette_init); % Initial.
Die Felder solinit.x, solinit.y der Structure solinit können natürlich auch unmittel-
bar besetzt werden. Eine Möglichkeit zeigen die folgenden Zeilen:
6a Kette_init=@(x) ([yL+(yR-yL)/w0*x;(yR-yL)/w0*ones(size(x))]);
9 solinit.x = linspace(0,w0,10); % Gitterpunkt
9a solinit.y = Kette_int(solinit.x) % Näherung
Weitere Optionen dienen der Rechenzeit-Reduzierung. Dies sind:
• die Vektorisierung der Differentialgleichung, so dass diese bei jedem Aufruf für alle Gitter-
punkte x ausgewertet wird,
• die analytische Erstellung der JACOBI-Matrix der rechten Seite f (yy) von (5.148)
⎡ ⎤
0 1
∂f ⎢ y ⎥
J = = ⎣ 0 d! 2 ⎦, (5.152)
∂yy 1 + y2
2
• die analytische Ermittlung der JACOBI-Matrizen der Residuen (5.150)

∂rr es 1 0 ∂rr es 0 0
Ja = = , Jb = = . (5.153)
∂yya 0 0 ∂yyb 1 0
Dieses erreichen wir mit den auszutauschenden Programm-Zeilen:

5 Kette_dgl=@(x,y) ([y(2,:); d*sqrt(1.0+y(2,:).^2)]); % Dgl. vekt.
6a Kette_init=@(x) ([yL+(yR-yL)/w0*x;(yR-yL)/w0]); % Initial.
6b Kette_bvpJac=@(x,y) ([0 1; 0 d*y(2)/sqrt(1+y(2)^2)]); % JACOBI-M.
% ---- Function Aufruf
8 options = bvpset(’Vectorized’,’on’,’FJacobian’,Kette_bvpJac,...
’BCJacobian’,@Kette_bvpJR,’stats’,’on’);
9 solinit=bvpinit(linspace(0,w0,10),Kette_init); % Initial.
wobei Kette_bvpJR.m eine separate Function ist. Den Einfluss der Vektorisierung in Kette-
_dgl und der Vorgabe der JACOBI-Matrix J nach (5.152) in Kette_bvpJac sowie der von J a
und J b nach (5.153) in @Kette_bvpJR.m zeigt der durch die Option ’stats’,’on’ erzeugte
Ausdruck:
The solution was obtained on a mesh of 10 points. The solution ... of 10 points.
The maximum residual is 6.797e-004. The maximum residual is 2.532e-005.
There were 117 calls to the ODE function. There were 9 calls to the ODE function.
There were 12 calls to the BC function. There were 4 calls to the BC function.
In der linken Hälfte ohne, in der rechten mit den zusätzlichen Optionen. Danach reduzieren sich
die Aufrufe/Auswertungen von Kette_dgl von 117 auf 9 und die von @Kette_bvpJR.m von 12
auf 4. Dies sind wesentliche Faktoren zur Rechenzeitreduzierung, insbesondere bei komplexen
Systemen höherer Ordnung und vielen Stützstellen.
Eine feinere Diskretisierung und damit eine geglättete Darstellung erhält man anschließend mit:
sxinit=deval(sol,linspace(0,4,20),1);~~~~% für 1. Komponente
Alle zulässigen Optionen erhalten wir nach Eingabe von bvpset ins Command Window:
>> bvpset
AbsTol: [ positive scalar or vector {1e-6} ] (1)
RelTol: [ positive scalar {1e-3} ] (2)
SingularTerm: [ matrix ] (3)
FJacobian: [ function_handle ] (4)
BCJacobian: [ function_handle ] (5)
Stats: [ on | {off} ] (6)
Nmax: [ nonnegative integer {floor(10000/n)} ] (7)
Vectorized: [ on | {off} ] (8)
Die ersten (1) und (2) beziehen sich auf Fehlertoleranzen, (3) bezieht sich auf spezielle singuläre
Differenzialgleichungen -siehe Online-Hilfe-, mit (7) kann man die Gitterpunkte in solinit.x
nach oben begrenzen. Die restlichen haben wir bereits erläutert und eingesetzt.
5.7.3 Mehrpunkt-Randwertprobleme
Es kann vorkommen, dass innerhalb des Intervalls [a, b] weitere Randwerte, z. B. durch Sprung-,
Stetigkeits- oder Gleichungsbedingungen, erfüllt werden müssen, so dass nun ein Mehr-Punkt-
Randwertproblem mit bvp4c bzw. bvp5c zu lösen ist. Die Differenzialgleichungen müssen be-
reichsweise formuliert werden. Beispiel: Beidseitig gestützter Balken mit einem Gelenk zwi-
schen den Lagern. Rechts und links am Gelenk sind zwar die Durchbiegungen gleich, die Nei-
gungen der Biegelinie aber unterschiedlich, vgl. Übungsvorschlag.
Wir wollen diese Problematik an einem auf dem bisherigen Beispiel aufbauenden erläutern.
Hierzu fügen wir zwischen den Lagern [a, b] = [[a, a1 ], [a1 , b]] eine mittig angebrachte (konstru-
ierte) Unstetigkeit in a1 ein, so dass zwei Ketten aufgehängt werden können, vgl. Bild 5.44.
Normalerweise würde man die beiden Kettenlinien getrennt betrachten, wir fassen es zu einer
Aufgabe zusammen, so dass ein Drei-Punkt-Problem mit zwei Bereichen [a, a1 ], [a1 , b] zu lösen
ist. Die beiden Differenzialgleichungen unterscheiden sich nur in den Parametern d1 , d2

yk,2
y k = = f (yyk ) , k = 1, 2. (5.154)
dk 1 + yk,2 (x)2
Die Randwerte im Bereich 1 [a, a1 ] seien y1 (a) = yL,1 , y1 (a1 ) = yR,1 , im Bereich 2 [a1, b]
y2 (a1 ) = yL,2 , y2 (b) = yR,2 .
MATLAB-Formulierung: Für die Initialisierung eines zugehörigen Gitternetzes setzen wir:
xinit = [0, 0.25, 0.5, 0.75, 1, 1, 1.25, 1.5, 1.75, 2]*w0/2;
wobei der doppelte Wert x=1*w0/2 zu a1 gehört. Die Bereichsansteuerung wird in einem zusätz-
lichen Argument in der Function der Differenzialgleichungen (5.154) berücksichtigt, d. h.
function dydx = Kette_Mdgl(x,y,bereich)

global d
dydx(1,:) = y(2,:);
switch bereich
case 1 % x: [0 w0/2], Bereich 1
dydx(2,:) = d*sqrt(1.0+y(2,:).^2);
case 2 % x: [w0/2 w0], Bereich 2
dydx(2,:) = 5*d*sqrt(1.0+y(2,:).^2);
otherwise
error(’Randw:Kette_Mbvp:Index’,...
’Falscher Bereichs-Index: %d’,bereich);
end
Unter Beachtung der Indizierung von (5.145) können die Residuen (Spaltenvektor) formuliert
werden:
function res=Kette_Mres(Y_links,Y_rechts)
global yL1 yR1 yL2 yR2
res=[Y_links(1,1)-yL1; Y_rechts(1,1)-yR1;
Y_links(1,2)-yL2; Y_rechts(1,2)-yR2];
Die Initialisierung der Schätzwerte übernehmen wir aus (5.151), wobei dies auf die Bereiche
übertragen werden muss, wie in der Function Kette_Minit.m in [52].
Bild 5.44: Kettenlinie, Zwei- und Drei-Punkt-Randwertproblem
In Bild 5.44 rechts ist das Ergebnis des Drei-Punkt-Randwertproblems dargestellt. Dabei fällt
die grobe Diskretisierung auf. Eine Glättung der Kurven kann nur bedingt durch deval erreicht
werden, weil die Sprungstelle durch den Mittelwert approximiert wird. Eine, zwar teure, Möglich-
keit ist eine feinere Anfangs-Diskretisierung, z. B mit xinit=[linspace(0,w0/2,20),lin-
space(w0/2,w0,20)]; sofern sie nicht von MATLAB geändert wird.
Das Programm Kette_bvp enthält beide Beispiele und ist mit allen Functions in [52] enthal-
ten.
Übungsvorschlag: Das skizzierte Modell11 besteht aus zwei Biegeträgern mit den konstanten
Biegesteifigkeiten EI1 , EI2 , die durch ein Gelenk verbunden sind. Die Abstützung erfolgt durch
die Federn c1 , c2 in A und C sowie dem Festlager und der Drehfeder cT in B. Belastung ist die
Einzelkraft F und die linear ansteigende Streckenlast q1 . Zu ermitteln ist die Biegelinie als Rand-
wertproblem. Dabei ist die Rechnung mit den Einheiten mm, N und m, kN der Systemgrößen
durchzuführen. Die Beurteilung der Rechnung soll anhand der Aufrufe der Differenzialgleichun-
gen erfolgen. Gegeben:
q1
Differenzialgleichungen: v 1 (x1 ) = 0, v
2 (x2 ) = x2
EI2 2
Bild 5.45: Zweifeld-Biegeträger
Parameter: 1 = 1 200 mm, 2 = 1 300 mm, F = 800 N, M = 220 Nm, q1 = 1,4 N/mm,
EI1 = 3 kN m2 , EI2 = 5 kN m2 , c1 = 50 N/mm, c2 = 300 N/mm, cT = 5 kN m
Hilfe: fGTraeger.m in [52].
11 http://www.tm-aktuell.de/TM2/Aufgabe_18-15/aufgabe_18_15.html
Rand- und Übergangsbedingungen für v1 (x1 ) und v2 (x2 ):
A: M = −EI1 v 1 (0) c1 v1 (0) = −EI1 v 1 (0)

C: v1 (1 ) = v2 (0) v 1 (1 ) = 0
v 2 (0) = 0 −EI1 v
1 (1 ) + c2 v2 (0) + EI2 v2 (0) − F = 0
B: v2 (2 ) = 0
cT v2 (2 ) = −EI2 v2 (2 )
5.7.4 Periodische Schwingungen nichtlinearer Systeme

In Anlehnung u. a. an die Beispiele aus Abschn. 4.6 unterscheiden wir Differenzialgleichungen
der Form
M (xx) ẍx + g (xx, ẋx) = 0 , M (xx) ẍx + g (xx, ẋx) = q sin (Ωt + Φ) . (5.155)
Einerseits ist mit (5.155)1 ein autonomes System, die Zeit tritt explizit nicht auf, andererseits mit
(5.155)2 ein nichtautonomes System, die Zeit tritt explizit auf, zu untersuchen. Beide Gleichungs-
typen haben wir in Abschn. 4.5 und folgenden als Anfangswertproblem gelöst. Hier formulieren
wir sie als Zwei-Punkt-Randwertproblem, um somit gezielt periodische Schwingungen zu ermit-
teln. Im Gegensatz zum Anfangswertproblem, mit dem nur stabile Schwingungen ermittelbar
sind, enthalten die Lösungen des Randwertproblems keine Information bezüglich derer Stabili-
tät, sie können stabil oder instabil sein. Physikalisch sind nur die stabilen Lösung von Bedeutung.
Mathematisch erhält man mit allen möglichen Lösungen einen besseren Überblick über die Lö-
sungsmannigfaltigkeit des Problems. Es muss also eine zusätzliche Stabilitätsuntersuchung der
gefundenen Lösung folgen, wir geben später stichwortartig eine Möglichkeit an.
Achtung! Gegenüber den bisher verwendeten Bezeichnungen der Variablen in den Randwert-
problemen ist jetzt die unabhängige Variable die Zeit t (statt die Ortskoordinate x).
5.7.4.1 Autonome Schwingungssysteme

T
Mit dem Zustandsvektor y = xT , ẋxT erhalten wir (5.155)1 in expliziter Form
ẏy(t) = f (yy(t)) (5.156)
der Ordnung n. Es stellt sich zunächst die Frage: gibt es Lösungen
y = y0 mit y0,i = const, i = 1,2, · · · , n aus f (yy0 ) = 0 ? (5.157)
wozu das nichtlineare algebraische Gleichungssystem f (yy0 ) = 0 , z. B. mit dem N EWTON-Ver-

fahren, zu lösen ist. y 0 ist die Gleichgewichts- oder Ruhelage. Sie kann stabil oder instabil sein.
Dies wollen wir hier nicht weiter verfolgen.
Insbesondere wenn y0 = const instabil wird, ist zu vermuten, dass auch periodische Lösungen
mit der Schwingungsdauer T , selbsterregte Schwingungen, der Form
2π
y (t + T ) = y (t), T = (5.158)
ωs
existieren. Die Kreisfrequenz ωs ist unbekannt, sie ist abhängig von den Systemparametern. D. h.
zur Formulierung des Randwertproblems muss ωs explizit auftretender Parameter der Differenzi-
algleichung sein. Dies erreichen wir durch die Zeittransformation
d d dτ d d
τ = ωst → = = ωs , = () (5.159)
dt dτ dt dτ dτ
mit der dimensionslosen Zeit τ. Angewendet auf (5.156) ergibt
ωs y (τ) = f (yy(τ)), y (τ + 2π) = y (τ) , (5.160)
y (τ) ist 2π-periodisch. Neben den Randwerten ist jetzt auch der Parameter ωs , wie in (5.141)
zugelassen, unbekannt. Eine zusätzliche Bedingung muss her. Da in (5.160) die Zeit τ nicht ex-
plizit auftritt, können wir den Zeitnullpunkt τ0 so verschieben, dass ein Randwert yk (τ0 ) aus y
festgeschrieben werden kann, z. B. yk (τ0 ) = 0 – muss verträglich mit der Lösung sein! Die er-
weiterten Randbedingungen sind somit
y (τ + 2π) − y (τ) = 0
(5.161)
yk (τ0 ) = 0, k ∈ 1,2, . . . , n; meist τ0 = 0 .
Bemerkung: Der Zustandsvektor y (τ) enthält z. B. die Komponenten y1 = y und y2 = ẏ. Dies ist
nachteilig für eine durchgehende Betrachtung in τ. Es ist vorteilhafter die Zeittransformation in
(5.155) einzuführen, so dass y (τ) = [y, y ]T enthält.
Beispiel mit MATLAB Script
Die wesentlichen Schritte zur Vorgehensweise zeigen wir am Modell des Metronoms nach Ab-
schn. 4.5 Gleichung (4.30). Danach folgt mit y1 = ϕ, y2 = ϕ̇ und den Parametern nach Bild 4.36
" #
y2
ẏy = g . (5.162)
− M+mmsin 2 y 12 y22 sin (2y1 ) + M+m
m L sin y1 − mL2 α − β y1 y2
1 2
1
Unterschiede bezüglich der Löser bvp4c, bvp5c zeigten sich bei der Parameterübergabe an die
einzelnen Functions. Während bvp4c eine mit den ODE-Lösern vergleichbare Übergabe durch
Erweitern der Argumente zuließ, z. B.
sol = bvp4c(@fmetro_dglS,@metro_res,solinit,options,M,m,...);
ist das bei bvp5c nicht erlaubt. Beide Löser können parallel genutzt werden, wenn wir eine Functi-
on fmetro_bvp.m mit Nested Functions anlegen. U. a. sind die Parameter dann persistent, siehe
Abschn. 1.5.4.2, sie sind im Editor farblich hervorgehoben. In diesem Fall gilt für die Initialisie-
rung und den Löser-Aufruf:
1 Om=20; % Selbsterregerfreq. omega_s

2 t=linspace(0,2*pi,50); % Initialisieren der Zeitachse
3 fmetro_ini=@(t) ([0.6*sin(t(1,:)); 10*cos(t(1,:))]);
4 solinit=bvpinit(t,fmetro_ini,Om); % mit Parameterübergabe
5 sol = bvploeser(@fmetro_dglS,@fmetro_res,solinit,options);
6 Om=sol.parameters; % Ergebnis von omega_s
Zeile 1-4 dienen der Initialisierung von: Om→ ωs , der Zeitachsendiskretisierung, Schätzung der
Lösungsfunktion und der Zusammenfassung in solinit einschließlich des unbekannten Para-
meters Om. Das Function Handle bvploeser in 5 steht für eine der Functions bvp4c, bvp5c. In
Zeile 6 wird die errechnete Frequenz zugewiesen. Die Functions zum Residuum und den JACOBI-
Matrizen ändern sich wegen des unbekannten Parameters gegenüber dem bisherigen, wir geben
sie deshalb hier an. In [52] ist die vollständige Function fmetro_bvp.m zu finden.
function res = fmetro_res(ya,yb,Om) % Residuen

res=[ya(1)-yb(1) % Bedingung für Randwerte
ya(2)-yb(2);
ya(1)]; % Bedingung zur Bestimmung von Om
end % Ende Nested Function fmetro_res
function [dfdy,dfdom] = fmetro_Jac(t,y,Om)

dfdy=[ 0, ..... ; % JACOBI-Matrix
1/Om, .....];
dfdom =-1/Om*fmetro_dgl(t,y,Om); % partielle Abl. nach Om
end % Ende Nested Function fmetro_Jac
function [dBCdya,dBCdyb,dBCdom] = fmetro_BCJac(ya,yb,Om)

dBCdya=[eye(2);1 0]; % JACOBI-M. der Residuen
dBCdyb=-eye(3,2);
dBCdom=zeros(3,1);%
end % Ende Nested Function fmetro_BcJac
Die Residuen entsprechen (5.161). Die JACOBI-Matrix ∂ f (yy)/∂yy wurde symbolisch mit der
Function jacobian aus der Symbolic Math Toolbox berechnet. Die JACOBI-Matrix der Residuen
entnimmt man unmittelbar aus metro_res als partielle Ableitungen nach y a .
Ergebnis und Schwingungsanalyse: Im Gegensatz zur Simulation des Anfangswertproblems,
bei dem nach einem Einschwingvorgang z. B. der Grenzzykel erreicht wurde, wird die periodi-
sche Lösung hier direkt ermittelt, die Stabilität ist offen. Die Lösung liegt nur zu diskreten Zeit-
punkten vor und ist somit wenig aussagekräftig. Eine Beurteilung, z. B. in Form der Grund- und
Oberschwingungen, ist so nicht möglich. Aus diesem Grund aber auch für die anstehende Stabi-
litätsuntersuchung ist es sinnvoll/erforderlich eine FFT (Fast F OURIER-Transformation) mit der
Function fft, wie in fmetro_bvp.m unter sanalysefft, durchzuführen.
5.7.4.2 Nichtautonome Schwingungssysteme

Wir legen (4.30) zur Bestimmung der erzwungenen Schwingungen zugrunde. D. h. es ist (5.162)
um den Term der Anregung aus (4.30) zu ergänzen, so dass
ẏy(t) = f (yy(t)) + q̃q(yy(t)) sin (Ωt + Φ) =: f (yy(t), t) (5.163)
mit
" #
0 1×3
q̃q(yy) = cos (y1 ) . (5.164)
−q L(M+m sin2 (y
1 ))
Es sind wegen der Anregung u. a. 2πs/Ω -periodische Lösungen zu erwarten, wobei Ω gegeben
ist. Für s = 2, 3, · · · spricht man von subharmonischen Schwingungen s-ter Ordnung. Wir wollen
nur Schwingungen mit der Kreisfrequenz Ω , d. h. s = 1, untersuchen. Neben der Grundharmo-
nischen treten in der Lösung Oberschwingungen mΩ , m = 2, 3, · · ·, auf. Für die numerische
Berechnung ist es wieder zweckmäßig, die dimensionslose Zeit τ = Ωt einzuführen, so dass
y (2π + τ) = y (τ) 2π periodisch. Aus (5.163) folgt
Ωyy (τ) = f (yy(τ), τ) . (5.165)
Das Problem enthält keine unbekannten Parameter, so dass die MATLAB-Umsetzung der aus
Abschn. 5.7.2 entspricht. Es lassen sich für (5.162) und (5.165) dennoch übergeordnete Aus-
drücke formulieren, so dass selbsterregte und erzwungene Schwingungen in fmetro_bvp.m
zusammengefasst werden können.
Ergebnis: Es sollen u. a. die Schwingungen in Abhängigkeit von diskreten Ω -Werten verfolgt
werden. Nach einer Startrechnung mit den Funktionswerten der erzwungenen Schwingungen des
linearisierten Systems (4.31) baut jeder folgende Schritt mit Ω := Ω + Δ Ω auf der vorangegan-
genen Lösung auf. Die so erhaltene Response-Kurve ist in Bild 5.46 dargestellt. Da die Erreger-
frequenz Ω in der Nachbarschaft der Selbsterregungsfrequenz ωs liegt, kommt es zu resonanzar-
tigen Überhöhungen, hier für die Maximalwerte von y1 = ϕ ausgewertet. Wie in Abschn. 4.6.1
gezeigt, treten Mitnahme-Effekte auf. Dies setzt stabile Schwingungen voraus. D. h. um diesen
Bereich abzugrenzen, muss eine Stabilitätsuntersuchung, wie im nächsten Abschnitt, folgen. Die
Ergebnisse sind bereits in Bild 5.46 eingearbeitet. Danach tritt für Ω > Ωk keine Mitnahme
mehr auf. Wie zusätzliche Rechnungen zeigten, enthalten die sich hier einstellenden Schwingun-
gen Frequenzanteile mit Ω und ωs , sie sind nicht mehr periodisch. Im unteren Frequenzbereich
Ω < 4 rad/s werden die Verhältnisse sehr komplex. Es treten Resonanzerscheinungen mit den
Oberschwingungen 2Ω , 3Ω ,... auf.
Bild 5.46: Response-Kurve, Maximalwert von y1 = ϕ in Abhängigkeit von Ω , Ωk = 15,945 rad/s

5.7.4.3 Stabilitätsuntersuchung
Soll die eine oder andere Lösung auf Stabilität untersucht werden, dann könnte man das Verhalten
der Lösung nach einer anfänglichen Störung der Lösung durch Verstimmung der Anfangswerte
per numerischer Integration klären. Liegt asymptotische Stabilität vor, dann nähert sich die ge-
störte Schwingung wieder der ursprünglichen an, im instabilen Fall entfernt sie sich von dieser.
Die Beurteilung des Verhaltens ist nicht immer eindeutig.
Sind Lösungen in Abhängigkeit von Parametern –wie oben– zu verfolgen, dann ist eine syste-
matische Stabilitätsuntersuchung aussagekräftiger. Wir können eine derartige numerische Vorge-
hensweise nur stichwortartig angeben. Die Vorgehensweise basiert auf dem Theorem von F LO -
QUET . Unter Stabilität oder asymptotischer Stabilität der periodischen Lösungen verstehen wir
das Verhalten der Lösung nach einer anfänglichen Störung (Stabilität im Sinne von L JAPUNOV).
Sei y 0 (τ + 2π) = y 0 (τ) die periodische Lösung von (5.165) bzw. (5.160), dann ergibt sich die
Differenzialgleichung der gestörten Bewegung v (τ) mit
y(τ) = y0 (τ) +vv(τ) (5.166)
aus einer TAYLOR-Entwicklung der rechten Seite bis zum linearen Term

∂ f (yy(τ), τ)
y 0 (τ) + v (τ) = f (yy0 (τ), τ) + v (τ). (5.167)
y (τ) y 0 (τ)
Da y 0 (τ) = f (yy0 (τ), τ) für sich erfüllt ist, bleibt die lineare Variationsgleichung

∂ f (yy(τ), τ) !
v (τ) = Q (τ) v (τ), = Q (τ) = Q (τ + 2π) . (5.168)
y (τ) y 0 (τ)
Strebt die Lösung v (τ) von (5.168) gegen Null für τ → ∞, so folgt für y 0 (τ) asymptotische
Stabilität. Nach L JAPUNOV erhalten wir diese Aussage und Aussagen über Instabilität bereits aus
der linearen Variationsgleichung (5.168) mit periodischer Koeffizientenmatrix, d. h. wir müssen
für (5.168) Stabilitätsbedingungen finden.
Die Variationsgleichung (5.168) hat n (hier n = 2) linear unabhängige Lösungen ṽvk (τ), die
die Fundamentalmatrix
V (τ) = (ṽv1 (τ), ṽv2 (τ), · · · , ṽvn (τ)) (5.169)
bilden. Sie genügt wegen der Periodizität von Q (τ) der Matrix-Differenzialgleichung
V (τ) = Q (τ)V
V (τ) → V (τ + 2π) = Q (τ)V
V (τ + 2π), (5.170)
d. h. V (τ + 2π) ist auch Lösung von (5.170)1 . Damit muss sich V (τ + 2π) als Linearkombination
der linear unabhängigen Lösungen ṽvk (τ) schreiben lassen
V (τ + 2π) = V (τ) K , (5.171)
K ist eine konstante reguläre Matrix. Die Lösungen ṽvk (τ) bestimmen wir uns numerisch aus
(5.170), bzw. spaltenweise aus (5.168), mit den speziellen Anfangsbedingungen
V (0) = E , E n×n Einheitsmatrix . (5.172)
Für die Matrix K gilt dann nach (5.171)
V (2π) = K . (5.173)
Nach dem F LOQUET-Theorem existieren Lösungen von (5.168), die der Bedingung
v (τ + 2π) = ρ v (τ) (5.174)
genügen, wo ρ der so genannte charakteristische Multiplikator ist. Die Lösung v(τ) lässt sich
durch V (τ), d. h. die linear unabhängigen ṽv(τ), ausdrücken:
v (τ) = V (τ) a , (5.175)
wo a ein zunächst unbekannter konstanter Vektor ist. Mit (5.174), (5.175) und (5.171) folgt dann:
V (τ) K a = ρ V (τ) a , (5.176)
woraus sich das Eigenwertproblem
(K
K − ρ E) a = 0 (5.177)
für die charakteristischen Multiplikatoren ergibt. K ist regulär und reell, folglich sind ρ und a
von Null verschieden und paarweise konjugiert komplex oder reell.
Die Stabilität von v (τ) aus (5.168) und damit von y 0 (τ) ergibt sich mit folgenden Aussagen:
|ρk | < 1 asymptotisch stabil

|ρk | > 1 instabil (5.178)
|ρk | = 1 kritisch.
Im kritischen Fall entscheiden die Terme höherer Ordnung von (5.167), ob Stabilität oder Insta-
bilität vorliegt.
Die F LOQUET-Lösung (5.175) lässt sich ausdrücken durch eine periodische Funktion
f (τ + 2π) = f (τ) ausdrücken
v (τ) = V (τ)aa = eλ τ f (τ), = 1, 2, ..., n (5.179)
Die λ = δ + iω sind die charakteristischen Exponenten. Es gilt der Zusammenhang

1
ρ = e2πλ oder λ = ln ρ , (5.180)
2π
wo ln ρ = ln |ρ | + i arg ρ + 2πmi = δ + iω und das Argument von ρ gemäß −π ≤ arg ρ <
π normiert sei. Der charakteristische Exponent ist also eine analytische unendlich vieldeutige
Funktion mit dem Hauptwert für m = 0. Die Stabilität des Systems ist somit auch durch die
Realteile der charakteristischen Exponenten bestimmt.
Vorgehensweise: Zur Stabilitätsuntersuchung der Lösung y0 (τ) des nichtlinearen Differenzial-
gleichungssystems ist die Bestimmung der Fundamentalmatrix V (τ) zu den speziellen Anfangs-
bedingungen V (0) = E und der Eigenwerte von K := V (2π), der charakteristischen Multiplika-
toren ρ, erforderlich. Hierzu muss die Variationsgleichung (5.168) entsprechend der Ordnung
(hier zwei) zu wechselnden Anfangswerten, jeweils dem -ten Einheitsvektor (=1, 2,..), nume-
risch integriert werden. Dies setzt voraus, dass die Lösung des nichtlinearen Systems, die nur zu
diskreten Zeitpunkten vorliegt, in ein F OURIER-Polynom mit der Function fft entwickelt wird.
Die zugehörigen Funktionswerte zu den diskreten Zeitpunkten des Integrators ergeben sich dann
aus einer F OURIER-Synthese. Mit dem folgenden Programmausschnitt wird K := V (2π) erstellt.
ka=2; % Ordnung des Zustandsmodells
kz1=0; % Zählvariable
while kz1 < ka % Aufbau der Fundamentalmatrix
kz1=kz1+1;
optstab=odeset(’Reltol’,1.e-8); % Optionen für Integration
[~,z]=ode45(@fmetro_stab,[0 2*pi],z0(:,kz1),optstab,c,N);
K(:,kz1)=z(end,:)’; % Spalten der Fundamentalmatrix
clear z
end
rho=eig(K); % charakteristische Multiplikatoren
Ergebnisse: In Bild 5.47 sind die mit der Response-Kurve aus Bild 5.46 korrespondierenden
charakteristischen Multiplikatoren ρ1 , ρ2 in einer komplexen Ebene eingetragen, Ω ist Kurven-
parameter. Bei Ω = Ωk sind |ρ1 | = |ρ2 | = 1, es liegt eine Stabilitätsgrenze vor. Für Ω > Ωk ist
die Lösung instabil.
Eine Besonderheit zeigt die Stabilitätsuntersuchung der selbsterregten Schwingungen. Auf-
grund der willkürlich vorgegebenen Komponente yk (τ0 ) in (5.161), d. h. der Phase der Schwin-
gung gegenüber τ0 , ist ein Multiplikator immer eins. Die restlichen bestimmen die Stabilität. Mit
der Ausgabe von fmetro_bvp.m lassen sich alle Einzelheiten nachvollziehen.
Bild 5.47: Charakteristische Multiplikatoren in Abhängigkeit von Ω , Ωk = 15,945 rad/s

6 Modellierung und Simulation mit dem Stateflow Tool
Wie insbesondere in den letzten Abschnitten gezeigt, sind bei der Modellierung dynamischer Sys-
teme zunehmend ereignisgesteuerte Simulationen durchzuführen. Z. B. können abschnittsweise
geltende Differenzialgleichungen durch eine Steuerlogik aktiviert bzw. deaktiviert werden. Man
spricht auch von reaktiven Systemen. Das Stateflow Tool unterstützt anschaulich u. a. die Mo-
dellierung und Animation der Steuerlogik derartiger Systeme in der Simulink-Umgebung. Es ist
somit für die Modellierung eventgetriebener Systeme ein interessantes Werkzeug. Insbesonde-
re wird anhand der Dreipunkt-Schaltlogik aus Abschn. 5.6.5 zur Modellierung des C OULOMB-
Elementes in Verbindung mit dem 1/4-Fahrzeug aus Abschn. 4.4 die unmittelbare Umsetzung
derartiger Logiken in der Simulink-Umgebung verdeutlicht. Weitere Stateflow-Elemente disku-
tieren wir anhand des Ballwurfes aus Abschn. 5.6.4.1.
Wir können hier nur Anregungen zur Modellierung mit dem Stateflow Tool vermitteln. Hier-
für geben wir zunächst einen kurzen Einblick bezüglich der Arbeitsweise von Stateflow (Versi-
on 6.1,..,6.5) und erläutern einige für unsere Betrachtung wesentliche Elemente. Weiterführende
Grundlagen sind u. a. in [1], [2] zu finden. Ergänzende Information enthalten die Demo-Beispiele
zum Tool. Diese erreicht man über den Library Browser und das Symbol der Sublibrary Stateflow:
Nach Mausklick mit der rechten Taste wird der Button Open the Stateflow library sicht-
bar; Klick mit linker Taste öffnet das Fenster sflib mit dem Examples-Block (oder kurz: >> sf)
eingeben. Letztendlich enthält die Online-Hilfe im Help Browser u. a. mit dem Stateflow User’s
Guide – öffnet mit >> sfhelp – detaillierte und stets aktuelle Informationen und Anleitungen.
Insbesondere unter Stateflow Examples (Help Navigator) sind alle Elemente beispielorientiert
erklärt.
6.1 Stateflow-Elemente
Das Stateflow Tool ist ein Entwurfs- und Entwicklungswerkzeug für die Simulink-Umgebung.
Es lassen sich in einem Stateflow Chart Block aus der Stateflow Library, grafische Stateflow-
Diagramme für logische und ereignisgetriebene Abläufe, so genannte endliche Zustandsautoma-
ten (finite state machines) erstellen. Das komplette Stateflow-Modell wird auch State Machine
genannt. Das Stateflow Chart stellt ein C-Code S-Function (Mex-File, fnc_name_sfun.mexw32,
für 32-Bit-Version) dar. Die Function wird mit dem Simulationsstart automatisch generiert und
Informationen im Unterverzeichnis slprj abgelegt. Zur Erzeugung der C-Code S-Function ist
ein C-Compiler erforderlich. Mit
>> mex -setup
kann unter Windows (32 Bit) der mitgelieferte Compiler Lcc-win32 aktiviert werden (einma-
liger Vorgang, vgl. Abschn. 4.7). Optional und für die 64 Bit-Version von Windows sind andere
Compiler auswählbar.
Für den Modelltest stehen ein Parser (Überprüfung der Semantik), ein Debugger (gezielte
Fehlersuche durch schrittweise Ausführung des Charts) zur Verfügung.
Während der Simulation werden die jeweils aktiven Übergänge und Zustände im geöffneten

DOI 10.1007/978-3-8348-8630-9_6,
318 6 Modellierung und Simulation mit dem Stateflow Tool
Stateflow-Diagramm animiert dargestellt. Es lassen sich Diagramme mit und ohne Zustände,
d. h. Zustandsdiagramme und Flussdiagramme (stateless) –vgl. ExpStatefl_3.mdl in [52]–,
grafisch im Chart erstellen. Dabei unterscheidet man grafische und nichtgrafische Elemente. Zu
den nichtgrafischen Elementen eines Charts zählen Events, Daten unterschiedlichen Typs sowie
Ein- und Ausgänge zu Simulink. Sie können im Model Workspace des zugehörigen Modells oder
im MATLAB Base Workspace gespeichert und über den Model Explorer verwaltet werden. Ein
Simulink-Modell kann mehrere Charts enthalten.
Stateflow besitzt einen objektorientierten Aufbau, d. h. jedes Objekt (Element) besitzt ein ein-
deutiges Eltern-Objekt (parent) mit beliebig vielen Kind-Objekten (children).
Eltern-Objekt → Stateflow Chart
Kinder des Charts → Im Chart enthaltende Elemente:
Zustände, Events, Variablen, Funktionen.
In den folgenden Abschnitten werden wir einige grundlegende grafische und nichtgrafische
Elemente erläutern, siehe im Help Browser: Stateflow, Stateflow Notation sowie Examples.
6.1.1 Das Chart
Ein leeres Chart erhält man einerseits innerhalb eines neuen Simulink-Modells durch die Eingabe:
>> sfnew , andererseits aus der Stateflow Library, die auch durch den Aufruf
>> stateflow oder kurz: >> sf
geöffnet wird. In diesem Fall ist das Chart in das Simulink-Modell zu ziehen (click-and-drag).
Mit einem Doppelklick auf das Chart öffnet sich der grafische Editor, wie in Bild 6.1, mit der ver-
tikalen Tool-Leiste der grafischen Elemente. Sie können in das Diagramm-Editor-Fenster gezo-
Bild 6.1: Stateflow-Diagramm-Editor mit Erklärung der Tool-Leiste und Shortcut Menü zur Arbeitsweise
gen werden. Ein Chart enthält danach die grafischen Elemente: State (Zustand), History Junction
(Gedächtnis für zuletzt aktiven Zustand), Default Transition (Standardverbindungen), Connecti-
ve Junction (Verzweigungspunkte) usw. Die Box ist im Wesentlichen ein grafisches Hilfsmittel
6.1 Stateflow-Elemente 319
zur visuellen Organisation in einem Chart. Bei mehreren Boxen wird die Ausführungsreihenfol-
ge geregelt. MATLAB Function und Graphical Function werden in ExpStateflow_2.mdl
aus [52] erklärt. Truth Table gestattet die Erstellung logischer Wahrheitstabellen mit dem Truth
Table Editor. Die Übergangspfade, die Transitionen, zwischen Zuständen untereinander und mit
Verzweigungspunkten (Connective Junction), wie in Bild 6.2, werden mit dem Mauszeiger er-
zeugt. Für alle Bedingungen der Zustand-Übergänge an den Transitionen sowie die der Zustand-
Aktionen, vgl. Bild 6.3, werden Label, deren Elemente in der Action Language (vgl. Stateflow
User’s Guide) spezifiziert sind, gesetzt.
Bild 6.2: Grundelemente eines Charts
6.1.2 Zustand und Zustand-Label
Grundsätzlich werden zwei Zustandsformen unterschieden:

Exklusiv-Zustände: zu einem Zeitpunkt kann nur ein Zustand aktiv sein,
(Oder-Zustände) grafisch: durchgezogene Rechtecke, vgl. Bild 6.2, Bild 6.4
Parallel-Zustände: es können mehrere Zustände gleichzeitig aktiv sein,

(Und-Zustände) grafisch: parallel angeordnete gestrichelte Rechtecke;
die Ausführungsreihenfolge wird durch Nummern angezeigt,
vgl. Bild 6.4 und Demo fuelsys.
Die Typ-Zuweisung erfolgt mit dem Shortcut Menü über den Menü-Punkt: Decomposition, wie
in Bild 6.1 gezeigt.
Der aus dem State Tool in den grafischen Editor gezogene Zustand (State) enthält zunächst in
der oberen linken Ecke eine Eingabeaufforderung oder den Label ” ? ”. Er ist unmittelbar oder
nach Klick der linken Maustaste auf ” ? ” durch den Zustand-Label, wie in Bild 6.3, vollständig
oder teilweise zu ersetzen, siehe auch Help Browser: State Action Types. Der Label beginnt zwin-
gend mit einem gewählten Zustand-Namen (erlaubt: Buchstaben, Unterstriche). Der Name ist, so-
fern kein Return folgt, mit einem Slash abzuschließen. Kommentare sind zulässig, sie beginnen
wie üblich in MATLAB mit % oder wie in C /*...*/ bzw. C++ //.... Nach dem Zustand-Namen kön-
nen optionale Zustand-Aktionen folgen, die sich aus dem Schlüsselwort entry (Kurzform: en),
during (du), exit (ex), bind und on event, für den Typ der Aktion mit einem abschließen-
den Doppelpunkt sowie der eigentlichen Aktionsanweisung, wie in Bild 6.3, zusammensetzen. Es
können Wertzuweisungen, logische Operationen und Events-Aktivierungen ausgeführt werden.
Die Syntax ist der der Programmiersprache C ähnlich. Für jeden Typ können mehrere Aktions-
anweisungen, getrennt durch Komma, Semikolon oder Return (vgl. MATLAB-Vereinbarungen)
aufgeführt sein. Jede Zustand-Aktion beginnt mit einer neuen Zeile. Sind nur Aktionen vom Typ
entry auszuführen, so können sie unmittelbar hinter dem Slash oder in einer neuen Zeile nach
dem Zustand-Namen ohne Schlüsselwortangabe aufgelistet werden. Ein Zustand wird aktiv bzw.
inaktiv, wenn eine zuführende bzw. wegführende Transition gültig ist.
Bild 6.3: Zustand (State) mit vollständigem Label
Die Schlüsselworte im Zustand-Label, wie in Bild 6.3, wollen wir kurz erläutern:
• Entry Action: Die Entry Action wird nach der Aktivierung des Zustandes, also beim Eintritt
in den Zustand, ausgeführt.
• During Action: Eine During Action wird während der aktiven Phase des Zustandes ausge-
führt. Die Häufigkeit der Ausführung der During Action ist von der Einstellung der Update-
Methode des Charts abhängig.
• Exit Action: Eine Exit Action wird beim Verlassen infolge einer wegführenden, gültigen
Transition oder des Eintretens eines Ereignisses (event, siehe On-Event Action) ausgeführt.
• On-Event Action: Eine On-Event Action wird in der aktiven Phase des Zustandes ausgeführt,
wenn das angegebene Event auftritt. Mehrere Events sind zulässig:
on event1, event2, event3:aktion123
• Bind Action: Eine Bind Action, z. B. bind: wert, des zugehörigen Zustands oder eines
diesbezüglichen Kind-Objekts lässt die Änderung des Wertes/Events wert nur innerhalb
des Zustands zu. Andere Zustände können auf wert in ihren Aktionen zugreifen, ihren
Wert aber nicht ändern.
6.1.3 Transitionen
Eine Transition ist ein verformbarer Pfeil, der ausgehend vom Quell- zum Zielobjekt zwei Gra-
fikobjekte verbindet (unidirektionaler Signalfluss). Wie u. a. in Bild 6.2, Bild 6.4, Bild 6.8 gezeigt,
können Transitionen zwischen zwei Zuständen und zwischen Verbindungspunkten (Connective
Junction) und Zuständen verlaufen. Mit Hilfe der linken Maustaste wird ausgehend von einer
geraden Kante des Quellobjekts durch Ziehen an eine gerade Kante des Zielobjekts, die Verbin-
dung erzeugt. Die Transitionen können Label enthalten, deren Bedingungen für eine Aktivierung
gültig sein müssen. Sie werden bei aktivem Quellobjekt auf ihre Gültigkeit überprüft. Es kann
in der Regel immer nur eine wegführende Transition aktiv sein. Verbindungspunkte (Junctions)
unterteilen eine vollständige Transition zwischen Quell- und Zielobjekt. Jeder Teil der Transition
muss gültig sein, um das Zielobjekt zu aktivieren.
Der Transitions-Label setzt sich aus einem Event, einer Bedingung (Condition), einer Bedin-
gungsaktion (Condition Action) und einer Übergangsaktion (Transition Action) zusammen. Je-
des dieser Elemente ist optional. Ein Label kann auch leer sein. Die allgemeine Form eines Labels
ist:
event[condition]{condition_action}/transition_action
Die ersten drei Elemente des Labels werden nacheinander abgearbeitet. Sind alle Bedingungen
true, dann ist die Transition gültig. Nicht gesetzte Bedingungen sind true. Ist die Transition
gültig, dann wird die Transitionsbedingung (Transition Action), die mit einem Slash / beginnt,
ausgeführt. Die Bedingung (Condition) ist ein boolscher Ausdruck.
6.1.3.1 Aktivierungsregeln
Existieren zwei oder mehrere wegführende Transitionen eines Quellobjekts – Zustand (State)
oder Verbindungspunkt (Connective Junction) – dann erscheinen ab Version 6.3 im Stateflow-
Diagramm numerierte Transitionen 1, 2,... entsprechend ihrer Überprüfungsreihenfolge auf Gül-
tigkeit bzw. Ausführung. Diese Reihenfolge ergibt sich aus festgeschriebenen Regeln und wird
als implizite Methode bezeichnet. Demgegenüber steht ab Version 6.3 die vom Benutzer festge-
legte oder explizite Ausführung. In diesem Mode setzt der Benutzer die Folge, in der die Tran-
sitionen für die Ausführung überprüft werden, teilweise oder vollständig fest. Dieser Mode ist
im Modell-Explorer bei aktiviertem Chart in der Model Hierarchy Spalte, vgl. Bild 6.9, durch
Anwahl von
User specified state/transition execution order
in der Dialog-Spalte, Chart:chart_name, zu aktivieren. Der explizite Mode bezieht sich auf
Parallel-Anordnungen von Zuständen, wie in Bild 6.4, als auch auf die Prioritäten der Transi-
tionen. Die Änderung der Folge erfolgt anschließend im Shortcut-Menü unter Execution Order,
geöffnet durch Rechtsmausklick auf die Transition. Die Reihenfolge der restlichen Transitionen
wird automatisch angepasst.
Die implizite Methode ist der Standard-Mode für alle Stateflow-Versionen. Modelle von Vor-
gängerversionen werden in diesen Mode konvertiert. Aus diesem Grund folgen noch einige Be-
merkungen zur impliziten Festlegung der Priorität.
Grundsätzlich liegen für mehrfach wegführende Transitionen von einem Quellobjekt (Zu-
stand, Verbindungspunkt) drei Vorgehensweisen zugrunde. Sie sind im Bild 6.4 in einer Parallel-
Anordnung von Superstates AA, AB, AC demonstriert. Diesbezügliche Experimente können mit
Prioritaet.mdl aus [52] durchgeführt werden. Vorgehensweisen:
1. Endpunkt Hierarchie (Endpoint Hierarchy): Transitionen, dessen Endpunkte zu einer hö-

heren Hierarchie-Ebene führen, werden zunächst überprüft und diejenige, die die Aktivie-
rungsbedingung erfüllt, siehe Bild 6.41 , ausgeführt.
2. Label: Transitionen mit Endpunkten auf gleicher Hierarchie-Ebene werden bezüglich ihres
Label-Eintrags überprüft und ggf. aktiviert, siehe Bild 6.42 :
• Label mit Events und Bedingungen (conditions)

• Label mit Event
• Label mit Bedingungen
• kein Label, leere Transition.
3. Winkellage der wegführenden Transition: Gleichwertige Transitionen bezüglich der Label
und der Hierarchie-Ebene der Endpunkte, siehe Bild 6.43 , werden nach der Winkellage am
Quellobjekt überprüft und aktiviert.
Beispiel: Eine Transition mit einer 2-Uhr-Lage hat eine höhere Priorität als eine mit einer
4-Uhr-Lage. Eine Transition in 12-Uhr-Lage hat die kleinste Priorität.
Es werden zunächst alle gültigen Transitionen im animierten Chart angezeigt, sofern im
Debugger-Fenster (Grafik-Editor: Tools/Debug) Transition Conflict aktiv ist. Ein sol-
cher Konflikt sollte vermieden werden.
Bild 6.4: Beispiele zu Aktivierungsbedingungen von Transitionen in Parallel-Zuständen
6.1.4 Default Transition

Die Default Transition oder Standardtransition hat, wie in Bild 6.2, Bild 6.41,2 und 6.8, kein
Quellobjekt. Sie endet an einem Zustand oder Verbindungspunkt, siehe u. a. Bild 6.8. Existieren
in einer Hierarchieebene mehrere inaktive exklusiv (OR) Zustände, dann wird der Zustand, an
dem die Default Transition hängt, zuerst aktiviert. Es können aber auch in einer Hierarchieebene
mehrere Standardtransitionen eingesetzt werden. In diesem Fall müssen Ereignisse/Bedingungen
sicherstellen, dass stets eine Transition gültig ist.
6.1.5 Verbindungspunkte
Die kreisförmigen Verbindungspunkte (Connective Junctions), u. a. in Bild 6.43 , sind Elemen-
te des Connective Junction Tools, vgl. Bild 6.2. Sie können Verzweigungspunkte, von denen
dann mehrere Transitionen wegführen, bilden. Unterschiedlichste Konstruktionen bezüglich hin-
und wegführender Transitionen sind möglich; vgl. Stateflow User’s Guide sowie Demo-Beispiel
sf_boiler u. a. mit function turn_boiler(mode). Darüber hinaus sind damit for-
Schleifen, do-while-Schleifen und if-then Abfragen, zustandsfreie Flussdiagramme usw.
realisierbar, verfolge: Help Navigator/ search/ Connective Junction und aus der Programmsamm-
lung [52] ExpStateflow_1,2,3.mdl.
6.1.6 Der Modell-Explorer
Aufbauend auf Abschn. 4.3.5.7 setzen wir die Betrachtung zum Modell-Explorer im Zusammen-
hang mit dem Stateflow Tool fort. Alle Events, Variablen, Eingänge und Ausgänge (interne, ex-
terne Variablen) von und zu Simulink müssen deklariert werden. Dies geschieht mit dem Model
Explorer nach Bild 6.9. Er wird u. a. mit dem Button aus der Menü-Leiste des Grafik-Editors,
Bild 6.2, oder Simulink-Modell-Fensters geöffnete. Auf der linken Seite des Explorers wird u. a.
die Modell-Hierarchie Chart/Zustände (Einrückungen kennzeichnen Eltern-Kind-Beziehung) an-
gegeben. Es sind alle momentan geöffneten Charts/Zustände enthalten. Die deklarierten Größen
und ihre Eigenschaften können im (Base) Workspace, sie sind global verfügbar, oder im Model
Workspace, die Daten werden nur von dem zugehörigen Modell gesehen, verwaltet.
Im anschließenden Teil (Contents Spalte) werden alle nicht-grafischen Elemente mit ihren
Eigenschaften in Abhängigkeit von der Einstellung unter Column View:, z. B. Default/Data Ob-
ject/.../Stateflow, angezeigt.
Auf der rechten Seite, Dialog Spalte, des Modell-Explorers kann die den Elementen zuge-
ordnete Dialogbox der Eigenschaften mit dem Button: in der Explorer-Menüleiste – sie sind
auch separat zu öffnen – ein- und ausgeblendet werden. Es können dort in Abhängigkeit von
den mit einem Mausklick aktivierten Elemente/Objekte der ersten beiden Fenster zugehörige
Eigenschaften angezeigt und eingestellt werden. Z. B. bei aktiviertem Chart-Symbol kann insbe-
sondere die Update method für die Aktivierung nach jedem Abtastschritt (Discrete, Continuous)
des Simulink-Modells, beim Auftreten eines externen Triggersignals oder bei jeder Neuberech-
nung der Eingangssignale (inherented) ausgewählt werden. Inherited ist die Standardmethode,
die Abtastrate des Charts wird von den Simulink-Eingängen vererbt. Wird ein Zustand im Explo-
rer aktiviert, dann erscheint das Zustand-Label, welches editiert werden kann. Dies erreicht man
ebenfalls über das Shortcut Menü unter Properties des ausgewählten Zustands. Bezüglich der
Variablen, Events usw. werden Namen, Scope, Datentyp usw. einstellbar. Eigenschaften bereits
eingetragener Variablen/Events werden nach deren Aktivierung im mittleren Fenster angezeigt.
Nach einem Klick auf: Model Workspace in der Spalte Modell-Hierarchie kann der Daten-
transfer in den Model Workspace über ein MDL-, MAT-, MATLAB-File oder durch Eingabe
eines MATLAB Codes in der Dialog-Spalte erfolgen, siehe Fahrz.mdl.
Weitere Deklarationen können u. a. über die Menüpunkte Add/Data – Ctrl+D –, Add/Event –
Ctrl+E – oder die Knöpfe: des Explores hinzugefügt werden. Diese Daten sind mit einem
Namen, dem Datentyp double, single, int32, boolean usw. zu versehen. Für die Variablenspezi-
fikation ist das Scope, z. B. auf lokal, Input, Output, ... zu setzen, d. h. zur Vereinbarung eines
Eingangssignals einer Variablen von Simulink auf Input. Dadurch wird am Chart ein Eingangs-
port angezeigt. Zusätzlich sind Datentyp und evtl. Portnummer zuzuweisen. Ausgangsvariable
nach Simulink erhalten die Spezifikation: Output, der Ausgangsport wird angezeigt. Der Daten-
typ constant wird durch Einstellung des Scopes auf Constant deklariert. Eine Konstante kann
nicht modifiziert werden. Im Feld Limit Range kann der zulässige Wertebereich der Variablen
festgelegt werden; er ist einzuhalten. Matrizen-Deklarationen erfolgen durch den Eintrag im Feld
Size, z. B. 5 für eine 5×1-Matrix und [5 4] für eine 5×4-Matrix, siehe ExpStateflow_2.mdl
[52].
Deklarierte Events (Add/Event, Ctrl+E) erhalten ebenfalls einen Namen, sie können als lokale
Events oder als Input/Output-Events from/to Simulink vereinbart werden. Darüber hinaus sind
Triggerart (Rising, Falling,...) und ggf. Port-Nummer sowie Debugger-Funktionen auszuwählen.
Sind Aktivitäten von Zuständen (States) an Simulink zu übergeben, dann ist dazu auf der
linken Seite, Model Hierarchy Spalte, im Explorer der Zustand auszuwählen und auf der rechten
Seite, Dialog Spalte, die Eigenschaft Output State Activity zu aktivieren. Es wird ein weiterer
Port am Chart angezeigt, siehe Bild 6.15.
6.1.7 Erweiterte Strukturen

Neben der Modellierung in einer Hierarchieebene des Charts erlaubt Stateflow unterschiedliche
Arten der Gruppierung und Hierarchiebildung. Zum einen dienen sie einer besseren Übersicht-
lichkeit, zum anderen lassen sie aber auch Konstruktionen mit erweiterten Funktionalitäten eines
Charts zu, siehe [2] sowie Bild 6.4. Mit einem Superstate lassen sich zusammengehörige Zu-
stände (Substates) zu einem übergeordneten Zustand zusammenfassen, wie in Bild 6.4 und in
Bild 6.16 zu Demo-Zwecken eingebracht. Ein Superstate ist demnach das Eltern-Objekt für wei-
tere Zustände, vgl. Bild 6.8. Er ist genau dann aktiv, wenn mindestens eines seiner Kind-Objekte
aktiviert wird oder er selbst das Ziel einer Transition ist; d. h. ein Superstate kann nie für sich
alleine aktiv sein. Die Funktionsweise der Superstates hängt davon ab, ob sie in Exklusiv-Oder
oder Parallel-Anordnung, vgl. Bild 6.4, verwendet werden. Weitere Einbettungen von Charts und
Zuständen sind möglich, so dass sich beliebige Schachtelungen erzeugen lassen.
6.2 Beispiel: Schwinger mit Coulomb-Reibung

Anhand des 1/4-Fahrzeuges aus Abschn. 4.4, Bild 4.16 sowie der Dreipunkt-Schaltlogik aus
Abschn. 5.6.5, Bild 5.37, wollen wir nun ein Simulink-Modell, in dem die Schaltlogik mit Stateflow-
Elementen realisiert wird, aufbauen. Damit wird es möglich, alle Bewegungsphasen des Modells
korrekt nachzubilden.
6.2.1 Bewegungsgleichungen und Schaltbedingungen

Wir übernehmen die Bewegungsgleichungen (4.5) der Gleitphasen in der Form
FC
ẍA = −ω12 (xA − xR ) − δ1 (ẋA − ẋR ) − s, s = sign (ẋA − ẋR )
mA
(6.1)
FC kR
ẍR = ω22 (xA − xR ) + δ2 (ẋA − ẋR ) + s+ (xs − xR ),
mR mR
wobei
kA kA dA dA
ω12 = , ω22 = , δ1 = , δ2 = .
mA mR mA mR
Die Variablen und Parameter sind in Abschn. 4.4 erklärt. Haftung tritt auf, wenn die Beschleuni-
gungen beider Massen (mA , mR ) gleich sind, d. h. ẍA = ẍR . Damit folgt aus (6.1)
kR
ẍA = (xs − xR ) . (6.2)
mA + mR
Der zugehörige Schaltkoeffizient ist per Definition s = 0.
6.2 Beispiel: Schwinger mit Coulomb-Reibung 325
Die Gleichungen (6.1) und (6.2) beschreiben somit die Bewegungsphasen Gleiten und Haf-
ten. Über die Dreipunkt-Schaltlogik muss entschieden werden, welche der Bewegungsformen zu
aktivieren ist. Zu diesem Zweck führen wir die Schaltfunktion q, sie entspricht der Relativge-
schwindigkeit von Aufbau und Rad, und den Schaltkoeffizient s
q =ẋA − ẋR

sign q, Gleiten: s ± 1 (6.3)
s=
0, Haften
ein. Die Hilfs-Schaltfunktionen S± folgen nach (5.129) aus q̇ = ẍA − ẍR zu

1 1 kR
S± = −(ω12 + ω22 )(xA − xR ) − (δ1 + δ2 )(ẋA − ẋR ) ∓ FC + − (xs − xR ). (6.4)
mA mR mR
Mit (6.3) und (6.4) kann die Dreipunkt-Schaltlogik nach Bild 5.37 aufgebaut werden.
6.2.2 Simulink-Modell mit Chart

6.2.2.1 Datenfile
Die für die Simulation benötigten Parameter sowie die Initialisierung der Anfangswerte und An-
fangszustände fassen wir im unten abgedruckten Daten-Modul dFahrz.m aus [52] zusammen.
Der Ausführungsvorgang erfolgt durch Eintrag des Filenamens dFahrz unter Menü:
File/Model properties, Callbacks, InitFcn oder über den Model Explorer.
Daten-Modul: dFahrz.m aus [52]

fprintf(’Lade Daten für Rampenauffahrt’)
% ---- Systemparameter
mA=1.0e+03; % Aufbauten-Masse [kg]
mR=1.0e+02; % Rad-Masse [kg]
kA=40.0e+03; % Federsteifigkeit der Radaufhängung [N/m]
kR=40.0e+04; % Reifensteifigkeit [N/m]
dA=12.0e+03; % Dämpfung der Radaufhängung [Ns/m]
FC=400.0; % Reibkraft [N]
d=0.01; % Rampenhöhe [m]
om1=kA/mA; om2=kA/mR; delta1=dA/mA; delta2=dA/mR; % Abkürzungen
xA0=0.0; xR0=0.0; xAp0=0.0; xRp0=0.0; % Anfangswerte

% % Initialisierung der Schalt-Logik
q=xAp0-xRp0; % Schaltfunktion (Relativgeschwindigkeit)
y=[xA0 xR0 xAp0 xRp0];
if q == 0 % Schaltfunktion (Relativgeschwindigkeit)
xs=0.0; % Fahrbahnanfangszustand
% ---- Initialisierung der Hilfs-Schaltfunktionen S+, S-;
sp=-(om1+om2)*(y(1)-y(2))-(delta1+delta2)*(y(3)-y(4))...
-FC*(1/mA+1/mR)-1/mR*(kR*(xs-y(2)));
sm=-(om1+om2)*(y(1)-y(2))-(delta1+delta2)*(y(3)-y(4))...
+FC*(1/mA+1/mR)-1/mR*(kR*(xs-y(2)));
% ---- Initialisierung des Schaltkoeffizienten s0
if sm < 0 s0=-1; % vgl. Dreipunkt-Schaltlogik
elseif sp > 0 s0=1; % Gleiten, positive Relativgeschw.
else s0=0; % Haften
end
else
if q < 0 s0=-1; % Gleiten, negative Relativgeschw.
else
s0 =1; % Gleiten, positive Relativgeschw.
end
end
disp(’ ’); disp(’ok.’); disp(’ ’)
6.2.2.2 Simulink-Subsystem des Fahrzeugs
Das 1/4-Fahrzeug modellieren wir mit (6.1), (6.2) als Subsystem Fahrzeug, wie in Bild 6.5.
Hierzu wählen wir:
Eingänge: s Schaltkoeffizient s aus der Zustands-Logik
xs Fahrbahnprofil mit Rampenauffahrt
Ausgänge: xA Fahrzeugaufbau-Auslenkung xA
xR Rad-Koordinate xR
xAp Geschwindigkeit ẋA
xRp Geschwindigkeit ẋR
xAp_state ẋA , State Port-Ausgang
xRp_state ẋR , State Port-Ausgang
Bild 6.5: Subsystem des 1/4-Fahrzeuges

Da ein strukturvariables System vorliegt, muss in Abhängigkeit vom Schaltkoeffizienten s

(s = 0, s = ±1) nach (6.3) zwischen den Bewegungsgleichungen (6.1) und (6.2) hin und her ge-
schaltet und gleichzeitig bei jedem Wechsel die Integratoren mit den Beschleunigungseingängen
neu gestartet werden. Hierzu setzen wir einerseits einen Switch Block mit dem Kontrolleingang
|s| und dem Schwellwert von < 1 (z. B. 0,5) ein. Dies garantiert einen Schaltvorgang bei einem
Wechsel |s| = 1 → s = 0, so dass zwischen Gleiten und Haften bezüglich der Bewegungsglei-
chungen unterschieden werden kann, wenn wir den Schalterausgang auf die Trigger-Eingänge
der Integrierer (fallende Flanke) legen. Die zu setzenden Anfangswerte (Geschwindigkeiten)
werden auf die extern geschalteten Integrierer-Eingänge der Anfangswerte gelegt. Hierzu wer-
den IC-Blöcke verwendet, die bei Simulationsstart die vorgegebenen Anfangswerte und später
die Endwerte des Integrationsintervalls über die State Ports der Integrierer durchschalten. Dies
ist zulässig, weil die Geschwindigkeitsverläufe zwar Knicke aber keine Sprünge aufweisen. Um
algebraische Schleifen zu vermeiden, benutzen wir die State Port-Ausgänge auch zur Nullstell-
bestimmung der Schaltfunktion (6.3) außerhalb des Subsystems.
Der weitere Subsystemaufbau in Bild 6.5 ist aus vorangegangenen Beispielen bekannt und
somit nachvollziehbar.
6.2.2.3 Das übergeordnete Simulink-Modell

Das Simulink-Modell Fahrz.mdl in [52] enthält neben dem aus Abschn. 4.4 bekannten ebe-
nen Fahrbahnprofil (xs ) insbesondere die Formulierung der Schalt- und Hilfs-Schaltfunktionen
(q, S± ), deren Nullstellenermittlung sowie das Chart (State Machine) mit der Dreipunkt-Schalt-
logik nach Abschn. 5.6.5, Bild 5.37.
Bild 6.6: Gesamtmodell des 1/4-Fahrzeuges
Die Schaltfunktion q nach (6.3) ergibt sich unmittelbar mit den Ausgängen der State Ports der
Integrierer im Subsystem des Fahrzeuges. Die Hilfsschaltfunktionen S± nach (6.4) realisieren

wir mit Hilfe zweier Function-Blöcke, vgl. Bild 6.7. Der zugehörige Eingangsvektor u setzt sich
aus vier Ausgängen des Subsystems Fahrzeug und des Fahrbahnprofils xs zusammen. Dazu
werden statt der Geschwindigkeiten ẋA , ẋR (xAp, xRp) die Werte der State Port-Ausgänge ver-
wendet. Dies vermeidet algebraischen Schleifen. Damit können wir die Hilfs-Schaltfunktionen
anschreiben:
Bild 6.7: Function-Blöcke der Hilfsschaltfunktionen S±
Auftretende Nullstellen der Schalt- und der Hilfs-Schaltfunktionen (q, S± ) werden mit den
Hit Crossing Blöcken durch 0 (keine Nullstelle) oder 1 (Nullstelle), wie in Bild 6.13 dargestellt,
angezeigt.
Zum Aufbau der Schaltlogik müssen die Hilfs-Schaltfunktionen Sp:=S+ , Sm:=S− sowie die
boolschen Werte (0 oder 1) für eine vorliegende Nullstelle von q, Sp_I und Sm_I am Eingang
des Charts Zustands-Log anliegen.
6.2.2.4 Das Stateflow-Diagramm und Testmöglichkeiten
Bild 6.8: Stateflow-Logik der Dreipunkt-Schaltlogik nach Bild 5.37

Die bekannte Dreipunkt-Schaltlogik nach Bild 5.37 können wir, aufbauend auf den Eingangs-
größen q, Sp, Sm, Sp_I, Sm_I, direkt umsetzen. Die deklarierten Daten werden im Explorer
von Bild 6.9 angezeigt. Ausgehend von den im Daten-Modul dFahrz.m formulierten Anfangs-
bedingungen sowie des hieraus resultierenden Schaltkoeffizienten s0 wird bei Simulationsstart
die Default Transition aktiviert und gibt somit den Weg zum zunächst aktiven Zustand frei.
Im Modell-Explorer Bild 6.9 sind die Daten des Charts deklariert. Die Einstellung von s0
ist dabei so gewählt, dass sie über den Workspace eingelesen wird. Die Update method ist auf
Inherited zu stellen, womit das Chart von der schnellsten, anliegenden Datenleitungen getrieben
wird.
Bild 6.9: Explorer mit Stateflow-Daten
Test des Charts

Mit drei, z. B. sinusförmigen, Testsignalen lässt sich die Logik im Chart überprüfen, vgl.
Bild 6.10 sowie s_test.mdl in [52]. Hierzu sind Signalamplituden von 1 sowie drei unter-
schiedliche Frequenzen, z. B. 0,75 | 1,0 | 1,2, und Phasen, z. B. π/6 | 0 | π/4 in den Sine Wave
Blöcken einzustellen. Der Anfangswert s0=1 muss im Workspace liegen. Wesentlich ist, dass
nur eine gültige wegführende Transition eines Zustandes möglich ist. Dies ist nur mit unterschied-
lichen Phasen der Testsignale erreichbar. Bei geöffnetem Grafik-Editor kann der Logik-Ablauf,
ggf. mit Totzeiteinstellung im Debugger, verfolgt werden. Bild 6.11 bestätigt die Richtigkeit der
abgebildeten Logik.
6.2.2.5 Simulationsergebnisse zum Fahrzeugmodell

Gegenüber der bisherigen Simulink-Modellierung mit dem Coulomb & Viscous Friction Block
aus Abschn. 4.4.1 bietet dieser Lösungsweg eine unproblematische numerische Integration. Die
Simulationsergebnisse nach Bild 6.12 zeigen an den Übergängen von Gleiten/Haften und umge-
kehrt definierte Schaltzustände, so dass stückweise stetige Funktionen zu integrieren sind. Mit
dem Floating Scope in Bild 6.6 lassen sich Aktivitäten und Daten einzelner Zustände im Chart
anzeigen. Hierzu ist aus der Menü-Leiste des Scope-Fensters, siehe Bild 6.14, mit dem Signal
Bild 6.10: Testaufbau zur Überprüfung der Dreipunkt-Schaltlogik im Chart
Bild 6.11: Testergebnisse zur Überprüfung der Dreipunkt-Schaltlogik im Chart; Signale: s, q, S+ , S− in

Abhängigkeit von t
selection Button der Signal Selector zu öffnen und die gewünschte Ausgabe anzuwählen. In
Bild 6.14 sind die aktiven und inaktiven Phasen der Zustände haften, ngleiten, pgleiten
nach Bild 6.8 aufgezeichnet. Die einzelnen Reibphasen lassen sich interpretieren und mit den an-
deren Ergebnissen in Einklang bringen.
6.3 Beispiel: Springender Ball

Anhand des springenden Balls im umgebenen Medium aus Abschn. 5.6.4.1 wollen wir zeigen,
wie einerseits ein Zustandsereignis, ein Event, der Simulink-Umgebung das Chart über ein ex-
ternes Triggersignal aktiviert und andererseits ein lokales Event des Charts zur Steuerung von
6.3 Beispiel: Springender Ball 331
a: Geschwindigkeiten b: Relativgeschwindigkeiten
Bild 6.12: Geschwindigkeiten von Aufbau und Rad sowie zugehörige Relativgeschwindigkeit
Bild 6.13: Boolsche Werte der Nullstellen von q
Bild 6.14: Haft- und Gleitphasen im Floating Scope
Simulink-Komponenten herangezogen werden kann. Die in Abschn. 5.6.4.1 eingeführten Para-

meter und die Bewegungsgleichungen für das Zeitintervall 0 ≤ t ≤ tu übernehmen wir:
ẍ + cw v ẋ = 0 Horizontalbewegung; ÿ + cw v ẏ = −g Vertikalbewegung,

wobei v = ẋ2 + ẏ2 der Betrag der Ballgeschwindigkeit ist. Das Springen soll beendet sein, wenn
die Auftreffgeschwindigkeit eine vorgegebene Schranke, z. B. |v| = 10−3 m/s, unterschreitet, so
dass im zweiten Bewegungsabschnitt tu ≤ t ≤ te die Bewegungsgleichungen
ẍ+cw v ẋ = 0 Horizontalbewegung; ÿ = 0, mit ẏ(tu ) = 0, y(tu ) = 0, Vertikalbewegung
gelten. Es ist ein strukturvariables System zu modellieren.
Bild 6.15: Simulink-Modell zum springenden Ball
Auf der Basis des Simulink-Modells aus Abschn. 5.6.4.1, Bild 5.27 ist das angepasste Simulink-
Modell in Bild 6.15 dargestellt und in [52] unter ball_stateflow.mdl abgelegt. Stateflow-
Elemente übernehmen die Berechnung der Stoßgeschwindigkeiten (v+ = −εs v− ) und die Inte-
grierersteuerung. Zur Integration der Bewegungsgleichung benötigen wir für jede Bewegungs-
richtung zwei Integrierer. Neben den Signaleingängen werden beim ersten Integrierer der Ver-
tikalbewegung y auch der Triggereingang zur Integrationsunterbrechung beim Aufprall und der
Eingang zum externen Setzen des Anfangswerts zu Simulationsbeginn und nach jedem Aufprall
benötigt. Darüber hinaus muss über den State Port die aktuelle Ballgeschwindigkeit ve als Chart-
Eingangssignal ausgegeben werden. Die Zeitpunkte der Nullstellen der Ballposition y (Schalt-
funktion) werden durch den Hit Crossing Block detektiert. Dabei wird das Ausgangssignal beim
Auftreten eines Ereignisses (Nullstelle) kurzzeitig wie in Bild 6.17c von 0 auf 1 und unmittel-
bar danach wieder auf 0 gesetzt. Die aufsteigende und abfallende Flanke (either) dieses Signals
nutzen wir als externes Triggersignal (Event) zur Steuerung des Logik-Ablaufs im Chart. Da-
zu muss das Event Aufprall im Explorer als Simulink-Eingang mit beiden Trigger-Flanken
(steigend/fallend – either –) deklariert werden, vgl. die Explorer-Einstellung.
Beim Start einer Simulation ist die State Machine und damit das Chart zunächst in Ruhe;
6.3 Beispiel: Springender Ball 333
es muss durch ein externes Event aufgeweckt werden. Ist die Update-Methode Inherited einge-
stellt, dann erfolgt der Weckvorgang durch die schnellste angelegte Simulink-Signalleitung. Un-
abhängig von der Update-Methode kann aber auch im eingeblendeten Menü Chart: u. a. durch
Aktivieren von Execute Chart At Initialization bei der Initialisierung des umgebenen Simulink-
Modells im Chart ein implizites Event ausgelöst werden. Dadurch befindet sich das Chart zum
Simulationsbeginn t = 0 in einer definierten Ausgangslage, ohne dass explizit ein Event auftritt.
Bemerkungen zum Chart, Bild 6.16
Variablen: Mit der Variablen Res wird der Integrierer gesteuert; die erzeugte steigende Flanke
0 → 1 unterbricht die Integration. v_0 ist die Geschwindigkeit nach dem Stoß, g die negative
Erdbeschleunigung g:= −g. Res, v_0, g sind somit die Output-Variablen. Die Input-Variable
v_e ist die Aufprallgeschwindigkeit. eps, s sind lokale Variablen des Stoßfaktors sowie des
Steuerparameters zur Umschaltung von v_0 und g während der Rollphase.
Bild 6.16: Stateflow-Diagramm mit Steuerlogik
Das Chart in Bild 6.16 besteht aus dem Superstate Ball sowie den beiden Substates Bewe-
gung und Stoss. Das Superstate dient hier nur zur Demonstration, es kann entfallen. Ist
Ball aktiv, dann wird zunächst die Standardtransition ausgeführt und aktiviert den Zustand
Bewegung, so dass die Entry-Aktion Res=0 ausgeführt wird. Bewegung wird inaktiv nach-
dem das externe Event steigende/fallende Flanke wahr wird. Die Transition mit dem Label
Aufprall aktiviert den Zustand Stoss. Die Entry-Aktionen zu v_0, Res=1 und g=s*g
– zunächst mit s=1 – werden abgearbeitet. Durch Res 0 → 1 wird die Integration gestoppt, der
neue Anfangswert v_0 gesetzt und die Integration fortgesetzt. Da die label-freie, wegführende
Transition stets wahr ist, das gesetzte Label an der Transition vom Verbindungspunkt bis zum fol-
genden Zustand falsch ist, wird die ungesetzte Transition ausgeführt. Der Zustand Bewegung
ist bis zum Einsatz des nächsten externen Events wieder aktiv. Dies setzt sich bis zum vorletzten
Durchlauf, bei dem ve ≤ 10−3 ist, fort. Da in diesem Fall der Transitions-Label wahr ist, wird die
gesetzte Transition gegenüber der ebenfalls gültigen leeren Transition ausgeführt, d. h. die Aktio-
nen s=0 und eps=0 werden zugewiesen. Das hat zur Folge, dass nach dem nächsten externen
Event v_0=0 und g=0 ausgegeben werden und die Integration hiermit zu Ende geführt wird.
Alternativ kann zur Integrierer-Steuerung, statt der Flanke von Res 0 → 1, auch die Aktivie-
rung des Zustandes Stoss herangezogen werden. Dazu muss dieses interne Event an Simulink
übergeben werden. Hierzu ist z. B. im Explorer nach Anklicken des Zustandes Stoss im Model
Hierarchy Fenster die Eigenschaft Output State Activity im rechten Fenster zu aktivieren.
Beide Realisierungen sind, wie in Bild 6.15 gezeigt, mit dem Manual Switch Block auszuwäh-
len. Die Animation der Abläufe im Chart sind im offenen Grafik-Editor zu beobachten. Detaillier-
ter wird die Animation im Debugger-Modus. Hierzu ist mit Tolls/Debug... das zugehörige
Fester zu öffnen und die Breakpoints z. B. Chart Entry und State Entry zu setzen. Die Abläufe
im Chart, sowie die der Simulationsergebnisse im Scope1 sind nun, z. B. im Step-Modus, zu
verfolgen.
Simulation
Zur Simulationsinitialisierung und der Darstellung der Ergebnisse kann das folgende M-File
ball_state_start.m aus [52] genutzt werden:
% ---- Optionen und Simulations-Aufruf

options=simset(’RelTol’,1.0e-3,’MaxStep’,0.01,’Refine’,4);
[t,y,q]=sim(’ball_stateflow’,[0, 10],options);
% ---- Darstellung der Ergebnisse

figure(1); .......
%.............Fortsetzung siehe ball-statefl_start.m ........
Bild 6.17: Simulationsergebnisse mit Nullstellenzeitpunkte, Ausgangssignal des Hit Crossing Blocks
Wesentlich sind die gesetzten Optionen RelTol, MaxStep und Refine. Insbesondere die Op-
tionen MaxStep und/oder Refine beeinflussen die Simulation im Übergangsbereich zum Rol-
len maßgeblich. Die unmittelbar aufeinanderfolgenden Auftreffpunkte, vgl. Bild 6.173 , können
nur durch eine richtige Abstimmung detektiert werden. Gegebenenfalls ist das Abbruchkriterium
|v| ≤ 10−3 zu entschärfen.
Die Simulationsergebnisse von Bild 6.17 sind selbsterklärend. Insbesondere der Einfluss des
Widerstandes infolge des umgebenen Mediums wird deutlich.
Übungsvorschlag: Modellieren Sie ein Chart, bei dem der Übergang in den Rollzustand durch
einen weiteren Zustand erreicht wird, d. h. die mit dem Label
[fabs(v_e)<=1.0e-03]{s=0;eps=0;}
in Bild 6.16 gesetzte Transition ist zu ersetzen. Hilfe: ball_stateflow_1.mdl aus [52].

7 Physikalische Modelle unter Simulink
Zur Bearbeitung insbesondere von Mehrdomänen-Modellen, wie in der Mechatronik, bietet die
objektorientierte Modellierung physikalischer Systeme ein geeignetes Werkzeug. Diesbezüglich
sind u. a. die Simulationsprogramme MODELICA1 [13], [63], ITI-Sim und Saber einzuordnen.
In der MATLAB/Simulink-Umgebung stehen z. Z. die blockorientierten Tools Simscape mit me-
chanischen, magnetischen, elektrischen, hydraulischen, thermischen Elementen in der Founda-
tion Library, SimMechanics für mechanische Mehrkörpersysteme, SimHydraulics für hydrauli-
sche Komponenten, SimDriveline für Antriebsstränge und SimPowerSystems für Elemente der
Leistungselektronik zu Verfügung. Bild 7.1 zeigt, dass bis auf SimPowerSystems alle anderen
in der Simscape Library eingebettet sind. Darüber hinaus sind die vorhandenen Sublibraries
des SimMechanics Tools ersichtlich; zugehörige Elementbeispiele zeigt Bild 7.2. Damit ist eine
erweiterte Multidomänen-Simulation in der Simulink-Umgebung möglich, Co-Simulation mit
anderen Programmsystemen entfallen weitgehend. Zur Modellierung werden nicht zwingend Ex-
perten der einzelnen Disziplinen benötigt. Da Simscape über eine eigene Sprache verfügt, sind
weitere Modellierungen eigener Komponenten bzw. Baugruppen möglich.
Bild 7.1: Übersicht der Simscape- und SimMechanics-Library
Die Arbeitsweise mit diesen Tools wollen wir anhand von SimMechanics etwas näher erläu-
tern, so dass man einen Einblick in die Arbeitsweise der physikalischen Modellierung erhält und
somit eine Einarbeitung in die anderen Tolls, unterstützt durch die jeweiligen Demos, verständli-
cher und einfacher wird.
Die Modellierung mit SimMechanics setzt einige Grundlagen der Mehrkörperbeschreibun-
gen voraus, auf die hier nicht ausführlich eingegangen werden kann. Es soll trotzdem versucht
werden, einige Begriffe in die Vorstellung einzuarbeiten. Im Einzelfall muss aber auf Spezial-
Literatur wie u. a. [6], [15], [29], [54], [56], [67] verwiesen werden.
1 http://www.modelica.org

DOI 10.1007/978-3-8348-8630-9_7,
336 7 Physikalische Modelle unter Simulink
Bild 7.2: Beispiele aus den SimMechanics-Sublibraries
7.1 SimMechanics Tool

Dieser Abschnitt enthält erste Schritte zur Arbeitsweise mit SimMechanics 3.2.2. Einige Blö-
cke sowie die unterschiedlichen Analyse-Methoden und Visualisierungs-Optionen werden vorge-
stellt. Beispiele runden die Einführung ab.
7.1.1 Funktionsweise
Wie schon erwähnt, werden mechanische Systeme mit Blöcken der Modell-Library, die jeweils
ein mechanisches Element repräsentieren, modelliert. Einige Elemente sind in Bild 7.2 zusam-
mengestellt. Sie werden in der Simulink-Umgebung mit den zugehörigen Parameter-Dialog-
Boxen konfiguriert. Im Gegensatz zu herkömmlichen Simulink-Blöcken, die mathematische Ope-
rationen darstellen und signalflussorientiert vom Ausgang eines Blockes zum Eingang des Folge-
blocks, also unidirektional, arbeiten, repräsentieren SimMechanics Blöcke mit zugehörigen geo-
metrischen und kinematischen Verträglichkeiten physikalische Komponenten, d. h. die Blöcke
haben hier eine eindeutige mechanische Bedeutung. Dadurch wird nicht mehr gleichungsorien-
tiert sondern objektorientiert gearbeitet. Die Datenflussrichtung zwischen verbundenen Blöcken
verläuft in beide Richtungen (bidirektional), die Pfade zeigen keine Pfeile. Man denke nur an
die Kraftwirkung zweier miteinander verbundener Massen (actio und reactio), wobei es keine de-
finierte Richtung des Signalflusses gibt. Damit sind auch Verzweigungen wie in Simulink unter
SimMechanics nicht möglich. Ausgehend von der Topologie des Modells mit den Systemparame-
tern, z. B. Masse, Trägheitstensor, geometrische Abmessungen, werden die Bewegungsgleichun-
gen für eine Simulation im Rechner generiert. Die abhängigen Variablen sind Relativkoordinaten
bezogen auf die durch die Geometrie vorgegebene Referenzlage.
Neben einfachen Standardblöcken – Body, Ground, Joint Sensor usw. – existieren solche mit
7.1 SimMechanics Tool 337
komplexer Funktionalität, was die Modellierung erheblich erleichtert. Z. B. kann mit dem Joint
Stiction Actuator in Abhängigkeit von Ereignissen ein Gelenk (Dreh- oder Schubgelenk) zeit-
weilig blockiert und anschließend wieder freigegeben werden. Typische Anwendungsfälle sind
Reibverbindungen mit Stick-Slip-Bewegungen, wie bereits in Kapitel 5.6.5 aber auch später un-
ter SimMechanics behandelt. Darüber hinaus existieren in der Sublibrary Joints/Disassembled
Joint Elemente die aufgeschnitten werden können, womit Systeme mit geschlossenen Schlei-
fen – vgl. Kurbeltrieb in Kapitel 5.4 – in solche mit offenen Schleifen überführt werden kön-
nen. Eine solche Situation überbestimmter Systeme erkennt SimMechanics aber auch automa-
tisch, so dass der Anwender diesen Übergang nicht explizit einleiten muss, vgl. Demo-Beispiel:
mech_four_bar.mdl. Insbesondere die Ermittlung konsistenter Anfangsbedingungen bei
nichtlinearen Systemen wird dadurch erleichtert.
Die Verbindungen zu Simulink-Komponenten werden durch die Sensor- und Actuator Blöcke
aus der Sensor & Actuator-Library hergestellt. Wie der Name schon andeutet, transformieren
Actuator Blöcke Simulink-Signale in Bewegungen, Kräfte oder Momente. Umgekehrt überfüh-
ren Sensor Blöcke mechanische Variable in Signale. Insbesondere lassen sich damit geregelte
mechanische Systeme in einer Umgebung bearbeiten. Sie sind ab der Version 2 echtzeitfähig,
womit Hardware-in-the-Loop (HIL)-Abläufe realisierbar sind.
7.1.2 Untersuchungsmethoden
SimMechanics unterscheidet vier Methoden zur Analyse mechanischer Systeme:
• Forward Dynamics: Berechnet die Bewegung (Zeitverläufe) eines Modells infolge der an-
greifenden Kräfte/Momente sowie der Zwangsbedingungen ausgehend von vorgegebenen
Anfangsbedingungen (Lage, Geschwindigkeit). Dies entspricht der bisherigen Simulation
durch numerische Integration der Differenzialgleichungen.
• Inverse Dynamics: Bestimmt die Kräfte/Momente die erforderlich sind, um eine vorgegebe-
ne Bewegung in offenen Schleifensystemen aufrecht zu erhalten, z. B. die Antriebsmomente
eines Roboters bei vorgegebener Endeffektor-Bewegung.
• Kinematics: entspricht der inversen Dynamik bei geschlossenen Schleifensystemen.
• Trimming: Berechnung von stationären oder Gleichgewichtszuständen; dies dient vielfach
der Linearisierung um Sollbewegungen oder Arbeitspunkten bzw. Gleichgewichtslagen, vgl.
Abschn. 8.4.7.
Die Methodenauswahl erfolgt in der Dialog-Box des Machine Environment Blocks.
7.1.3 Erstes SimMechanics-Modell

Um einen ersten Einblick in die Modellierung zu erhalten, betrachten wir zunächst den Einmas-
senschwinger nach Bild 7.3. Er ist zwar kein Repräsentant eines Mehrkörpermodells, zeigt aber
überschaubar und nachvollziehbar die Arbeitsweise von SimMechanics und die Ankopplung an
Simulink-Komponenten.
Der Quader mit den Kantenlängen a = b = 0,1 m, c = 0,05 m von Breite, Höhe und Tiefe sowie
der Masse m = 1,5 kg gleitet zunächst auf einer glatten Ebene. Er wird einerseits mit einem Feder-
Dämpfungs-Element k = 2 N/m, d = 0,02 Ns/m mit der Federlänge FD = 0,1 m der entspannten
Feder an die Umgebung gekoppelt, andererseits durch die äußere Kraft f (t) = 20 sin 5t angeregt.
Bild 7.3: Einmassenschwinger und Koordinatensysteme zur Modellierung mit SimMechanics
Neben den Modellparametern und der Geometrie mit verträglichen Einheiten (in der Regel
im MKS-System) spielen die verwendeten Koordinatensysteme (CS Coordinate System) u. a. zur
Festschreibung der Topologie eine zentrale Bedeutung. In SimMechanics wird unterschieden:
• Das Inertial-, bzw. Welt-, bzw. World-Koordinatensystem (I) – I x, I y, I z – (rechtsorientiert,

kartesisch), worin alle folgenden eingebettet sind. Wir bleiben bei der bisherigen Bezeich-
nung (I) für Inertialsystem; SimMechanics verwendet (W ).
• Das Ground-System (G) – I xG , I yG , I zG ; es beschreibt einen Fixpunkt des Modells inner-
halb von (I) und ist hierzu parallel.
• Das körperfeste System (K) – K x, K y, K z – für Lage und Orientierung. Die Orientierung
(Drehung) gegenüber (I) kann mit definierten EULER-Winkeln, Quaternionen oder 3×3
Transformationen [67] geändert werden.
Die Kontaktpunkte zweier benachbarter Körper – die Bindung –, hier den der glatten Unterla-
ge und den des Quaders, werden durch die Punkte B (Basis) und F (Follower), vgl. Prismatic
Block in Bild 7.5, charakterisiert. Dadurch können über einen Joint Sensor Block neben den Re-
lativgrößen Position, Geschwindigkeit, Beschleunigung von F gegenüber B auch Reaktionskräfte
bezüglich B oder F gemessen werden. Darüber hinaus muss bei der Einführung der Koordinaten-
systeme sichergestellt werden, dass – wie hier – bei einer Translationsbewegung F und B auf
einer Achse oder in einer Ebene liegen, d. h. es ist auf Verträglichkeit zu achten.
Da die Masse nach Voraussetzung nur einen translatorischen Freiheitsgrad hat, könnten wir
sie als Punktmasse behandeln, womit u. a. die Koordinatensysteme zusammenfallen könnten. Um
aber das Handling mit den Koordinaten zu zeigen, benutzen wir die eingeführten geometrischen
Abmessungen a, b, c, h, FD . Zunächst wählen wir den Bezugspunkt 0 nach Bild 7.3 als Ur-
sprung des World-Systems (I) mit der angegebenen Orientierung – es ist also gegenüber Bild 7.3
neu zu positionieren. Den Ursprung des dazu parallel angeordneten Ground-Systems (G) legen
wir im Abstand h auf die neue I y-Achse von (I), so dass B auf I xG liegt. Damit ist die Lage von
(K) – hier CS2 – nicht mehr frei wählbar, I xG und K x müssen wie in Bild 7.3 zusammenfallen.
Weitere körperfeste Punkte, z. B. der Schwerpunkt (Massenmittelpunkt, Center of Gravity)
CG und der Feder-Dämpfer-Angriffspunkt CS1 sind in (K) oder (I) beschreibbar; vgl. Body
Block in Bild 7.5. Sie erhalten zunächst die Orientierung von (I). Auf der Seite Orientation
Bild 7.4: Dialog-Boxen zum Body Block
in der Body-Dialog-Box kann diese jedoch verändert werden. Darüber hinaus kann sich das Ko-
ordinatensystem mit seiner Orientierung auf den vorangegangenen Körper (Adjoining) beziehen,
die dann übernommen wird. Zusätzliche Körperpunkte CS3, 4,... wie in Bild 7.4 sind u. a. zur
anschaulichen Darstellung in einer Animation festschreibbar. Diese geometrischen Daten sowie
die der Masse m und des Trägheitstensors I CG =diag(Ixx , Iyy , Izz ) bezogen auf das Schwerpunkt-
Koordinatensystem mit dem Ursprung in CG sind in der Dialog-Box nach Bild 7.4 des jeweili-
gen Körpers (Body) einzutragen. Wir wollen nun schrittweise den Block-Modell-Aufbau – man
Bild 7.5: SimMechanics-Modell eines Einmassenschwingers mit Alternativen zur Modellierung

spricht auch von der Maschine (Machine) – nach Bild 7.5 besprechen. Zu eigenen Experimenten
dient das Programm M1_sm.mdl und M1_ss.mdl für eine erste Modellierung mit Simscape
in [52].
Zunächst wird mit dem Ground Block der Fixpunkt in (I) mit I x =I z = 0, I y = h festgeschrie-
ben, hierzu ist der Vektor [0, h, 0] in die Ground-Dialog-Box einzutragen. Jede Maschine muss
mindestens einen Ground Block enthalten. Ergänzend müssen die Umgebungsparameter der Ma-
schine im Machine Environment Block angegeben werden. Hierzu ist in der Ground-Dialog-Box
das Fenster Show Machine Environment Port zu aktivieren. Danach sind beide Blöcke miteinan-
der zu verbinden. Zu den Umgebungsparametern zählen u. a. der Gravitationsvektor in Bezug auf
das gewählte World-System (I); hier [0, −9,81, 0] m/s2 sowie die angestrebte Untersuchungsme-
thode hier: Forward Dynamics. Alle weiteren Einstellungen übernehmen wir zunächst, einige
diesbezügliche Erläuterungen folgen später.
Die prismatische Führung (Schubgelenk) des Quaders wird mit dem Prismatic Block model-
liert. Der Basis-Punkt B liegt dabei an Ground, der Folgepunkt F ist Punkt des Körpers. Die trans-
latorische Bewegungsrichtung des Schubgelenkes bezüglich der eingeführten Koordinatensyste-
me ist in vektorieller Form – hier: [1 0 0], da x die Bewegungsrichtung ist – in die Dialog-Box
einzutragen. Die Anzahl weiterer Ports z. B. für den Joint Sensor Block sowie den Anfangswert-
Block IC können angezeigt werden. In den jeweiligen Dialog-Fenstern sind einerseits die ge-
wünschten Ausgabegrößen in die Simulink-Umgebung auszuwählen und andererseits sind die
Anfangswerte als numerische oder symbolische Größe vorzugeben. Der IC Block enthält hier
Lage und Geschwindigkeit zum Zeitpunkt t = 0 bezüglich der konfigurierten Gleichgewichtsla-
ge. Der Quader wird durch den Body Block repräsentiert. In der Dialog-Box nach Bild 7.4 sind
hierfür die Größe der Masse – symbolisch m oder numerisch 1.5 –, der Trägheitstensor I CG , hier
beliebig, mit den verwendeten Einheiten einzutragen. Gehen wir von einer Punktmasse aus, dann
ist I CG der Null-Tensor, was zum Warning führt. Die Lagen der körperfesten Punkte gegenüber
einer gewählten Basis u. a. World sind im unteren Box-Bereich unter Body coordinate systems
vorzugeben; Block-Ports z. B. für den Body Actuator Block sind unter Show port zu aktivieren.
Daten, auf die nur zur Darstellung in einer Animation zurückgegriffen wird, benötigen keinen
Port; vgl. die vorgenommene Parameter-Einstellung in Bild 7.4. Vorschlag: Skizzieren Sie mit
den Daten des Body Blocks den Quader mit den eingeführten Koordinatensystemen; die Maße
beziehen sich alle auf das Koordinatensystem CS2.
Das Feder-Dämpfer-Element sowie die Anregung f (t) modellieren wir zunächst mit bekann-
ten Simulink-Komponenten. Das so erzeugte vektorielle Kraftsignal [I fx , 0, 0] ist über den Body
Actuator Block auf den Körper zu bringen.
Schließlich gehen wir noch kurz auf mögliche Modellvarianten ein. Diese beziehen sich
auf die Realisierung und Aufschaltung des Feder-Dämpfer-Elements. Hierfür bieten sich die
in Bild 7.5 aufgenommenen drei alternativen Lösungen – gepunktete Signalpfade – an. Da alle
Größen von F gegenüber B des Prismatic Blocks gemessen und aufgeschaltet werden können
und speziell B ein Festpunkt ist, lässt sich, wie in der 1. Alternativen in Bild 7.5 dargestellt, die
mit Simulink-Elementen modellierte Kraft komplett über einen Joint Actuator Block einbringen.
Entsprechend ist die 2. Alternative zu verstehen, bei der das Feder-Dämpfer-Element durch den
Joint Spring & Damper Block aus der Force Elements Sublibrary von SimMechanics ersetzt wur-
de. In der 3. Alternativen wird eine Modellierung mit dem Body Spring & Damper Block aus
der gleichen Sublibrary vorgeschlagen. Dies erfordert einen weiteren Ground Block und einen
zusätzlichen Port am Body Block.
Sind die Parameter in symbolischer Form, m für die Masse usw. eingetragen, dann können die
für Simulink geltenden Möglichkeiten der numerischen Wertzuweisung, u. a. M-File, Tastaturein-
gabe, übernommen werden. Die Daten müssen also vor dem Start des SimMechanics-Modells
im Workspace stehen. Wir wählen den direkten Eintrag unter: File/Model Properties/
Callbacks in den Fenstern Model pre-load (kurz: PreLoadFcn) function und/oder
Model initialization function (kurz: InitFcn). Unter PreLoadFcn eingetragene
Datenzuweisungen oder M-Files werden bei Programm-Block-Öffnung ausgeführt. Parameter-
änderungen werden nur nach erneuter Modell-Öffnung aktiviert. Im Gegensatz dazu wird der
Eintrag unter InitFcn bei jedem Simulations-Start ausgeführt. Konfigurationsparameter (But-
ton: Simulation/Configuration Parameters), z. B. die Start- und Stoppzeit in symbolischer Form
tstart, tend oder Toleranzwerte müssen ab Simulink 6 unter PreLoadFcn aufgeführt wer-
den und stehen nur dann vor dem Modell-Start im Workspace.
Auf dieser Basis lassen sich Mehrkörpersysteme modellieren, wie das folgende Beispiel zei-
gen wird.
Beispiel 7.1: Schwingungen eines Roboter-Modells

Das Modell eines Roboters in Bild 7.6 besteht aus dem dreieckigen Gestell (Basisflä-
che 1 ), Höhe 1 und den beiden in A und B angelenkten starren Armen (S2 , S3 ).
Das Gestell ist über ein Feder-Dämpfer-Element an die Umgebung gekoppelt. In den
Bild 7.6: Modell des Roboters
Drehgelenken A, B wirken Dreh-Feder-Dämpfer-Elemente, die in der skizzierten Refe-

renzlage, siehe auch Bild 7.8, entspannt sind. Aus dieser Referenzlage bei gleichzeitig
entspannter Translationsfeder (k, Länge FD ) schwingt das System in seine Gleichge-
wichtslage. Dieser Einschwingvorgang ist ausgehend von der Referenzlage mit Hilfe
der Vorwärtsdynamik (Forward dynamics) zu untersuchen. In einem zweiten Schritt
soll der Endeffektor (Greifer) einem vorgegebenen Zeitsignal folgen, was durch die
Blöcke Angle driver, Driver Actuator aus der Constraints & Drivers bzw. Sensors &
Actuators Library zu realisieren ist.
Tabelle 7.1: Wesentliche Modellparameter
Massen m1 , m2 , m3 20, 5,64, 2,92 kg

Trägheitstensor Θ S2 diag(2,1, 630, 630) 10−3 kg m2
Trägheitstensor Θ S3 diag(1,1, 88, 88) 10−3 kg m2
Gestellabmessung 1 0,4 m
Gelenkabstände 2 , 3 0,48, 0,24 m
Referenzlagen ϕ20 , ϕ30 π/4, π/6 rad
entspannte Federlänge FD 0,6 m
Feder-, Dämpferkonstante k, d 400, 5 N/m, Ns/m
Dreh-Feder-, -Dämpferk. k12,23 , d12,23 200, 16, 2, 0 Nm/rad, Nms/rad
Erdbeschleunigung g 9,81 m/s2
Lösung
Modellerstellung: Anhand von Bild 7.6 und Bild 7.8 sowie den Parametern nach Ta-
belle 7.1 lässt sich das SimMechanics Modell Bild 7.7 erstellen. Der Ursprung 0 des
Inertialsystems (I) bzw. (W ) liegt im Federfußpunkt, das Ground-System fällt mit (I)
zusammen. Gestell, Arm 1 und Arm 2 entsprechen jeweils einem Body Block. Das Ge-
stell führt, wie im einführenden Quader-Modell, eine Translationsbewegung aus, was
ein Prismatic Block (Schubgelenk) mit dem Ground Block liefert. Die Gelenke A und
B sind Drehgelenke, wozu jeweils ein Revolute Block benötigt wird.
Bild 7.7: SimMechanics-Modell des Roboters
Das translatorische Feder-Dämpfer-Element zwischen Quader und Umgebung wird

mit dem Body Spring & Damper Block abgebildet, wozu ein weiterer Ground Block
erforderlich wird. Die Dreh-Feder-Dämpfer-Elemente, Joint Spring & Damper Block,
in den Gelenken A, B erzeugen aufgrund der Relativbewegungen innere Momente und
sind somit an dem jeweiligen Revolute Block (weitere Ports müssen angezeigt werden)
anzuschließen. In die zugehörigen Parameter-Boxen sind Feder- (Spring Constant),
Dämpferkonstante (Damper Constant) sowie ggf. die Länge der entspannten Federn,
hier: FD , einzutragen.
Als Messgrößen bieten sich u. a. die Relativwinkel (Angle) Δϕ2 Δϕ3 sowie die
damit berechenbaren Gelenkmomente (Computed torque) in A, B sowie die Transla-
tionsbewegung von m1 an. Im jeweiligen Joint Sensor Block sind zugehörige Größen
auszuwählen, womit sie als Simulink-Signal, z. B. angezeigt werden können.
Wesentlich sind die Eintragungen in die Block Parameters Fenster der Body Blöcke.
Sie beinhalten neben den Masseeigenschaften die Referenzlagen, die hier der Konfi-
guration mit entspannten Federn entspricht; z. B. die Schwerpunktslage (CG) des Ge-
stells im I-System, [ FD + 0,51 , 0, 0 ], von wo aus sich die Ankopplungen CS1, CS2,
CS3 vermaßen lassen. Weitere Körperpunkte können für die Visualisierung nützlich
sein. Entsprechend sind die Masseeigenschaften der Roboter-Arme aus Tabelle 7.1
einzutragen.
Die Vorgabe von Positionen und Orientierung von Arm 1 verdeutlichen wir mit
Bild 7.9. Danach wird die Position von CS1, also die Anlenkung in A, vom vorange-
Bild 7.8: Winkel-Beziehungen und Schnittbild zur Berechnung der Gleichgewichtslage
gangenen Block übernommen (Adjoining). Bezüglich dieser Lage lassen sich Schwer-
punkt (CG) und Gelenklage B im körperfesten System angeben. Die Orientierung
ϕ10 von Arm 1 entspricht der Referenzlage in Bild 7.8 bzw. Bild 7.6. Das so schritt-
weise aufgebaute Modell stellt man zweckmäßigerweise im Visualisierungs-Fenster,
vgl. Bild 7.16 und Abschn. 7.1.5, dar. Jede Änderung der Geometrie im Body Block
wird durch ein Update: Edit/Update Diagram, Ctrl+D bzw. mit dem Update-
Button im Modell oder Visualisierungsfenster übernommen. Koordinatensysteme,
Schwerpunkte usw. lassen sich ein- und ausblenden. Für Arm 2 ist entsprechend zu
verfahren.
Ergebnisse: Wenn möglich sollten zunächst Kontrollgrößen berechnet werden. Dies
wären hier die Relativwinkel Δϕ20 , Δϕ30 der Gleichgewichtslage und die sich im sta-
tionären Zustand einstellenden Gelenkmomente. Die von SimMechanics verwendeten
Relativwinkel werden aus der Referenzlage gezählt, es gilt:
Arm 1 (m2 ) gegenüber Gestell (m1 ) : Δϕ2 − ϕ10 = Δϕ2 , ϕ10 = 0

Arm 2 (m3 ) gegebüber Arm 1 (m2 ) : (Δϕ2 + Δϕ3 ) − Δϕ2 = Δϕ3 .
Bild 7.9: Parameter-Box zu Arm 1, Position und Orientierung
Die in Bild 7.7 eingeführten Scopes zeigen also unmittelbar die relativen Drehwinkel
Δϕ2 , Δϕ3 an.
Mit dem Schnittbild in Bild 7.8 lässt sich das statische Gleichgewicht bezüglich A und
B3 anschreiben:
∑ M(A) = 0 = k12 Δϕ2 − k23 Δϕ3 + g2 (m2 + 2m3 ) cos(ϕ20 + Δϕ2 )
∑ M(B3 ) = 0 = k23 Δϕ3 + m3 g3 cos(−ϕ30 + Δϕ2 + Δϕ3 ) .
Dies sind zwei nichtlineare algebraische Gleichungssysteme für Δϕ2 , Δϕ3 , die in
RobiDaten.m, vgl. auch Newton.pdf, aus [52] mit Hilfe des N EWTON-Verfah-
rens gelöst werden; es ergeben sich die Gleichgewichtslagen (Δϕ j → Δϕ j0 ) und die
Gelenkmomente zu:
Δϕ20 = −0,25077 rad, Δϕ30 = −0,23019 rad

(A)
m = −k12 Δϕ20 = 50,1548 Nm, m(B) = −k23 Δϕ30 = 3,6830 Nm .
Diese Ergebnisse lassen sich mit Robi.mdl aus [52] nach dem Einschwingvorgang
bestätigen.
Die um die zeitliche Winkelvorgabe des Endeffektors erweiterte Modellierung ist im
MDL-File RobiAkt [52] gezeigt.
7.1.4 Arbeitsweise des Joint Stiction Actuators

Ein typischer Vertreter eines komplexeren Objekts ist der Joint Stiction Actuator. Anwendungen
sind Gelenke mit Reibung, wobei Gleit- und Haftreibungsphasen, also spezielle ereignisgesteuer-
te Phasen, auftreten. Die Bezeichnungsweise zur Formulierung der Reibgesetzmäßigkeiten unter
SimMechanics unterscheidet sich von der der deutschsprachigen Literatur, wie in Abschn. 5.6.5.
Zur besseren Abstimmung mit den SimMechanics-Komponenten benutzen wir weitgehend die
SimMechanics-Schreibweise. Ein Bezug u. a. zu Abschn. 5.6.5 ist einfach herzustellen. Der Joint
Stiction Actuator aus der Library Sensors & Actuators mit seiner Dialog-Box ist in Bild 7.10,
woraus auch die Beschaltung hervorgeht, dargestellt. Weitere Information ist der Online-Hilfe
Bild 7.10: Joint Stiction Actuators und Prismatic Block sowie zugehörige Dialog-Box
Bild 7.11: Reibelement des Joint Stiction Actuators mit Bezeichnungen
bzw. [1] zu entnehmen. Der Actuator ist im Zusammenhang mit einem Schub- bzw. Drehgelenk
(kein Kugelgelenk, spherical primitive) einzusetzen. Dementsprechend sind die Eingangsgrößen
Kräfte/Momente mit festzuschreibenden Einheiten (MKS- oder SI- Einheiten) in die zugehöri-
gen Dialog-Boxen, wie z. B. in Bild 7.10, einzutragen. Das Objekt des Actuators ist das C OU -
f
LOMBsche Reibgesetz nach Bild 7.11. Die Extremwerte der Haftung sind Fs , Fsr (s stiction, f
forward, r reverse) bezüglich der Vorwärts- und Rückwärtsbewegung. Fk (k kinetic) ist die vor-
zeichenbehaftete Gleitreibungsgröße.
Liegt die Relativgeschwindigkeit v innerhalb des Intervalls [−vth , +vth ] nach Bild 7.11, dann
wird numerisch zwischen Haften und Gleiten entschieden. Die verwendete Schaltstrategie ist der
Online-Hilfe zum Joint Stiction Actuator zu entnehmen. Da der Schwellwert (threshold) vth > 0
von der Integrationsschrittweite abhängig sein muss, ist gleichzeitig die Absolute Tolerance der
Integrierereinstellung zu beachten; die Einstellung auto ist somit nicht erlaubt. Anhaltswert: vth
sollte 10 mal größer als die Absolute Tolerance gewählt werden.
Zur Erläuterung der Beschaltung des Joint Stiction Actuators betrachten wir wieder den Ein-
massenschwinger nach Bild 7.3, wobei in den Kontaktpunkten F/B eine Reibkraft mit dem Gleit-
reibungskoeffizienten μ =0,8 und dem Haftreibungskoeffizienten μ0 =1,5 wirken soll. Die Einstel-
lungen der Dialog-Box in Bild 7.10 übernehmen wir. Die Eingangssignale des Actuator Block
• Kinetic Friction Fk = μ m g
• Forward Stiction Limit Fsf = −μ0 m g
• Reverse Stiction Limit Fsr = +μ0 m g
sind eindeutig. Die beiden restlichen Signale sind von der Modellierung der Maschine abhängig.
Deshalb erläutern wir zunächst den External Actuation Eingang Fext , worüber sich auch andere
als Reibkräfte/momente aufschalten lassen. Bezüglich unseres Beispiels können wir, wie gezeigt,
die Kraft aus der Anregung f (t) und der des Feder-Dämpfer-Elements über den Body Actuator
Block direkt auf den Body Block legen, so dass dann Fext = 0 ist. D. h. neben den Relativkräften
der Reibung werden keine weiteren vom Joint Stiction Actuator übergeben. Wir können aber
auch, ähnlich der 1. Alternativen in Bild 7.5 mit den dort aufgeführten Gründen, die Simulink-
Modellierung der (Relativ-) Kraft
Fext = −k x − d ẋ + f (t)
auf den Eingang External Actuation in Bild 7.10 geben.

Abhängig von diesen Darstellungsmöglichkeiten ist jetzt die Static Test Friction Ftest zu for-
mulieren. Ftest ist u. a. nach [1] ein Maß für Kraft/Moment während der Haftphase Fsf < Ftest <
Fsr , sie dient der Berechnung des Übergangs zur Gleitphase innerhalb von [−vth , +vth ]. Diese
Kraft/Momenten-Signale werden nicht zur Integration der Bewegung herangezogen, sie dienen
lediglich der Ermittlung von Schaltpunkten, vgl. Abschn. 5.6.5. Wesentlich sind insofern nur die
Relationen zueinander. Dies erklärt auch, dass diesbezüglich kein Eintrag in der Dialog-Box zu
finden ist. Insbesondere für Einsteiger ist es jedoch einfacher, sich an die bereits festgeschriebe-
nen Krafteinheiten z. B. von Fk zu orientieren.
In unserem sowie in den meisten Reibmodellen kann Ftest = Fs gesetzt werden. Fs ist die
statische Haftkraft und liegt demnach auch in [Fsf , Fsr ], wozu die Relativbeschleunigung ẍ =
a = 0 und -geschwindigkeit ẋ = v = 0 gehört.
Fsf , r und Ftest können von den Systemzuständen und/oder der Zeit t abhängen; vgl. auch
Demo-Beispiel: Double Pendulum with Stiction, mech_dpen_sticky.mdl.
Für unser einfaches Beispiel lässt sich Fs aus der als bekannt vorausgesetzten Bewegungsglei-
chung

Fs für v = 0
mẍ + d ẋ + kx − f (t) − =0 (7.1)
Fk für v
= 0
mit der Gleitreibungskraft (kinetic friction) Fk = −μmg sign(v) und der Haftreibungskraft (static
friction) Fs ermitteln. Aus (7.1) folgt für v = 0, ẍ = a = 0 unmittelbar
Fs = kx − f (t) . (7.2)
Bei komplexeren Systemen, z. B. mit mehreren Reibelementen, ist dies nicht mehr so einfach
zu durchschauen und auch nicht erstrebenswert. Um die Vorgehensweise zu verallgemeinern,
greifen wir deshalb auf errechnete Gelenkkräfte, die als Simulink-Signale am Joint Sensor Block
anliegen
Computed force/torque FC (eigene Bezeichnung)
Reaction force/torque FRe = ( fx , fy , fz )Re ,
zurück. Dabei ist FC hier die auf F gegenüber B bezogene Kraft in Richtung der prismatischen
Führung (prismatic axis). Sie wird vom Joint Stiction Actuator erzeugt. Für die beiden Modellie-
Bild 7.12: Schnittbilder zur direkten (Fext = 0) und indirekten (Fext

= 0)Kraftaufschaltung
rungen mit direkter (Fext = 0) und indirekter (Fext

= 0) Kraftaufschaltung sind die Situationen
in Bild 7.12 in Form der Schnittbilder dargestellt. Danach folgt für die direkte Modellierung
unmittelbar

Fs kx − f (t) für v = 0
FC = FR = = , (7.3)
Fk −μmg sign(v) für v
= 0
d. h. FC entspricht der Reibkraft FR im Haft- und Gleitbereich. Insbesondere ist FC = Fs in

[−vth , +vth ]. Bezüglich der indirekten Modellierung lesen wir aus Bild 7.12 ab:

Fs ! für v = 0
FR = = FC + d ẋ + kx − f (t) = FC − Fext , (7.4)
Fk für v
= 0
so dass insbesondere
Fs = FC − Fext für v = 0, a = 0 . (7.5)
Resultat: In jedem Falle lässt sich also die Haftreibungskraft (static friction) Fs = Ftest aus der
berechneten Kraft FC oder der entsprechenden Komponente der Reaktionskraft FRe (siehe Joint
Sensor) und der am Actuator angelegten externen Kraft Fext erzeugen; es gilt (7.5).
Beide vorgestellten Modellierungen sind in dem in Bild 7.14 dargestellten Blockdiagramm
Bild 7.13: SimMechanics-Modell des Einmassenschwingers mit Reibung bei direkter und indirekter
Kraftaufschaltung
Bild 7.14: Reibkraft-Actuator zum Einmassenschwinger mit Reibung
wiedergegeben. Die jeweilige Modellierung ist durch die beiden Manual-Switch-Schalterstellun-

gen auszuwählen. Es müssen stets beide Schalterstellungen geändert werden! Bild 7.15 zeigt ein
Ergebnis in Form der Zeitverläufe. Danach treten Stick-Slip-Bewegungen auf, d. h. Haft- und
Gleitreibungsphasen wechseln sich ab. Der Körper verharrt in den Umkehrpunkten von x(t) zeit-
weilig in der gleichen Position. Ähnliche Ergebnisse haben wir schon in Abschn. 5.6.5, 5.6.5.3
diskutiert.
Bild 7.15: Zeitverläufe: Position x(t), Geschwindigkeit v(t), Beschleunigung a(t) zum Reibschwinger
Übungsvorschlag: Das Modell des Einmassenschwingers ohne/mit Reibung ist durch ein am
Quader angebrachtes Pendel mit quadratischem Querschnitt (Kantenlänge: a p = 0,01 m), der
Pendellänge von l p = 0,5 m und der Pendelmasse m p = 0,5 kg zu ergänzen. Hilfestellung in:
M1_pendel_sm.mdl [52].
7.1.5 Visualisierung und Animation der Maschine
Bild 7.16: SimMechanics Robotermodell im Visualisierungsfenster, Trägheitsellipsoid-Darstellung
Neben den üblichen grafischen Darstellungen unter MATLAB/Simulink steht eine zusätzliche
Möglichkeit im SimMechanics Visualisierungs-Fenster nach Bild 7.16 zur Verfügung. Es kön-
nen auf der Basis der in der Body Dialog-Box festgeschriebenen Körperpunkte sowie der Masse-
eigenschaften die Körper der Maschine automatisch dargestellt werden. Dabei wird zwischen
statischer Darstellung, bei der sich die Auswirkungen z. B. der Maschinenparameter unmittelbar
beobachten lassen und der Animation dieser Darstellung während der Simulation unterschie-
den. Die Visualisierungsart wird im Rahmen der Maschinen-Konfiguration in der Machine En-
vironment und Simulation/Configuration Parameters Dialog-Box eingestellt: Z. B. erfolgt dies
zunächst in der Machine Environment Box, wo das Feld Visualization zu aktivieren ist. Über den
Button Open Configuration Parameters gelangt man zur zugehörigen Dialog-Box in der unter
SimMechanics/Visualization zwischen
• Display machine after updating diagram

• Show animation during simulation
ausgewählt werden kann. Im ersten Fall werden die Körper der Maschine statisch im SimMecha-
nics Visualisierungs-Fenster dargestellt, siehe Bild 7.16. D. h. Parameteränderungen oder hin-
zufügen von Körpern wird während der Modellierung angezeigt. Hierzu ist das Fenster durch
Update Diagram im Simulink-Edit-Menü (oder Ctrl+D) oder mit dem zugehörigen Button in der
Menüleiste des Modell- bzw. Visualisierungsfensters u. a. nach Bild 7.16 zu öffnen und nach
jeder Komponenten- und Parameteränderung zu aktualisieren. Diese Art der Vorgehensweise ist
eine gute Kontrolle der parallel laufenden Modellierung insbesondere bei komplexen Modellen.
Es können eine oder beide Visualisierungsmöglichkeiten gleichzeitig ausgewählt werden. Ent-
scheidet man sich nur für die Animation, dann wird das Visualisierungsfenster bei Simulations-
start automatisch geöffnet. Die Animation erhöht die Rechenzeit erheblich.
Weitere Visualisierungseigenschaften einschließlich des Simulationsstarts sind in der Menü-
Leiste des Visualisierungsfensters, wie in Bild 7.16, zu finden. Dazu gehört auch die Abbildungs-
art der Körper. Hier wird zwischen
• Equivalent ellipsoids basierend auf der Masseeigenschaft und der Schwerpunktslage (Träg-
heitsellipsoid)
• Convex hulls basierend auf den Körperkoordinaten (CSs) – vgl. Body Dialog-Box
unterschieden. Die Darstellung des Trägheitsellipsoids mit dem Hauptträgheitsmoment des Kör-
pers sowie den Trägheitsradien als Hauptachsen ist nur bei angenähert gleichen Größenord-
nungen der Trägheitsmomente aller Körper der Maschine übersichtlich. Unter Convex hulls
Abbildungen werden die vorgegebenen körperfesten Punkte (CS1, CS2,...) als 2D- bzw. 3D-
Abbildungen – Flächen, Volumen – markiert und untereinander verbunden. Dadurch entstehen
ausgefüllte Flächenmodelle, die alle Körperpunkte umschließen. In Bild 7.16 ist das Robotermo-
dell aus Bild 7.6 in der Ellipsoid-Abbildungen dargestellt. Zusätzlich lassen sich u. a. Schwer-
punkte und Koordinatensysteme ein- und ausblenden.
Darüber hinaus kann die Animation im AVI-Format abgespeichert und somit von MATLAB
unabhängig vorgeführt werden. Eine realistischere Wiedergabe der Körper ist mit der Virtual
Reality Toolbox erreichbar. Beliebige virtuelle Welten können geschaffen werden.
7.1.6 Einige mathematische Aspekte

Wir wollen auf einige grundlegende Aspekte zur numerischen Behandlung von mechanischen
Mehrkörperproblemen im Zusammenhang mit SimMechanics insbesondere bezüglich der einzu-
stellenden Parameter eingehen. Einen vollständigeren Überblick mit den umgesetzten mathema-
tischen Methoden ist in [68] und in der dort aufgeführten Literatur zu finden.
Einige Probleme und Erfahrungen haben wir bereits in Abschn. 5.4 kennen gelernt. Danach er-
gaben sich für ein mechanisches Mehrkörpermodell differenzial-algebraische Gleichungen vom
Index 3, die Bindungsgleichungen bzw. Nebenbedingungen beruhen dabei auf Lageebene. Wei-
terhin wurde dort erwähnt, dass unter Simulink außer gewöhnlichen Differenzialgleichungen nur
eine spezielle Klasse differenzial-algebraischer Gleichungen vom Index 1 und somit Mehrkör-
permodelle in der Regel nicht direkt lösbar sind. Die erforderliche Index-Reduktion erfolgt nach
den in Abschn. 5.4 angegeben Methoden durch Differenziation der Bindungsgleichungen nach
der Zeit. Der damit eingehandelte Drift-Effekt und eine diesbezügliche Stabilisierung spielen
auch hier eine wesentliche Rolle.
Ein mechanisches Mehrkörpermodell besteht aus mehreren massebehafteten starren Körpern,
die durch masselose Kraftelemente (Feder, Dämpfer oder Stellmotoren) und durch masselose
starre Verbindungen (Gelenke, Koppelstangen) miteinander verbunden sind. Grundsätzlich wird
zwischen zwei topologischen Typen unterschieden und zwar der Baumstruktur, einem System
aus offenen Schleifen und solchen mit geschlossenen Schleifen, vgl. [6], [15], [29], [68].
Unabhängig von der Herleitung können beide Fälle u. a. nach [68] durch die Bewegungsglei-
chung in Deskriptorform
q̇q = H̃
Hv
T
M (qq)v̇v = f (t, q , v ) + H̃
H (qq)G λ
GT (t, q )λ (7.6)
0 = g (t, q )
formuliert werden, siehe auch Abschn. 5.4. Dabei ist der kinematische Zusammenhang zwischen
der zeitlichen Ableitung der Struktur- bzw. Konfigurationsvariablen q̇q und der Geschwindigkeits-
variablen v durch (7.6)1 hergestellt. In vielen Anwendungen ist H̃H die Einheitsmatrix, so dass
(7.6)1 eine Identität darstellt. Dies kennen wir von der Erzeugung der Standardform zur Inte-
gration gewöhnlicher Differenzialgleichungen. Die Differenzialgleichung (7.6)2 beschreibt die
Dynamik des Systems. M ist die positiv-definite Massenmatrix, f der Vektor der Zentrifugal-
und Coriolis-Kräfte/Momente einschließlich der äußeren Anregungen. Der letzte Term auf der
rechten Seite von (7.6)2 enthält die Anteile der Reaktionskräfte infolge der Kinematik. λ re-
präsentiert den Vektor der L AGRANGEschen Multiplikatoren. Schließlich beschreiben (7.6)3 die
kinematischen Bindungen, die die Bewegung einschränken. Die explizite Zeitabhängigkeit von
g erlaubt z. B. die Einarbeitung zeitabhängiger Antriebselemente.
Die Struktur insbesondere von M und g hängen im hohen Maße von der Koordinatenwahl ab.
Viele kommerzielle Software-Pakete für Mehrkörpersysteme (u. a. ADAMS) benutzen eine For-
mulierung in Absolutkoordinaten. D. h. jeder Körper des Systems hat zunächst sechs Freiheitsgra-
de. Die Einschränkung der Bewegung, z. B. infolge von Gelenken, wird durch die zugehörigen
Bindungsgleichungen festgeschrieben. Das Ergebnis ist ein System mit vielen Strukturvariablen.
Redundanzen in den Koordinaten werden durch einfach aufgebaute Bindungsgleichungen be-
rücksichtigt. Man erhält ein großes System von differenzial-algebraischen Gleichungen mit einer
spärlich besetzten Massenmatrix (Sparse-Matrix). Diese Sparse-Besetzung und der einheitliche
Aufbau der Bewegungsgleichung wird softwareseitig konsequent ausgenutzt. In SimMechanics
wird diese Strategie nicht verfolgt. Man benutzt eine Formulierung mit Relativkoordinaten. Da-
durch werden weit weniger Konfigurationsvariablen und Bindungsgleichungen benötigt. Nach-

teilig ist die dicht besetzte Massenmatrix und die komplexer aufgebauten Bindungsgleichungen.
Wie schon erwähnt, werden in SimMechanics geschlossene Schleifenstrukturen durch Auf-
schneiden geeigneter Gelenke in solche mit offener Schleifenstruktur überführt, was zusätzliche
Schließbedingungen erfordert, so dass sich mathematisch wieder das Verhalten des Ausgangsys-
tems ergibt. Dies kann automatisch oder über den User erfolgen.
In jedem Falle liegt ein Index-3-Problem vor, welches für eine Behandlung unter Simulink
zunächst auf ein gewöhnliches Differenzialgleichungssystem zurückzuführen ist. Wie in Ab-
schn. 5.4 gezeigt, werden hierzu die Bindungsgleichungen mehrfach nach der Zeit differenziert.
Den weiteren Ablauf kann man in zwei Schritte unterteilen. In dem ersten Schritt wird für
(7.6) ein explizites Differenzialgleichungssystem aufgestellt. Hierzu existieren unterschiedliche
Methoden, die meisten von ihnen sind rekursive Verfahren. Wird die spezielle Struktur der me-
chanischen Gleichungen, insbesondere die der Massenmatrix M , ausgenutzt, dann wird durch
so genannte Order n-Formalismen ein Rechenaufwand erreicht, der nur linear mit der Anzahl
n der Körper im System steigt. Anderenfalls würde der Aufwand wie n3 anwachsen; vgl. [68].
Im zweiten Schritt wird dann die Integration des expliziten Differenzialgleichungssystem zur
Bestimmung der Gelenk-Trajektorien durchgeführt.
Probleme ergeben sich, wenn der Mechanismus sich in einer nahezu singulären Konfiguration
befindet, d. h. Bindungen sind nicht mehr unabhängig voneinander und die Lösung λ somit nicht
mehr eindeutig, es gibt numerische Probleme. Aus diesem Grunde kann der User zwischen zwei
numerischen Methoden im Machine Environment Block auf der Seite Constraint auswählen. Die
üblicherweise eingestellte Methode (default, Feld ist nicht markiert) basiert auf der C HOLESKY-
Zerlegung, die alternativ auszuwählende auf der QR-Zerlegung. Die erste Methode ist im Allge-
meinen schneller, die zweite robuster bei Singularitäten. Sie sollte nur ausgewählt werden, wenn
die C HOLESKY-Zerlegung nicht zum Ziel führt.
Ein weiteres Problem ist der durch die Vorgehensweise verursachte Drift-Effekt, siehe
Bild 5.19, der auch schon in Abschn. 5.4 untersucht wurde. Unter SimMechanics kann zur Unter-
drückung dieses Effektes eine Stabilisierung nach [5] durch hinzufügen stabilisierender Terme
wie in (5.69) und eine Koordinaten-Projektion (coordinate projection) im Environment Block aus-
gewählt werden. Bei der Projektionsmethode wird nach jedem Integrationsschritt die numerische
Lösung auf die Bindungen in Lage- und Geschwindigkeitsebene zurückprojiziert, wodurch diese
im Rahmen einer vorgegebenen Toleranz verbessert werden kann. Die Stabilisierungs-Methode
ist schneller und ab Version 2 somit für eine Echtzeitverarbeitung geeignet, sie verfälscht al-
lerdings die Dynamik des Ausgangssystems. Die Koordinatenprojektion ist, entsprechend einer
vorgegebenen Toleranz, genauer.
Für die Simulation (Vorwärtsdynamik) ist also unter SimMechanics, im Gegensatz zu Simsca-
pe, die Bewegungsgleichung (7.6) in ein explizites, gewöhnliches Differenzialgleichungssystem
zu überführen und mit einem gewählten Integrator zu lösen. Im Falle der inversen Dynamik
gestaltet sich die Aufgabe erheblich einfacher. Ausgehend von einer festgelegten Bewegung
(Position, Geschwindigkeit und Beschleunigung) sind die zugeordneten Reaktionen (Gelenk-
Kräfte/Momente) zu ermitteln. Dies führt auf ein algebraisches Problem.
Ereignisse in Form von Unstetigkeiten, wie in Abschn. 5.6 behandelt, lassen sich unter Sim-
Mechanics unmittelbar nur im Rahmen des Joint Stiction Actuator bearbeiten. Die Modellierung
als Simulink-Modell auch unter Einbezug des Stateflow Tools gilt weiterhin uneingeschränkt.
7.2 Anwendungen und Ausblick 353
7.2 Anwendungen und Ausblick

In Abschn. 8.4 sind Modellierungen zum Hebelmechanismus einer Pkw-Klimaanlage und in Ab-
schn. 8.5 zum Dreifachpendel nachzulesen. Darüber hinaus wird mit Dreh_SimMech.mdl
in [52] ein Drehschwinger modelliert. Die Ergebnisse sind denen einer konventionellen Me-
thode auf der Basis von Bewegungsgleichungen gegenübergestellt. Mit dem SimMechanics-
Modell reib_12sm aus [52] kann der Schwinger mit einem Reibkontakt nach Bild 5.35 aus
Abschn. 5.6.5 simuliert werden. In jedem Fall erwies sich das SimMechanics Tool und damit
alle anfangs erwähnten physikalischen Modellierungen als sehr sinnvolle Ergänzungen und Al-
ternativen für komplexere Modelle mittleren Ausmaßes, insbesondere im Zusammenhang mit
regelungstechnischen Komponenten.
Abschließend wollen wir an das Modell des Zweimassenschwingers mit zwei Reibkontakten
aus Abschn. 5.6.5.3 anknüpfen und hierfür ein SimMechanics Modell erstellen. Die skriptorien-
tierte Realisierung mit reib_34.m aus [52] stellte sich als sehr anspruchsvoll heraus. Nutzt
man die Bemerkungen zum Joint Stiction Actuator in Abschn. 7.1.4, dann bereitet die Modellie-
rung nach Bild 7.17 des Block-Modells reib_34sm.mdl aus [52] keine Probleme.
Bild 7.17: Modell zum Reibschwinger aus Abschn. 5.6.5.3 mit zwei Reibkontakten
Numerische Ergebnisse
Wir führen Simulationen zu den Beispielen 3 und 4 mit den Parametern nach Tabelle 5.9 durch.
Für Beispiel 3 betrachten wir ausgehend von den Anfangswerten
x1 (0) = 0, x2 (0) = 0, ẋ1 (0) = 0,1, ẋ2 (0) = −0,1
den Einschwingvorgang für 0 ≤ t ≤ 16. Die Ergebnisse sind in Bild 7.18 dargestellt. Gegenüber
dem Modell mit einem Reibkontakt nach Abschn. 5.6.5 ist die jetzige Situation wesentlich viel-
fältiger. Es existieren in kurzen Zeitintervallen mehrere Ereignispunkte, welche insbesondere in
den Beschleunigungsverläufen zum Ausdruck kommen. Dem Beispiel 4 liegen die Anfangswerte
x1 (0) = 0,4525400968668081, x2 (0) = 0,4756654765658993

Bild 7.18: Beispiel 3: Einschwingvorgang des Zwei-Massen-Reibschwingers mit zwei Reibkontakten
4 40
m2 m2
2 20
2
m1
xpp , xpp
xp1, xp2
0 0
1
−2 m1 −20
−4 −40
−0.4 −0.2 0 0.2 0.4 0.6 −4 −2 0 2 4
x1, x2 xp1, xp2
Bild 7.19: Beispiel 4: Phasendiagramme der periodische Schwingungen des Zwei-Massen-

Reibschwingers mit zwei Reibkontakten
ẋ1 (0) = 1,671443845733659, ẋ2 (0) = 1,671443845733659 ,
die einer periodischen Schwingung genügen, zugrunde. Die Schwingungen mit der Perioden-
dauer T = 1 s sind als Phasenkurven ẋ j (x j ) sowie ẍ j (ẋ j ) in Bild 7.19 dargestellt. Einerseits
treten die bereits erwähnten Knicke in den Geschwindigkeitsverläufen, andererseits die Sprünge
in den Beschleunigungsverläufen auf. Die Ergebnisse entsprechen denen aus Abschn. 5.6.5.3 mit
reib_34.m.
8 Projekte
Anhand von acht Projekten ausgewählter Modelle wollen wir die bisherigen Grundlagen und
deren Anwendung vertiefen. Jedes Projekt beginnt mit einer Aufgabenstellung, der einige mo-
dellspezifische Aufbereitungen folgen. Darauf aufbauend wird es möglich, einzelne/alle Projekt-
punkte selbstständig zu erarbeiten oder dem hier eingeschlagenen Lösungsweg zu folgen. Dieser
beinhaltet die erforderlichen theoretischen Grundlagen sowie wesentliche programmtechnische
Umsetzungen. Aus Platzgründen beschränken wir uns bei drei Projekten hier auf die Vorstellung
des Projektes und auf die Aufgabenstellung. Die vollständigen Ausarbeitungen sind bei Interes-
se in der Programmsammlung zu Kap. 8 unter www.viewegteubner.de auf der Homepage
zum Buch [52] zu finden. Aus gleichem Grund können nur einzelne Programmausschnitte abge-
druckt werden, die vollständigen Programme stehen an gleicher Stelle wie oben zur Verfügung.
Damit können alle Berechnungen nachempfunden werden. Eigenständige Parameterstudien oh-
ne/mit Änderungen/Verbesserungen sind durchführbar. Einzelne Programmteile lassen sich in
eigene Projekte übernehmen oder regen zur Programmierung vorliegender Probleme an.
Die Zuordnung der Programme und schlagwortartige Inhaltsangaben werden stets in den Kopf-
zeilen zum jeweiligen Projekt angegeben. Damit kann gezielt speziellem Interesse nachgegangen
werden.
8.1 Permanentmagnet gelagerter Rotor
Schlagworte: Simulink-Modelle, Modellbeschreibung, instabile Strecke, Spulenmodell, aktive Sta-

bilisierung, unstetiges Anschlagmodell, Reglerauslegung, Reglerumschaltung
Programme: Mag_Rotpd.mdl, Mag_Rotpidy.mdl, Mag_Rotpidi.mdl, Mag_Rotpidsub.mdl,
Mag_RotD.m, Mag_RotG.m, Mag_Rotpidya.mdl, Mag_pidyb.mdl
Bild 8.1: Modell der Rotorlagerung und der Leistungselektronik

DOI 10.1007/978-3-8348-8630-9_8,
356 8 Projekte
Für das Modell des magnetisch gelagerten Rotors mit permanentmagnetischer Radiallagerung
nach Bild 8.1 soll eine aktive Stabilisierung der Axialbewegung entworfen und das Schwingungs-
verhalten insbesondere beim Abhebevorgang aus der oberen bzw. unteren Lagerbegrenzung unter
Simulink simuliert werden. Auf der Basis der in Abschn. 8.1.1-Abschn. 8.1.4 vorgestellten Sys-
tembeschreibung und Modellierung zur Axialbewegung mit elastischer Lagerbegrenzung sowie
der aktiven Ablenkspule mit idealem Verstärker sind folgende Punkte zu bearbeiten:
1. Aufbauend auf dem vorgestellten Streckenmodell ist ein Zustandsregler-Entwurf, d. h. mit
vollständiger Rückführung von y = (y, ẏ, i)T mittels Polvorgabe und LQ-Algorithmus vor-
zunehmen. Für die Systemparameter und die Reglerauslegung ist ein M-File anzulegen.
2. Entwurf des Simulink-Modells bezüglich des Rotors und des Spulensystems sowie des Reg-
lers in Form eines Subsystems. Simulieren Sie Abhebevorgänge, wenn der stehende Rotor
sich in der unteren bzw. oberen Lagerbegrenzung befindet. Anhaltswert: 0 ≤ t ≤ 100 ms.
3. Reglererweiterung: Berücksichtigen Sie einen I-Anteils mittels Polvorgabe, wobei die Ei-
genwerte aus 1. enthalten sein sollen. Der I-Anteil soll sich einerseits auf die Auslenkung y,
andererseits auf den Strom i beziehen.
4. Erstellen Sie auf der Basis des zuvor erstellten Simulink-Modells eines mit Reglerumschal-
tung, so dass zunächst ein Abhebevorgang mit einem Regler, der den I-Anteil bezüglich
y enthält, erfolgen kann und nach 125 ms auf einen Regler, der den I-Anteil bezüglich
des Stromes i enthält, umgeschaltet wird. Diese Umschaltung ist einerseits mit dem Switch
Block, andererseits mit schaltbaren Subsystem-Blöcken zu realisieren.
5. Entwurf eines Reglers mit Approximation der zeitlichen Ableitung der Rotorauslenkung y.
Masse m 4,6 kg
O HMscher Widerstand R 3,4 Ohm
Induktivität L 26,875 mH
Strom-Kraftkoeffizient kM 32,23 N/A
Proportionalverstärkung der Leistungsstufe kI 6,255
Permanentmagnetsteifigkeit k pm 1,25 106 N/m
Lagerkontaktsteifigkeit kw 43,77 106 N/m
Lagerspiel ymax 124 10−6 m
8.1.1 Systembeschreibung
Zunächst stellen wir das Lagerprinzip eines radial permanentmagnetisch (passiv) und axial elek-
tromagnetisch (aktiv) gelagerten Rotors nach Bild 8.1 stichwortartig vor.
Wählen wir für die gegenüberliegenden Permanentmagnetringe des oberen und unteren La-
gers ungleichnamige Magnetpole, dann entsteht eine anziehende Axialkraft; der Rotor legt sich
je nach anfänglicher axialer Störung oben oder unten an die Lagerbegrenzung an. Dabei nimmt
die anziehende Kraft mit enger werdendem Spalt zu. Im Gegensatz zu dieser destabilisierenden
Kraft kommt es bei einer radialen Rotorauslenkung zu einer stabilisierenden Kraftkomponente
(passives stabiles Gleichgewicht). In Richtung des Flusses bedarf es also einer aktiven Stabilisie-
rung der Axialbewegung.
8.1 Permanentmagnet gelagerter Rotor 357
Turbomolekularpumpe
(Schnittdarstellung)
Bild 8.2: Magnetisch gelagerter Rotor einer Turbomolekularpumpe; Leybold, Köln
Die aktive Stabilisierung erreicht man dadurch, dass dem Fluss der Permanentmagnete ein in
Abhängigkeit von der Rotorauslenkung y und dem Spulenstrom i geregelter Fluss eines elektri-
schen Spulensystems überlagert wird, so dass die in Flussrichtung wirkende Kraft mit zunehmen-
der Spaltweite nicht mehr abnimmt sondern ansteigt. Um dies zu erreichen, sind die obere und
untere Spule in Bild 8.1 hintereinander geschaltet, so dass in Abhängigkeit von der Stromrichtung
z. B. im oberen Lager eine Verstärkung und im unteren Lager eine Abschwächung der Flussdich-
te und somit eine resultierende Kraft in Richtung von y erzeugt wird. Bei entgegengesetztem
Stromfluss dreht sich die Kraftrichtung um. Eine Stabilisierung erreichen wir somit durch eine
gezielte Ansteuerung der Schalter des Leistungsteils in Bild 8.1. Der Lastkreis, d. h. die Spulen,
werden abwechselnd an die Spannung uM = ±UM gelegt. Der Mittelwert der Spannung ūM wird
durch das Verhältnis der Einschaltdauer der Schalterpaare, d. h. das Pulsweiten-Verhältnis der
am Lastkreis liegenden Rechteckspannung, gesteuert. Dies kann mit Hardware-PWMs sowie mit
Mikrokontrollern oder speziellen Signalprozessoren realisiert werden.
8.1.2 Rotor- und Magnetmodellierung

Die Rotorauslenkung y(t) betrachten wir aus der Spaltmitte, die gleichzeitig der Kraftmittelpunkt
der Magnetanordnung sein soll. Die destabilisierende Permanetmagnetkraft sei linear abhängig
von y und somit über die Federsteifigkeit k pm zu beschreiben. Die Axiallagerbegrenzung sei
elastisch mit der Steifigkeit kw . Die Kraftverhältnisse aus Permanentmagnetlagerkraft und Lager-
begrenzung sind in Bild 8.3 veranschaulicht. Die Kräfte der Schwebe- und Lagerkontaktphase
lassen sich dann wie folgt formulieren:

−k pm y für − ymax < y < ymax Schweben
f (y) = . (8.1)
−k pm y + kw (y − ymax sign y) für − ymax ≥ y ≥ ymax Kontakt
Für die Magnetspulen wählen wir das einfache Modell nach Bild 8.4 aus O HMschem Widerstand
R sowie weg- und frequenzunabhängiger Induktivität L (L=const.). Die axialen Kräfte der sym-
metrischen Rotoraufhängung lassen sich aus der Differenz der Felddrücke an den Rotorenden
berechnen. Damit lauten die Bewegungsgleichungen des Rotors vom Gewicht mg sowie des Spu-
lenmodells
358 8 Projekte
Bild 8.3: Destabilisierende Lagerkräfte und Kontaktkräfte
mÿ + f (y) = −kM i − mg

(8.2)
L(i)˙+ Ri = uM .
Die stromdurchflossenen Spulen erzeugen die auf den Rotor wirkende Kraft kM i, die Permanent-
magnete die Kraft k pm y nach (8.1). Unberücksichtigt blieben bei der Modellierung: Kopplung
zwischen Radial- und Axialbewegung, weg- und frequenzabhängige Spuleninduktivität, Spulen-
kapazität, Nichtlinearität der Permanentmagnete, Dynamik der Sensorkreise, Filter zur Signal-
glättung (u. a. RC-Filter für uM -Glättung) usw.
Bild 8.4: Spulenmodell
8.1.3 Die aktive Stabilisierung, Reglerstrukturen

Für die Stabilisierung des aus einer mechanischen und elektromagnetischen Teilstruktur zusam-
mengesetzten Systems bieten sich die in Bild 8.5 angegebenen beiden Reglerstrukturen an. Wir
wollen sie kurz besprechen. Die Rotorlage und der Strom werden messtechnisch erfasst, die Sens-
ordynamik bleibt aber unberücksichtigt; die Verstärkungen setzen wir zu eins. Der Kaskadenreg-
ler, Bild 8.5 oben besteht aus dem Lageregler (iy ) und dem internen Rückkopplungsregler (innere
Regelschleife, Hilfsregler), dem Stromregler (ui ). Der Lageregler berechnet den zur Rotorstabi-
lisierung erforderlichen Strom iy . Die innere Regelschleife regelt diesen Strom und steuert die
Leistungselektronik, um die erforderliche Spannung für die Magnete zu erzeugen; kurz Strom-
regler. Man spricht auch von einem stromgesteuerten System, wobei der Stromregler wesentlich
schneller als der Lageregler ausgelegt werden muss. Dieser Reglertyp ist in der Industrie insbe-
sondere wegen seiner geringen Störempfindlichkeit und der guten Einstellmöglichkeit (Tuning)
sehr verbreitet.
Bild 8.5: Zwei Reglerstrukturen
Bei der zweiten Regelstrategie, dem Ausgangsgrößenregler nach Bild 8.5 unten, erfolgt die
Stabilisierung über ein einziges Stellgesetz u. Es kann die Form eines PD, PID oder Zustands-
reglers mit/ohne I-Anteil haben. Dabei gehen wir davon aus, dass die zeitliche Ableitung von y
bzw. ys durch einen Differenzierer oder Beobachter rekonstruiert oder sogar gemessen wird. Man
spricht von einem spannungsgesteuerten System.
8.1.4 Das kontinuierliche Modell
Wir werden hier den zweiten Reglertyp zugrunde legen. Darüber hinaus ersetzen wir die Leis-
tungsstufe durch einen idealen Leistungverstärker. D. h. wir ersetzen den entsprechenden Block
in Bild 8.5 unten durch ein Proportionalglied mit dem Proportionalfaktor kI , so dass
uM = kI u . (8.3)
Der Verstärkungsfaktor der Leistungsstufe ist nach Tabelle 8.1 kI = 6,255.
Mit diesen idealisierten Modellkomponenten wollen wir mittels Zustandsregler ohne/mit I-Anteil
(auch kurz nach seinem Verhalten PD/PID-Regler genannt) eine aktive axiale Rotorstabilisierung
erreichen. Dabei sind drei ausgezeichnete Betriebszustände mit den stationären Gleichgewichts-
zuständen für t → ∞
y(∞)
= 0 ∧ i(∞)
= 0, y(∞) → 0 ∧ i(∞)
= 0 bzw. y(∞)
= 0 ∧ i(∞) → 0
360 8 Projekte
realisierbar. Dies erreichen wir mit den Stellgesetzen
1. y(∞) ∧ i(∞)
= 0 : u = −k p y − kd ẏ − k pi i
$
2. y(∞) → 0 : uy = −k p y − kd ẏ − ki y dt − k pi i (8.4)
$
3. i(∞) → 0 : ui = −k p y − kd ẏ − kii i dt − k pi i.
8.1.5 Reglerentwürfe
8.1.5.1 Zustandsregler
Wir wollen zunächst nur den Fall y(∞) ∧ i(∞)

= 0 verfolgen. Basis des Entwurfes ist somit eine
vollständige Zustandsrückführung ohne integralem Anteil. Hierfür gilt die Zustandsgleichung
(ohne Führungsgröße)
⎡ ⎤ ⎡ ⎤⎡ ⎤ ⎡ ⎤ ⎡ ⎤
ẏ 0 1 0 y 0 0
⎢ ⎥ ⎢ k ⎥⎢ ⎥ ⎢ ⎥ ⎢ ⎥
⎣ ÿ ⎦ = ⎣ mpm 0 − kmM ⎦ ⎣ ẏ ⎦ + ⎣ 0 ⎦ u + ⎣ m1 ⎦ ( fw − mg) (8.5)
(i)˙ 0 0 −L R i kI
L
0
⎡ ⎤ ⎡ ⎤⎡ ⎤
ys ksy 0 0 y
⎣ ẏs ⎦ = ⎣ 0 ksy 0 ⎦ ⎣ ẏ ⎦ (8.6)
is 0 0 ksi i
mit der Lagerkontaktkraft nach (8.1)
fw (y) = kw (y − ymax sign(y)) für − ymax ≥ y ≥ ymax .
oder kurz
żz = A z +B
B u +V
Vv
(8.7)
y = C z.
Einfachheitshalber setzen wir weiterhin in (8.6) die Sensorverstärkungen ksy , ksi zu 1. Das Stell-
gesetz lautet:
u = −K
K zz, (8.8)
wobei der Reglerentwurf sich auf die ungestörte (v = 0) Bewegungsgleichung (8.7) bezieht. Voll-
ständige Steuer- und Beobachtbarkeit folgt aus der Anschauung. Einen numerischen Nachweis
erhalten wir über den Rang der Steuerbarkeitsmatrix Co bzw. Beobachtbarkeitsmatrix Ob
Co=rank(ctrb(A,B)); Ob=rank(obsv(A,C)); MATLAB-Aufruf.
Aus der Vielzahl der Regler-Entwurfsmethoden wollen wir drei aus der Control System Tool-
box heranziehen, die auf zwei unterschiedlichen Bewertungen basieren. Auf die Algorithmen
können wir dabei nicht näher eingehen; vgl. [1], [29], [39], [40]. Wir beschränken uns auf die
Function-Aufrufe:
• Polvorgabe (Polzuweisung, pole placement):
K = place(A, B, p)
Die Routine aus [34] errechnet die Regler-Matrix K für (8.8), so dass die Eigenwerte von
(A
A − BK
BK) denen von p entsprechen. In Bezug auf einen erforderlichen P- und D-Anteil sind
die Eigenwerte in p zu wählen; z. B.
√
p = (−520 + i 20; −520 − i 20; −750)T , i = −1 .
Alternativ kann für Single-Input-Systeme der Algorithmus von ACKERMANN [1] genutzt
werden
K = acker(A, B, p)
• Optimaler Zustandsregler (LQ-Regelung, R ICCATI-Regler, Linear Quadratic Regulator):

Der Reglerentwurf wird mit Hilfe eines integralen Gütekriteriums (cost functional, perfor-
mance index)
$
J= (zzTQ z +uuTR u + 2 zTN uu)dt (allgemein)
mit zu wählenden Bewertungsmatrizen Q, R, N ausgeführt. Dieser Entwurf bewertet also

die Stell- und Reglergrößen kontinuierlich über das gesamte Zeitintervall bezüglich z und u .
Die Bewertungsmatrizen werden praktisch als Diagonalmatrizen angesetzt. Der MATLAB-
Aufruf lautet
[K, S, E] = lqr(A, B, Q, R, N);
vgl. auch lqr2, lqry, dlqr (zeitdiskret). Ausgang der Routine ist die Reglermatrix K , die
Lösung S = S T der R ICCATI-Gleichung – vgl. [29], [40] und Online-Hilfe – und die Eigen-
werte E des geschlossenen Kreises.
Der auf (8.7) basierenden Programm-Code – Ausschnitt des Datenfiles Mag_RotD.m – ge-
ben wir an.
% Reglerauslegung
% I) Zeitkontinuierliche lqr-Auslegung
Q=[.1 0 0 ;0 .1 0 ; 0 0 10]; % Bewertungsmatrizen
RR=1;
N = [0; 0; 0];
[K,S,E] = lqr(A,B,Q,RR,N) % lqr-Algorithmus
% II) Polvorgabe
p=[-520+i*20; -520-i*20; -750]; % Pollagen
[Kp,prec,message] = place(A,B,p) % Algorithm. nach KAUTSKY
Ka=acker(A,B,E) % Algorithm. nach Ackermann
Z. B. liefert der lqr-Algorithmus die Reglermatrix
K = [ -4.2670e+005 -8.1530e+002 7.1625e+000 ]
362 8 Projekte
8.1.5.2 Regler mit Integralanteil
Die Koeffizienten der Integralanteile ki , kii in (8.4) können manuell eingestellt werden, wenn
man die dadurch hervorgerufenen Eigenwertverschiebungen kontrolliert, z. B. durch das Ein-
schwingungsverhalten mittels Simulation. Anhaltswerte: ki = −107 , kii = −500, vgl. Bild 8.7.
Darüber hinaus ist es möglich, mit Hilfe erweiterter Systemmatrizen neue Reglerentwürfe u. a.
per Polvorgabe durchzuführen, wobei die Eigenwerte des PD-Verhaltens übernommen werden.
Dies wollen wir für die Ermittlung des Integralanteils (ki ) bezüglich y, so dass y(∞) → 0, zeigen.
Zunächst ersetzen wir den I-Anteil im Stellgesetz durch
$
Q= y dt , so dass Q̇ = y
mit dem Anfangswert zur Ruhelage des Rotors (oberer bzw. unterer Lageranschlag) aus
! kp
uy (0) = −k p y(0) − ki Q(0) = 0 → Q(0) = − y(0).
ki
Damit liegt für die erweiterte Reglerauslegung ein Differenzialgleichungssystem 4. Ordnung
1
mÿ + f (y) = −kM i − mg, y(0) = (kw ymax sign(y0 ) − mg) , ẏ(0) = 0
kw − k pm
L(i)˙+ Ri = kI uy , i(0) = 0 (8.9)
kp
Q̇ = y, Q(0) = − y0
ki
und das Stellgesetz
uy = −k p y − kd ẏ − ki Q − k pi i, uy (0) = 0 (8.10)
vor. Es hat die Matrizenstruktur
żzy = A y z y +B
By uy +V
Vy v y(∞) → 0
(8.11)
uy = −K K y zy
mit

A 0 B V
Ay = , By = , Vy = , A , B , V nach (8.7)
1 0 0 0 0 0

K y = [ K , ki ] , z Ty = z T , Q
sowie dem Anfangswertvektor
z Ty (0) = [ y(0), 0, 0, −K(1)/ki y(0) ] , K = [ K(1), K(2), . . . ] ,
wobei y(0) = −(mg ± kw ymax )/(kw − k pm ) mit (+) für den Start aus dem unteren und (−) für den
aus dem oberen Lageranschlag eines stehenden Rotorsystems. Den Vektor der bisher angesetzten
Pole p erweitern wir um einen weiteren, z. B.
p := [ppT , −150]T .
Mit (8.11) können wir dann den neuen Reglerentwurf durchführen. Die ursprünglich vorgegebe-
nen Pole p (der rechten Seite) bleiben Teil des geschlossenen Kreises.

Entsprechendes gilt für den stromlosen Betrieb mit Qi = i dt
żzi = A i z i +BBi ui +V
Vi v i(∞) → 0
ui = −K K i zi, ui (0) = 0
mit

A 0 B V
Ai = , Bi = , Vi = , A , B , V nach (8.7)
0 0 1 0 0 0

K i = [ K , kii ] , zTi = zT , Qi .
Aufgrund der Anfangswerte i(0) = 0 und Qi (0) = −k p /kii y(0) kann mit ui der Rotor nicht
aus der Ruhelage in die Lage y(∞)
= 0, i(∞) → 0 gebracht werden. Man startet deshalb z. B. mit
einem Zustandsregler und schaltet nach dem Abheben den I-Anteil hinzu.
8.1.6 Parametrierung und Reglerkoeffizienten
Zweckmäßigerweise fassen wir die Parametrierung sowie den Reglerentwurf in dem M-File
Mag_RotD.m zusammen. Dieses ist in der Programmsammlung [52] zu finden, wir drucken
es hier nicht ab. Über den manuell einzustellenden Steuerparameter ou (oben/unten) sind die An-
fangswerte für einen Start aus der oberen bzw. unteren Lagerbegrenzung auszuwählen. Das File
Mag_RotD.m ist vor dem Simulationsstart auszuführen. Für eine grafische Darstellung unter
MATLAB dient das M-File Mag_RotG.m. Es ist manuell bzw. automatisch nach dem Simulati-
onsvorgang zu starten.
8.1.7 Simulink-Modelle
Die jeweiligen Regler formulieren wir als Subsysteme mit zugehörigen Parameterfenstern. Die
Simulink-Modelle enthalten dann die Modellierung der Strecke nach (8.2) mit (8.3) , vgl. Bild 8.9,
sowie das jeweilige Subsystem eines der Reglerstrategien. In Bild 8.9 ist ein Zustandsregler (kurz:
PD-Regler) realisiert, vgl. Rot_Magpd.mdl. Für einen Betrieb mit Reglerumschaltung sind
die beiden Entwürfe Mag_Rotpidi.mdl und Mag_Rotpidsub.mdl vorgesehen. Im ersten
Modell wird die Reglerumschaltung mit dem Switch Block, vgl. Bild 8.10, erreicht, im zwei-
ten Modell wird mit schaltbaren Subsystemen gearbeitet, vgl. [52]. Ist die Geschwindigkeit ẏ
nicht messbar, dann kann versucht werden, diese durch numerisches Differenzieren zu berück-
sichtigen. Dies zeigen die Simulink-Modelle Mag_Rotpidya.mdl und Mag_pidyb.mdl der
Programmsammlung [52].
364 8 Projekte
8.1.8 Simulationsergebnisse
Bild 8.6 zeigt zwei Abhebevorgänge mittels PD-Regler jeweils aus der oberen bzw. unteren La-
gerbegrenzung. In beiden Fällen löst sich der Rotor unmittelbar nach Stellgrößenaufschaltung.
Dabei ist der Stromanstieg beträchtlich. Der Strom steigt in 1 ms auf nahezu 5 A und stellt sich
im eingeschwungenen Zustand auf ≈ -5 A ein. Die Rotorendlage y(∞) befindet sich in unmittel-
barer Nähe der Lagerbegrenzung. Diese ungünstige Endlage und der damit zusammenhängende
hohe Dauerstrom von -5 A machen diesen Entwurf zunichte. Mit einem höheren P-Anteil (höhe-
re Steifigkeit) ließe sich der stationäre Zustand verbessern. Nachteilig wird sich aber der noch
höhere Stromanstieg beim Abhebevorgang auswirken. Einerseits durch die Taktung der Endstufe
und andererseits durch die realen Komponenten, u. a. der Spule, ist dies nicht mehr zu erreichen.
Die Auswirkung eines zusätzlichen I-Anteils ist in Bild 8.7 dargestellt, wobei sich dieser zu-
nächst auf y und nach 125 ms auf i bezieht. Dadurch behält der Rotor in der Abhebephase länger
Lagerbegrenzungskontakt, der Strom steigt in dieser Phase linear mit der Zeit bis auf den Abhe-
bestrom an. Daran schließt sich der Einschwingvorgang auf die stationären Werte mit y → 0 an.
Zum Zeitpunkt t = 125 ms wird auf die Stellgröße eines Regelgesetzes mit Kompensation des
Stromes umgeschaltet, wobei die Anfangswerte der Stellgröße nicht an die vorangegangene Situa-
tion angepasst wurden. Dadurch entsteht ein deutliches Überschwingen bevor der neue stationäre
Zustand mit i → 0 angenommen wird. Der Rotor wird also unabhängig von einer statischen Last
nahezu leistungsfrei in seiner Position gehalten. Frage: In welche Richtung y bewegt sich der
Rotor, wenn in Richtung der Gravitationskraft eine zusätzliche konstante Last aufgebracht wird?
Bild 8.6: Abhebeverhalten aus oberer und unterer Lage mit PD-Regler
8.2 Störgrößenkompensation harmonischer und konstanter Störungen
Schlagworte: Simulink-Modell, S-Function, M-File, vektorisierter Code, Beobachter-, Regler-

entwurf, Zustandsmodell, analytische Lösung, freie und erzwungene Schwingungen, Eigenwerte,
anstückeln von Lösungen
Programme: St_Beob_M.m, St_Beob_Mkonst.m, St_Beob_s.mdl, St_Beob_sD.m, St_Beob_sP.m,
St_Beob_sf.mdl (sf_beob.m)
8.2 Störgrößenkompensation harmonischer und konstanter Störungen 365
Bild 8.7: Abhebeverhalten aus oberer und unterer Lage sowie Umschaltung auf stromlosen Zustand mit
PID-Regler
Bild 8.8: Reglerstrukturen zum Modell mit Reglerumschaltung
Der unwuchtige Motor nach Bild 8.11 läuft mit konstanter Winkelgeschwindigkeit Ω und regt
das Fundament zu Schwingungen an. Über den Stellzylinder (u(t)) sollen diese Vertikal-Schwin-
gungen kompensiert werden. Die Fundamentbewegungen x und ẋ werden gemessen. Für die akti-
ve Kompensation – vgl. [51], [50] – dieser speziellen Störung soll ein Störgrößenbeobachter z. B.
nach [39], [40], [42] eingesetzt werden. Die notwendigen Grundlagen werden kurz dargestellt,
so dass auf dieser Basis folgende Punkte erarbeitet werden können.
1. Erstellen Sie für die Übergabe in die Simulink-Umgebung ein Parameter-File (M-File) mit
den wesentlichen Parametern sowie der Berechnung zum Beobachterentwurf.
2. Für das unbeeinflusste System (u(t) ≡ 0, Strecke) ist das Simulink-Modell zu entwerfen und
zu testen.
3. In das gleiche Modellfenster ist der Beobachterentwurf als Subsystem einzubringen und zu
testen.
4. Mit einem Switch Block soll die Störgrößenkompensation über u(t) nach ts =0,2 s aufge-
schaltet werden.
5. Formulieren Sie die Beobachtergleichung einschließlich der Schaltbedingungen in einer M-
File S-Function und erstellen Sie das zugehörige Simulink-Modell.
6. Da Strecke und Beobachter ein lineares System mit konstanten Koeffizienten darstellt, ist ei-
366 8 Projekte
Bild 8.9: Zustandsregler
Bild 8.10: Modell mit Reglerumschaltung auf stromlosen Betrieb

Parameter:
m := m + mu = 100 kg
k = 36 106 N/m
d =10−4 k N s /m
emu = 0,5 m kg
ku
kT = = 20 1/kg
m
Ω = 300 rad/s
q0 12 104 N
Bild 8.11: Unwuchtiger Motor
ne direkte Lösung des Problems mit den Mitteln der linearen Algebra aus Kapitel 3 möglich.
Bringen Sie die zugehörigen Bewegungsgleichungen in eine der Vorgehensweise angepass-
ten Form. Formulieren Sie die Lösungsansätze und die Lösungen. Erstellen Sie für diese
Vorgehensweise ein M-File. Vergleichen Sie die Ergebnisse mit denen aus der Simulink-
Simulation.
7. Diskutieren Sie den Kompensationsvorgang in Verbindung mit den rekonstruierten Sig-
nalen. Beurteilen Sie die Beobachterdynamik und den Einfluss der Systemparameter k, d.
Überprüfen Sie die Parameterempfindlichkeit des Beobachterentwurfs, indem Sie die Fun-
damentfedersteifigkeit k bei der Beobachterauslegung als fehlerbehaftet ansehen.
8. Aufbauend auf der analytischen Vorgehensweise ist eine zusätzliche konstante Störung q0
zuzulassen und mittels eines erweiterten Störgrößenbeobachters ebenfalls zu kompensieren.
8.2.1 Grundlagen zur Strecke und zum Beobachterentwurf

Bewegungsgleichung der Strecke für die Schwingungen um die statische Gleichgewichtslage:
ẍ + 2δ ẋ + ω02 x = kT u(t) + q cos (Ωt + Φ), Φ beliebig (8.12)
mit den Abkürzungen
d k ku mu 2
2δ = ; ω02 = ; kT = ; q= eΩ .
m m m m
Für den Beobachterentwurf muss die Störung w = q cos (Ωt + Φ) durch eine gewöhnliche Dif-
ferenzialgleichung modellierbar sein, d. h. bezogen auf die vorliegende Störung gilt
ẅ + Ω 2 w = 0.
Durch Umordnen bzw. Transformation gewinnen wir die für einen Beobachterentwurf allgemein
gültige Darstellung
w = Pw +Q
ẇ Qy +D
Du(t)
ẏy = Rw +SSy +E
E u(t), y = [y1 , y2 ]T = [x, ẋ]T ,
368 8 Projekte
w und in der zwei-

wobei auf der linken Seite der ersten Gleichung die Ableitung des Störmodells ẇ
ten Gleichung die der Messgröße y steht. Bezogen auf unser Beispiel bedeutet dies ausführlich:
Störmodell

ẇ1 0 1 w1 w1 w
= , mit = , Q = 0, D = 0,
ẇ2 −Ω 2 0 w2 w2 ẇ
mechanisches Modell

ẏ1 0 0 w1 0 1 y1 0
= + + u(t)
ẏ2 1 0 w2 −ω02 −2δ y2 kT
oder kurz
w = Pw ,
ẇ w = [w1 , w2 ]T = [w, ẇ]T
(8.13)
ẏy = Rw +SSy +E
E u(t), y = [y1 , y2 ]T = [x, ẋ]T .
w wird in der Form:

Der Beobachter für die zu rekonstruierende Größe ŵ
v̂v˙ = Lv̂v +My

My +N
N u(t)
(8.14)
w = v̂v +Hy
ŵ Hy rekonstruierte Störung: ŵ1 (t) → q cos (Ωt + Φ) für t → ∞
angesetzt. Dies ist ein dynamisches Modell, für welches zunächst die unbekannten Matrizen L ,
M , N , H und damit die Dynamik zu ermitteln sind. Hierzu formulieren wir den Fehler e , der aus
w Störgröße: e = w − ŵ
der tatsächlichen w und rekonstruierten ŵ w gebildet wird. Die rekonstruierte
w strebt gegen die tatsächliche w , wenn e → 0 möglichst schnell abklingt. Um die
Störgröße ŵ
Dynamik von e zu beurteilen, formulieren wir die Fehlerdifferenzialgleichung und setzen ẇ w˙
w, ŵ
aus (8.13), (8.14) ein:
ėe = ẇ
w − ŵ
w˙
= Le + (PP −L
L −HR
HR w + (LH
HR)w LH −M
M −HS
HS)yy − (N
HS N +HE
HE
HE)u(t).
Forderung nach asymptotischer Stabilität des Fehlers e führt auf die beiden Bedingungen:
1. ėe = Le
Le, e ist asymptotisch stabil, wenn für die Realteile der Eigenwerte ℜ(λk (L
L)) < 0 gilt
2. P −L
L −HR
HR = 0 → L = P −H
HR
LH −MM −H
HS = 0 → M = LH −H HS
N +H
HE = 0 → N = −HHE .
Hierin sind P , R , S , E aus (8.13) bekannt, H , L , M , N unbekannt. Sie müssen die obigen Be-
dingungen erfüllen. Zunächst betrachten wir die Dynamik der Fehlergleichung, womit H und L
ermittelbar sind:
- Koeffizientenmatrix L = P −HR
HR

0 1 h11 h12 0 0 −h12 1
L= − =
−Ω 2 0 h21 h22 1 0 −h22 − Ω 2 0
- charakteristische Gleichung zu ėe = Le mit e = v eλt nach Kapitel 3
L − λII | = λ 2 + h12 λ + h22 + Ω 2 = 0,

det|L I Einheitsmatrix. (8.15)
Zur Festlegung der Dynamik von e geben wir die Pole (Eigenwerte) λ1 , λ2 vor, sie genügen dem
Polynom.
(λ − λ1 )(λ − λ2 ) = λ 2 − (λ1 + λ2 )λ + λ1 λ2 = 0 . (8.16)
Ein Koeffizienten-Vergleich beider Polynome (8.15), (8.16) ergibt
h12 = −λ1 − λ2 , h22 = λ1 λ2 − Ω 2 .
Alternativer Weg zur Ermittlung von H : Wir betrachten das zur Fehlergleichung ėe = Le adjun-
gierte Problem
ėe = L Te = P Te + R T (−H
H Te )
!
= Ae + Bu
Bu, u = −Ke
Ke = − H Te Standardform
und haben damit ein Regelproblem zu lösen. Zur Bestimmung der Reglermatrix H T stehen mit
der Control System Toolbox mehrere Algorithmen zur Verfügung. Wir wählen wieder eine Pol-
vorgabe, z. B. mit zwei reellen Polen
p = [λ1 , λ2 ] = [−100, −300], reelle Eigenwerte.
Hierfür existieren die beiden Function acker.m und place.m. Die erste Function setzt Syste-
me mit einem Eingang voraus, so dass wir mit place.m arbeiten müssen; MATLAB-Aufruf:
H = place(P’, R’, p)’; P T → P’, R T → R’, H → H .
Mit H ist auch L und damit N, M der 2. Bedingung bekannt. Der Störgrößenbeobachter ist ausge-
legt. Die Störgrößenaufschaltung erfolgt schließlich mit
1
u(t) = − ŵ1 (t) .
kT
8.2.2 Parameterfile und Simulink-Modell
Zu 1.-4.: Die Strecke und der Beobachter sind lineare Systeme. Wir wollen die Strecke mit zwei
Integrierer modellieren. Für den Beobachter (8.14)1 wählen wir einen State Space Block. Hierbei
gehen wir von der angepassten Beobachtergleichung
v̂v˙ = Lv̂v +BBv u v (t) State Space ẋ = A x + B u

y v = C v v̂v +D
Dv u v (t) Block y=Cx+Du
mit B v = C v = I 2 × 2 als Einheitsmatrix sowie der 2 × 2-Durchgangsmatrix D v = 0 und dem

Eingangsvektor
u v (t) = My +N
N u(t)
370 8 Projekte
aus. Damit liegt am Ausgang des State Space Blocks der vollständige Beobachtervektor y v = v̂v
an. Die rekonstruierte Größe ŵ1 folgt aus
ŵ1 = [1, 0] [v̂v +H

H yy], → ŵ1 = v̂1 + h12 ẋ,
was aber nicht den Schluss zulässt, dass nur die Messgröße ẋ benötigt wird; beachte My
My. Na-
türlich kann die Rekonstruktion (Schätzung) der Auslenkung x und/oder der Geschwindigkeit ẋ
eingearbeitet werden. Eine diesbezügliche Messung wird damit überflüssig.
Modellgleichungen: Die zur Modellierung benötigten Gleichungen stellen wir zusammen:
- Strecke mit Beeinflussung nach (8.12)
1
ẍ + 2δ ẋ + ω02 x = kT u(t) + q cos (Ωt + Φ), u(t) = − ŵ1 (t) (8.17)
kT
- Beobachter nach (8.14)
v̂v˙ = Lv̂v +My

My +NN u(t)
(8.18)
ŵ1 = [1, 0][v̂v +Hy
Hy
Hy], ŵ1 (t) rekonstruierte Störung.
Ins Parameter-File arbeiten wir neben den Systemparametern der Strecke auch die Polvorgabe
zum Beobachterentwurf sowie die Berechnung der Systemmatrizen ein; vgl. St_Beob_sD.m
in [52]. Da die Parameter vor dem Simulationsstart im Workspace stehen müssen, muss das File
zuvor manuell oder automatisch durch den Eintrag des File-Namens unter dem File-Button →
Modell Properties, Callbacks, Feld: Model initialization function gestar-
tet werden. Die grafische Ausgabe findet teilweise auch unter MATLAB statt. Hierzu dient das
M-File St_Beob_sP.m. Zur automatischen Ausführung tragen wir es, wie das Parameterfile,
jetzt aber in das Feld: Simulation stop function ein.
Das Simulink-Modell St_Beob_s.mdl [52] einschließlich des Beobachter-Subsystems mit
dem Schalter zur Aufschaltung der rekonstruierten Störung kT u(t) = −ŵ1 ist in Bild 8.12 darge-
stellt.
8.2.3 Beobachter über S-Funktion

Zu 5.: Im Simulink-Modell ist nur das Beobachter-Subsystem durch einen S-Function-Block
zu ersetzen, Ein- und Ausgangsgrößen sind identisch. Die Beobachtermatrizen werden weiter-
hin über das Parameterfile St_Beob_sD.m erzeugt, so dass die Beobachtergrößen an den S-
Function-Block übergeben werden können. Das zugehörige Level-1 M-File sf_Beob.m sowie
das Block-Modell St_Beob_sf.mdl sind [52] zu entnehmen.
8.2.4 Analytische Ermittlung der Lösungen

Zu 6., 8.: Das Gesamtmodell aus Strecke (Schwinger) und Beobachter ist ein lineares System
mit konstanten Koeffizienten, so dass sich die Lösungen bezüglich der freien und erzwungenen
Schwingungen mit Kapitel 3 analytisch angeben lassen, siehe auch [17], [21], [22], [28], [44],
[66]. Wegen des Schaltvorganges bei ts =0,2 s, liegt ein System mit einem Zeitereignis vor. In
Bild 8.12: Simulink-Modell mit Subsystem des Beobachters
beiden Zeitabschnitten sind die freien und erzwungenen Schwingungen zu ermitteln und zu über-
lagern. Sie enthalten Integrationskonstanten, die einerseits mit vorgegebenen Anfangswerten und
andererseits mit Übergangsbedingungen in ts , d. h. der Endzustand zum Schaltzeitpunkt ts ist An-
fangszustand für den zweiten Zeitabschnitt, zu ermitteln sind. Schließlich sind die Lösungen für
diskrete Zeitpunkte auszuwerten. Die Vorgehensweise ist ein typischer Vertreter der aus der Li-
teratur bekannten Anstückelmethoden [17]. Insbesondere wird gezeigt, wie man durch systema-
tische Vektorisierung einen sehr übersichtlichen, kurzen und mit der analytischen Formulierung
vergleichbaren Code erzeugen kann.
Basis für diese Vorgehensweise ist eine zweckmäßige Zustandsdarstellung für das Gesamtmo-
dell. Das Zustandsmodell der Strecke (8.17) bilden wir mit dem Zustandsvektor y :
ẏy = A m y + b u u(t) + b m cos (Ωt + Φ), y = [x, ẋ]T ,

372 8 Projekte
mit

0 1 0 0
Am = ; bu = ; bm = .
−ω02 −2δ kT q
Für das Gesamtsystem ist die Beochtergleichung (8.18)1 noch hinzuzufügen:

ẏy Am 0 y bu bm
= + u(t) + cos (Ωt + Φ).
v̂v˙ M L v̂v N 0
Darin gilt mit (8.18)2 wieder die Stellgröße

1 1
u(t) = − ŵ1 = − c Tw [v̂v +Hy
Hy
Hy], c Tw = [1, 0].
kT kT
Setzen wir dies noch ein, dann folgt für den geschlossenen Kreis:
⎛ ⎞

ẏy Am 0 y bu ⎜ 1 T ⎟ bm
= + ⎝− c w (v̂v +Hy
Hy)⎠ +
Hy cos (Ωt + Φ) .
v̂v˙ M L v̂v N kT 0
ŵ1

aufzuschaltender Anteil

A (y T , v̂vT ) = Ax
T
T
Die beiden ersten Terme auf der rechten Seite können wir noch zu A y T , v̂vT zusammenfassen.
Für den Cos-Term der Anregung führen wir die komplexe Relation
1 √
cos (Ωt + Φ) = (ei(Ωt+Φ) + e−i(Ωt+Φ) ), i= −1
2
ein, siehe Abschn. 3.3.2.2, so dass das Gesamtsystem folgende Form erhält:
1 T T
ẋx = Ax + b (eiΦ eiΩt + e−iΦ e−iΩt ), x = y T , v̂vT , b = b Tm , 0 T
2
oder in der für die weitere Betrachtung zweckmäßigen Form
T
1 T iΦ T
ẋx = Ax + ĥh eiΩt + ĥh e−iΩt , ĥh = b e ,0 , (8.19)
2 m

ĥh ist der zu ĥh konjugiert komplexe Vektor. Die letzte Gleichung gilt für beide Zeitabschnitte, wir
formulieren deshalb zunächst die allgemeine Lösung, sie setzt sich aus der freien und erzwunge-
nen Bewegung zusammen, und passen sie später an die beiden Zeitabschnitte an.
Den freien Bewegungen liegt die homogene Gleichung
ẋxh = Ax h
zugrunde. Der Ansatz x h = v eλt führt auf das Eigenwertproblem (λII − A )vv = 0 mit den Eigen-
werten in λ = [λ1 , . . . , λ4 ]T , den Eigenvektoren v , mit denen die Modalmatrix V = (vv1 , . . . , v 4 )
gebildet wird. Das Eigenwertproblem lösen wir numerisch
[V,Lambda]=eig(A); lambda=diag(Lambda); MATLAB
Die freien Schwingungen ergeben sich nach Abschn. 3.2.2.2 damit zu
4
xh = ∑ cj v j eλ j t = V diag(cc) eλ t , c = [c1 , c2 , c3 , c4 ]T ,
j=1
wobei c j die Integrationskonstanten sind.

Für die erzwungenen Schwingungen liegt die inhomogene Differenzialgleichung des obigen
Gesamtsystems (8.19) zugrunde. Das Ergebnis setzt sich nach Abschn. 3.3.2.2 aus zwei partikulä-

ren Teillösungen ξ , ξ entsprechend der beiden Anregungsterme ĥh eiΩt und ĥh e−iΩt zusammen:
x p = ξ +ξξ = 2ℜ(ξξ ) .
Zur Ermittlung von ξ betrachten wir das reduzierte System
ξ̇ξ = Aξ + ĥh eiΩt .
Der Lösungsansatz vom Typ der rechten Seite
ξ = ξ̂ξ eiΩt
führt auf das algebraische Gleichungssystem
(iΩII − A )ξ̂ξ = ĥh → ξ̂ξ = (iΩII − A )−1 ĥh, I Einheitsmatrix,
was wir wiederum numerisch lösen. Die reelle Partikularlösung lautet dann
x p = 2 ℜ(ξ̂ξ eiΩt ) .
Die vollständige Lösung ergibt sich wiederum durch Überlagerung x = x h +xx p zu:
x = V diag(cc) eλ t + 2 ℜ(ξ̂ξ eiΩt ) .
Die Integrationskonstanten sind einerseits mit den Anfangswerten zum Zeitpunkt t0 und anderer-
seits für den Bereich der Kompensation mit den Übergangsbedingungen zum Zeitpunkt ts → t0
zu ermitteln. Gehen wir von einem allgemeinen Zustand zum Zeitpunkt t0 aus, dann gilt für die
Anfangswerte bzw. Übergangsbedingungen x(t0 ) = x0 , so dass
x 0 = V diag(cc) eλ t0 + 2 ℜ(ξ̂ξ eiΩt0 ), t0 = 0, bzw. t0 = 0,2s .
Damit sind die Integrationskonstanten ermittelbar:
c = eλ t0 .\ (V
V $xx0 − 2ℜ(ξ̂ξ eiΩt0 ))) teilweise MATLAB-Schreibweise (Punktop. .$!
374 8 Projekte
Zur grafischen Auswertung legen wir für jeden Zeitabschnitt einen Zeit-Vektor t T aus diskreten
Zeitpunkten an. Damit lautet die Lösungsmatrix
x (tt T ) = V diag(cc) eλt + 2ℜ(ξ̂ξ eiΩtt ) .

T T
Programmtechnisch arbeiten wir die beiden Zeitabschnitte innerhalb einer for-Schleife ab. Die
Störgrößenaufschaltung erfolgt über einen logischen Ausdruck. Wesentliche Programmzeilen
aus St_Beob_M.m, [52] zur obigen Vorgehensweise geben wir an.
Programm-Ausschnitt:
t0=0; t=linspace(t0,ts,200); % Zeitvektor im ersten Bereich, I=1
for I=1:2 % Bereich 1, 2
A=[Am zeros(2); M L]... % Systemmatrix mit
+(I==2)*[-bu; -N ]*[cw*H cw]/kT; % zugeschaltetem Anteil
%---- erzwungene Schwingungen
xi_d=(i*Om*eye(4)-A)\hd; % komplexe Teil-Amplitude
%---- Eigenschwingungen, Gesamtlösung
[V,D]=eig(A); % Eigenwertproblem
e=diag(D); % Eigenwerte
cI=exp(e*t0).\(V\(x0-... % Integrationskonstanten
2.0*real(xi_d*exp(i*Om*t0))));
x=real(V*diag(cI)*exp(e*t))+... % Gesamtlösung, Lösungsmatrix

2.0*real(xi_d*exp(i*Om*t));
%---- Datensicherung + generieren der Anfangswerte für I = 2
tg=[tg t]; % Daten, Zeitvektor
xg=[xg x]; % Daten, Zustände
t0=t(end); % Anfangszeit für I = 2
x0=x(:,end); % Anfangs- / Übergangswerte
t=linspace(ts,2.5*ts,300); % Zeitintervall für I = 2
end
Das Programm St_Beob_Mkonst.m in [52] ist bezüglich einer zusätzlichen konstanten

Störung erweitert.
8.2.5 Ergebnisse
Zu 7.: Den Zeitverläufen in Bild 8.13, insbesondere x(t), lesen wir ab:
• 0 < t < 0,15 s: Einschwingvorgang des unbeeinflussten Systems; den Unwuchtschwingun-
gen x(t) sind aufgrund der Anfangswerte Eigenschwingungen
! überlagert.
Eigenkreisfrequenz des dämpfungsfreien Systems ω0 = mk = 600 rad/s, Periodendauer
T0 = 0.0105 s, Erregerkreisfrequenz Ω = 300 rad/s, Periodendauer T = 2 T0 .
• 0,15 < t < ts s: Unwuchtschwingungen mit der Periode T , Eigenschwingungen sind abge-
klungen.
• t = ts s: Beobachter wird zugeschaltet.
• ts < t < ts + T s: Unwuchtschwingungen sind nach ca. einer Periode T kompensiert, Eigen-
schwingungen sind durch den Schaltvorgang angeregt, vgl. Schwingungsdauer T0 .
• t > ts + T s: Eigenschwingungen werden durch Systemdämpfung d abgebaut; Vorgang ist

nicht durch Beobachterpole beeinflussbar. Strecken- und Beobachterdynamik sind separiert,
dies steckt im Beobachterentwurf.
Bild 8.13: Kompensation der Unwuchtschwingungen des Fundamentblockes
Zur Parameterempfindlichkeit beim Beobachterentwurf: Da der Beobachterentwurf von den Sy-
Bild 8.14: Kompensation mit fehlerbehaftetem Streckenparameter k
stemparametern der Strecke und dessen Modellierung abhängig ist, müssen u. a. die Parameter
sehr genau bekannt sein. Erhöhen wir z. B. die Federkonstante k der Fundamentfeder beim Be-
obachterentwurf um 10 %, also auf kB = 39,6 106 N/m, dann erhalten wir einen deutlich schlech-
teren Einschwingvorgang nach der Kompensation, worauf Bild 8.14 hindeutet. Eine Änderung
um 20 % führt bereits zur Instabilität des Systems – die anfänglich vorhandene Separierbarkeit
von Strecke und Beobachterentwurf ist verletzt. Diese Parameterempfindlichkeit im Zusammen-
hang mit einer getreuen Strecken-Modellierung machen den Einsatz in der Praxis problematisch.
376 8 Projekte
8.3 Schwingungstilger mit viskoelastischem Anschlag
Schlagworte: Simulink-Modell, eventgesteuertes System, Stoßkraft, Sinus-Sweep, frequenzmodu-

lierte und stationäre Schwingungen, Signalaufbereitung, Spitzenwert, Eigenwerte, Tilgerfrequenz,
Amplitudengang
Programme: Tilger.mdl, TilgerD.m, TilgerP.m
Das Primärsystem des Schwingungstilgers besitzt die Masse m1 und ist mit einem parallelge-
schaltetem Feder-Dämpfer-Element (k1 , d1 ) gegenüber der Umgebung abgestützt. Die Tilger-
masse (m2 , Sekundärsystem) ist durch ein weiteres viskoelastisches Element (k2 , d2 ) an das Pri-
märsystem angekoppelt. Die Erregung des Primärsystems erfolgt über die Kraft f (t) = q sin (Ωt)
mit der konstanten Amplitude q. Die Bewegung der Tilgermasse wird durch einen viskoelasti-
schen Anschlag (k, d, masselos) begrenzt; das Spiel gegenüber der Gleichgewichtslage sei Δ.
Parameter:
m1 =1 kg
m2 = 0,1 kg
k1 = 25 103 N/m
k2 = 4300 N/m
d1 = 0,8 Ns/m
d2 = 0,1 Ns/m
f (t) = q sin (Ω (t)t) N
q = 10 N
Ω (t) = 2πsweep t rad/s
Δ =3 mm
k = 250 103 N/m
d = 200 Ns/m
sweep = 0,1 Hz/s; Sweep-Rate
Bild 8.15: Tilgersystem und Parameter
Die Bewegungsgleichungen bezüglich der Gleichgewichtslage lauten:
m1 ẍ1 + d1 ẋ1 + d2 (ẋ1 − ẋ2 ) + k1 x1 + k2 (x1 − x2 ) = f (t)

(8.20)
m2 ẍ2 − d2 (ẋ1 − ẋ2 ) − k2 (x1 − x2 ) + fN (ẋ2 , x2 ) = 0
mit der Stoßkraft (Normalkraft, Kontaktkraft)

⎧
⎨ k(x2 − Δ) + d ẋ2 , wenn x2 ≥ Δ und fN > 0
fN (ẋ2 , x2 ) = 0 , wenn x2 ≥ Δ und fN < 0 (8.21)
⎩
0 , wenn x2 < Δ .
Die Antworten des Schwingungssystems auf die Erregung f (t) ist zu untersuchen. Hierzu sind
zunächst die kritischen Frequenzen (Resonanzlagen) sowie die Tilgerfrequenz abzuschätzen. Dar-
auf aufbauend ist ein Hochlauf (Sweep) mit Ω (t) durchzuführen, vgl. [4]. Die diesbezüglichen
8.3 Schwingungstilger mit viskoelastischem Anschlag 377
Schwingungssignale sind für eine grafische Darstellung in Form des Spitzenwertes und des qua-
dratischen Mittelwertes aufzubereiten. Folgende Punkte sind zu bearbeiten:
1. Stationärer Zustand Ω =konst ohne Anschlag: Berechnung der Eigenkreisfrequenzen sowie

der Tilgungsfrequenz des ungedämpften Systems mit Angabe der Resonanzfrequenzen. Gra-
fische Darstellung des Amplitudenfrequenzganges. Überprüfen Sie die Resonanzlagen. Für
die einzelnen Berechnungsschritte und Grafiken ist ein M-File zu schreiben. Es ist gleichzei-
tig als Datenfile für das Simulink-Modell zu nutzen und somit um alle zusätzlich benötigten
Parameter zu ergänzen.
2. Entwurf des Simulink-Modells mit den Subsystemen der Anregung (Sinus-Sweep) für Ω (t),
des mechanischen Modells (8.20), der Stoßkraft (8.21) sowie einem später noch zu erarbei-
teten Auswerteteil der Schwingungssignale einerseits bezüglich des vollständigen Frequenz-
spektrums, andererseits bezüglich der Basiskreisfrequenz Ω .
3. Für das System ohne Anschlag sei die Schwingungsantwort bei einer zeitlich veränderli-
chen Erregerfrequenz Ω (t) mit gegebener Sweep-Rate sweep im Frequenzbereich
Ω
0 ≤ ≤ 60 Hz: f (t) = q sin (2πsweept 2 )
2π
zu ermitteln; frequenzmodulierte Schwingung.
4. Ermittlung der Schwingungsantwort wie unter 3. aber mit viskoelastischem Anschlag.
5. Ermittlung der stationären Schwingungen zur Tilgungsfrequenz ftilgung des ungedämpften
Systems. Ausgehend von den Anfangswerten
x1 (0) = −1,120714064744865 10−5 ; x2 (0) = 4,690345372471773 10−5 ;

ẋ1 (0) = −5,823441920555026 10−5 ; ẋ2 (0) = −4,819093080477291 10−1 ;
ist die Integration über das Zeitintervall 0 ≤ t ≤ 80/ ftilgung vorzunehmen.
Neben dem Datenfile (TilgerD.m, [52]) empfiehlt sich auch ein Plotfile (TilgerP.m, [52])
zur grafischen Auswertung der Simulationsergebnisse unter MATLAB anzulegen.
8.3.1 Das stationäre System ohne Anschlag

Zu 1.: Zur Beurteilung der später zu berechnenden instationären Schwingungen ermitteln wir
zunächst einige nützliche Systemeigenschaften des ungedämpften und gedämpften stationären
Systems mit Ω =konst. Hierzu gehören die Eigenkreisfrequenzen im Zusammenhang mit den
Resonanzlagen, die Tilgungsfrequenz sowie der Amplitudenfrequenzgang.
Die Eigenkreisfrequenzen des ungedämpften Systems folgen nach Kapitel 3 aus der homoge-
ne Bewegungsgleichung nach (8.20)

k1 + k2 −k2
M ÿy + K y = 0 , M = diag(m1 , m2 ), K = . (8.22)
−k2 k2
Der reelle Ansatz
y = ṽv cos ω0t, Eigenvektor ṽv, Eigenkreisfrequenz ω0 (8.23)

378 8 Projekte
nach Abschn. 3.2.2.1 führt auf das Eigenwertproblem
ω02M ṽv = K ṽv, (8.24)
welches wir numerisch unter MATLAB lösen:
e = sqrt(eig(K,M)); MATLAB-Aufruf
In e stehen die Eigenkreisfrequenzen e = [ω01 , ω02 ]T . Daraus folgen die Frequenzen

ω01
ω01 ≈ 144 rad/s, f1 = ≈ 23 Hz
2π
ω02 (8.25)
ω02 ≈ 226 rad/s, f2 = ≈ 36 Hz.
2π
Im ungedämpften Fall herrscht Resonanz, wenn Ω = ω0k . Danach sind
Ωkr1 ≈ 144 rad/s, Ωkr2 ≈ 226 rad/s
die kritischen Kreisfrequenzen, bei denen es auch im gedämpften System zu großen Amplituden-
überhöhungen kommt.
Tilgung tritt im ungedämpften System zu dem Ω auf, bei dem die Primärmasse m1 in Ru-
he bleibt und die Sekundärmasse m2 mit der Eigenkreisfrequenz des angehängten Feder-Masse-
System schwingt, d. h.

1 k2
ftilgung = ≈ 33 Hz . (8.26)
2 π m2
Den Amplitudenfrequenzgang ermitteln wir mit der Bewegungsgleichung des gedämpften

Systems

s d1 + d2 −d2 s q
M ÿy + Dẏy + K y = ĥh sin Ωt, D = ; ĥh = (8.27)
−d2 d2 0
mit M , K nach (8.22). Der reelle Lösungsansatz der stationären Schwingung nach Abschn. 3.3.2.1
y = ŷyc cos Ωt + ŷys sin Ωt (8.28)

führt auf das lineare algebraische Gleichungssystem
⎡ ⎤
0
K − Ω 2M ΩD
D ŷyc ⎢ 0 ⎥
=⎣ ⎥
⎢ . (8.29)
−ΩD D K − Ω 2M ŷys q ⎦
0
!
Die Maximalamplituden ŷ j = ŷ2c j + ŷ2s j in Abhängigkeit von Ω werten wir in den folgenden
Programmschritten aus:
fmax=60; % betrachtete Maximalfrequenz

OMmax=fmax*2*pi; % max. Kreisfrequenz
hd=[0; 0; q; 0]; % Anregungsamplitude
magn=[];
for OM=0:OMmax/1000.0:OMmax % Amplitude(Omega)
A=[K-OM^2*M OM*D; % Systemmatrix
-OM*D K-OM^2*M];
x=A\hd; % Schwingungsamplituden
magn=[magn;sqrt(x(1:2).^2+x(3:4).^2).’];
end
Das Ergebnis ist in Bild 8.16 dargestellt. Resonanzlagen und Tilgungspunkt stimmen mit der
vorangegangenen Berechnung (8.25), (8.26) überein.
Bild 8.16: Amplitudenfrequenzgang
8.3.2 Entwurf des Simulink-Modells
Zu 2.: Das Simulink-Modell nach Bild 8.17 bilden wir mit den Subsystemen: Sweep-Generator,
Schwinger mit Stoßkraft und Auswerteblöcke.
8.3.2.1 Sweep-Generator, Anregungsfunktion
Für die Sweep-Kreisfrequenz setzen wir
Ω (t) = 2 π sweep t (8.30)
mit der Sweep-Rate sweep in Hz/s. Demzufolge sind die Kreisfunktionen der Anregung in (8.20)
aber auch der später eingeführten Referenzsignale mit
sin (Ω (t) t) → sin (2 π sweep t 2 ), cos (Ω (t) t) → cos (2 π sweep t 2 ) (8.31)
zu bilden. Dies sind frequenzmodulierte Signale. Einen Bezug zur momentanen Kreisfrequenz
und damit zu den Ergebnissen des stationären Systems unter 1. ist durch trigonometrische Um-
380 8 Projekte
Bild 8.17: Modell des Schwingungstilgers mit Stoß
Bild 8.18: Sweep-Generator für die Anregungsfunktion und die Referenzsignale
formung von (8.31) nicht zu erreichen. Wir schreiben deshalb
sin (2 π sweep t 2 ) = sin ϕ, → ϕ = 2πsweept 2 , (8.32)
so dass näherungsweise
Ωmomentan ≈ ϕ̇ = 4 π sweep t (8.33)
ist. Hiermit können wir die Auswertung im Frequenzbereich vornehmen und haben gleichzeitig
einen Bezug zu den stationären Schwingungen mit Ω = konst in (8.27) und somit zu Bild 8.16.
Das Simulink-Subsystem des Sweep-Generators zeigt Bild 8.18. Zusätzlich zur Modellierung
von (8.31) ist über den Manual Switch Block eine Betrachtung des stationären Betriebs zu einem
vorgegebenen Ω = konst möglich.
8.3.2.2 Modell des mechanischen Schwingers und der Stoßkraft

Den linearen Teil der Bewegungsgleichung (8.20) bilden wir mit vier Integratoren, vgl. Bild 8.19.
Die Stoßkraft fN nach (8.21) (nichtlinearer Teil) wird in dem Subsystem Stosskraft nach
Bild 8.20 mit den Eingängen x2 , ẋ2 erzeugt. Die logische Entscheidung x2 > Δ bzw. x2 − Δ ≥ 0
realisieren wir mit dem Dead Zone Block für die tote Zone [−∞, Δ], so dass mit dem nachge-
schalteten Sign Block
1 für x2 > Δ und 0 für x2 ≤ Δ
durchgeschaltet wird. Die Aufschaltbedingung fN ≥ 0 realisieren wir mit dem logischen Re-
lational Operator Block: stimmen die Vorzeichen von fN und x2 − Δ überein, so wird eine 1,
sonst eine 0 ausgegeben. Mit den oben verwendeten unstetigen Blöcken können wir einerseits
Bild 8.19: Mechanischer Schwinger
über die Unstetigkeiten hinwegintegrieren oder durch Auswahl von: Enable zero crossing
detection in den Block-Dialog-Boxen eine event-gesteuerte Simulation, bei der Schaltpunkte
im Rahmen der numerischen Genauigkeit eingehalten werden, durchführen.
8.3.2.3 Auswertemodul
Das Schwingungssignal xk (t) setzt sich aus einem Anteil mit der Erregerfrequenz (Basisfre-
quenz) Ω – Basisharmonische – und einem mit von Ω verschiedener Frequenzen ω j
= Ω zu-
382 8 Projekte
Bild 8.20: Stoßkraft-Modell
sammen, z. B. für ω = ω j :
x(t) = a cos Ωt + b sin Ωt + ã cos ωt + b̃ sin ωt . (8.34)
Zur Ermittlung der Maximal-Amplitude (Spitzenwert)

x̂ = a2 + b2 (8.35)
zur Basisfrequenz Ω multiplizieren wir (8.34) jeweils mit cos Ωt bzw. sin Ωt und bilden mit
Hilfe eines Tiefpasses mit der Eckfrequenz ωg << |Ω − ω j | die Mittelwerte x̄c , x̄s
Tiefpass 1 1
x(t) cos Ωt −→ x̄c ≈ a, (vgl. cos2 Ωt = (1 + cos 2Ωt))
2 2
1 (8.36)
Tiefpass
x(t) sin Ωt −→ x̄s ≈ b.
2
Die Schwingungsamplitude der Basisharmonischen folgt schließlich aus
!
x̂ = 2 x̄c2 + x̄s2 = a2 + b2 Signal 1. (8.37)
Die Gleichungen (8.36) und (8.37) setzen wir in ein Simulink-Subsystem um; vgl. Bild 8.21.
Zusätzlich bilden wir Amplitudenwerte der Schwingungsantwort, die neben Ω auch weitere
Frequenzen, z. B Eigenfrequenzen, enthalten. Dazu bauen wir auf dem quadratischen Mittelwert
(Effektiv-Wert) auf. Hierzu bilden wir zunächst x2 und mit einem Tiefpass den Mittelwert x¯2 . Wir
zeigen dies wieder an dem Signal aus (8.34). Es folgt:
1 2 1 1
x2 = (a + b2 ) + (ã2 + b̃2 ) + (a2 − b2 ) cos 2Ωt + ab sin 2Ωt
2 2 2
+ (aã − bb̃) cos (Ωt + ωt) + (ab̃ + ãb) sin (Ωt + ωt)
(8.38)
+ (aã + bb̃) cos (Ωt − ωt) − (ab̃ − ãb) sin (Ωt − ωt)
1
+ (ã2 − b̃2 ) cos 2ωt + ãb̃ sin 2Ωt
2
und nach einer Tiefpassfilterung der Mittelwert
1 1 1 1
x¯2 ≈ (a2 + b2 ) + (ã2 + b̃2 ) = x̂2 + x̃2 (8.39)
2 2 2 2
bzw.
1 2
x¯2 = √ x̂ + x̃2 =: xrms (rms = root mean square). (8.40)
2
Dieser quadratische Mittelwert hat ausschließlich quantitativen Charakter. Um das Ergebnis mit
der Amplitude des harmonischen Signals (8.35) vergleichen zu können, verwenden wir den Spit-
zenwert
√
x̄¯ = 2 x¯2 = x̂2 + x̃2 Signal 2; (8.41)
d. h., enthält das Signal nur Ω -Terme, dann geht x̄¯ in x̂ über. Die beiden Auswertemethoden
(8.37), (8.41) realisieren wir in dem Simulink-Subsystem nach Bild 8.21. mit den ebenfalls inte-
grierten B UTTERWORTH-Tiefpässen 3. Ordnung – vgl. (4.19) –
...
y F + μ1 ωg ÿF + μ2 ωg2 ẏF + μ3 ωg3 yF = μ3 ωg3 u (8.42)
mit dem Eingangssignal u und den Filterparametern μ1 = μ2 = 2; μ3 = 1 sowie der Grenzfre-

quenz (Eckfrequenz) ωg , vgl. Bild 4.19.
Bild 8.21: Auswertemodul für die Simulationsergebnisse

384 8 Projekte
8.3.3 Schwingungsantwort mit einem Sinus-Sweep des Systems ohne/mit Anschlag
Zu 3., 4.: Bild 8.23 enthält Ergebnisse nach einem Sweep-Durchgang für das System ohne/mit
Anschlag. Neben den beiden Zeitschrieben x1 (t), x2 (t) sind die Ausgänge des Auswertemoduls
in Form: Maximal-Amplituden nach (8.37) – Signal 1 – der Basis-Harmonischen (Frequenz Ω )
und des vollständigen Signals (alle Harmonischen) nach (8.41) – Signal 2 – bezüglich der Aus-
lenkungen x1 , x2 sowie der der Kraft des Feder-Dämpfer-Elementes fu = k1 x1 + d1 ẋ1 dargestellt.
Auffällig sind in Bild 8.23 oben die großen Resonanzüberhöhungen bezüglich der Auslenkun-
gen x1 , x2 sowie das Kraftminimum bei der Tilgungsfrequenz von ≈ 33 Hz, wenn kein Anschlag
vorhanden ist. Da das System gedämpft ist, liegt keine vollständige Tilgung vor. Die Schwin-
gungen enthalten, bis auf wenige schmale Übergangsbereiche, lediglich die Basiskreisfrequenz
Ω.
Mit Anschlag, Bild 8.23 unten, werden die Resonanzüberhöhungen deutlich abgebaut. Die
Tilgung wird aufgrund des Maßstabes auch in dem Zeitschrieb x1 (t) deutlich. Bedingt durch den
Anschlag enthält das Schwingungssignal jetzt einen größeren Anteil an Frequenzen, die nicht
mit Ω übereinstimmen. Durch den Stoß werden Eigenschwingungen angeregt.
8.3.3.1 Stationäre Schwingungen zur Tilgungsfrequenz
Zu 5. Modellseitig ist für die Ermittlung der stationären Schwingungen mit dem Schalter des
Blocks Manual Switch in Bild 8.18 statt der Zeit t eine 1 durchzuschalten. Die Sweep-Rate ist im
Datenfile TilgerD.m durch die konstante Tilgungsfrequenz sweep = ftilgung zu ersetzen.
Bild 8.22: Stationäre Schwingungen zur Tilgungsfrequenz ftilgung ; System mit Anschlag
In den Grafen von Bild 8.22 – entsprechend der Anordnung von Bild 8.23 – spiegelt sich der
Tilgungseffekt in der Signalhöhe von x1 und der Kraft wieder. Die unteren beiden Bilder stellen
die Spitzenwerte nach (8.37), (8.41) dar. Nach dem Einschwingvorgang (t > 2 s) der Tiefpässe
enthält das stationäre Schwingungssignal ausschließlich die Basisfrequenz Ω . Die Amplituden-

werte stimmen mit den Maximalwerten der Zeitverläufe von x1 , x2 überein.
Bild 8.23: Sweep-Durchgang mit sweep = 0,1 Hz/s; System ohne/mit Anschlag
386 8 Projekte
8.4 Axialkolbenverdichter einer Pkw-Klimaanlage

Schlagworte: Lagrange’sche Gleichung 1. Art, Lagrange’sche Multiplikatoren, Bindungsglei-
chungen, differenzial-algebraische Gleichungen, M-File, physikalische Modellierung, SimMecha-
nics-Modell und Animation, Gelenkkraftermittlung, Trimming-Mode, Gleichgewichtslagen, New-
ton-Verfahren
Programme: Hebel.m, Hebel_Daten.m, fhebel.m, vergleich.m, Gleich_Lage.m, Hebelsm.mdl
8.4.1 Das Modell
Bild 8.24: Modell eines Axialkolbenverdichters
Axialkolbenverdichter werden heute in der Pkw-Klimatechnik eingesetzt. Bild 8.24 zeigt ein
Modell eines solchen Verdichtertyps. Der Verdichter besteht aus einer mit Ω rotierenden Welle,
an die in 0H der Hebel H angelenkt ist. Das andere Hebelende ist an einer Schrägscheibe S dreh-
bar befestigt. Diese ist ihrerseits mit der Gleithülse G über ein Drehgelenk in 0S verbunden. Die
Gleithülse und damit die Schrägscheibe S können sich somit translatorisch auf der Welle bewe-
gen, wodurch sich der Kippwinkel α verändert. Über eine nicht mitdrehende Wobble-Scheibe
oder Taumelscheibe W, die auf der Schrägscheibe gleit- oder wälzgelagert ist, werden über Gleit-
steine die 5-7 Kolben reibungsarm angelenkt. Die Zylinderbohrungen sind auf einem Teilkreisra-
dius R in einem feststehenden Zylinderblock angeordnet. Aufgrund der Schrägstellung und der
Rotation kommt es zur Kolbenbewegung; der Kolbenhub ist von α abhängig. Begrenzt man die
Schrägstellung von S durch Anschläge, dann gehört zum kleinsten Winkel αmin der kleinste, zum
größten Winkel αmax der größte Kolbenhub. Mittels der Abmessungen und der zwischen Welle
und Gleithülse wirkenden vorgespannten Feder (k, d) ist es möglich, die oberen Kolbentotlagen
zu unterschiedlichen Winkeln α konstant zu halten. Mit dem Dämpfungskoeffizienten d wird
eine Federdämpfung berücksichtigt, so dass anfängliche Störungen abklingen.
Die Kühlleistung ist somit durch Veränderung des Kolbenhubs über den Kippwinkel α er-
reichbar. Hierzu wird der Verdichterinnenraum, in dem sich H, S, W, G usw. befinden, mit einem
Steuerdruck pS , der auf die Unterseite der Kolben wirkt, beaufschlagt; er wirkt entgegen dem
Kolbendruck, so dass sich damit α ändert.
8.4 Axialkolbenverdichter einer Pkw-Klimaanlage 387
Der Arbeitsprozess könnte durch ein pV -Diagramm mit isentroper oder adiabater Verdichtung
und Expansion, wie in Klima_Verd.mdl in [52], berücksichtigt werden.
8.4.2 Der Hebelmechanismus
Bild 8.25: Hebelmechanismus
Wir wollen hier ein Teilproblem lösen, indem wir uns nur auf den Hebel H in Bild 8.24 be-
schränken. Die Anlenkung an die Schrägscheibe S ersetzen wir, wie in Bild 8.25 skizziert, durch
ein Feder-Dämpferelement (kH , dH ), welches bei entspannter Feder eine Länge von F hat. Die-
ser Hebelmechanismus rotiert mit konstanter Winkelgeschwindigkeit Ω . Ausgehend von belie-
bigen Anfangswerten der Hebellage schwingt dieser um seine stationäre Lage. Dieses Schwin-
gungsverhalten ist für die in Tabelle 8.2 angegeben Parameter per numerischer Simulation unter
MATLAB und mit Hilfe des SimMechanics Tools zu untersuchen. Im Einzelnen sind folgende
Punkte zu bearbeiten:
1. Ermittlung der Bewegungs- und Bindungsgleichungen (DAEs vom Index 3) ausgedrückt
durch die Schwerpunktkoordinaten Z xs , Z zs sowie den Lagewinkel φ des Hebels im rotieren-
den Z-Koordinatensystem. Die Gleithülsenmasse kann vernachlässigt werden, das System
hat somit einen Freiheitsgrad. Überführen Sie die Bewegungsgleichungen in das zugehörige
Index-1-Problem in einer semi-expliziten Form zur Integration der DAE.
2. Erstellen Sie ein M-File zur Simulation unter MATLAB mit einer Darstellungsmöglichkeit
der Zeitverläufe Z xs (t), Z zs (t), φ (t), λ1 (t), λ2 (t). Die Systemparameter nach Tabelle 8.2
sind in einem separaten Datenfile, welches auch für die Modellierung mit dem SimMecha-
nics Tool genutzt werden soll, zusammenzufassen.
3. Führen Sie einen modellbasierten Entwurf mit dem SimMechanics Tool unter Simulink
durch. Es sind gegenüber dem ersten Modell die Masseeigenschaften der Gleithülse und
ein Feder-Dämpfer-Element (k, d) wie in Bild 8.24 zu berücksichtigen, das System hat so-
mit zwei Freiheitsgrade. Aktivieren Sie das Visualisierungsfenster und beobachten Sie darin
die Einzelschritte der Modellerstellung sowie die Animation während der Simulation.
4. Vergleichen Sie die Ergebnisse beider Vorgehensweisen anhand der Gelenkkräfte in 0H .
5. Untersuchen Sie mit Hilfe der Analyse-Methode Trimming die sich einstellende stationäre
Lage.
388 8 Projekte
Tabelle 8.2: Parameter des Hebelmechanismusses
Masse mH = 1,2 10− 2 kg

Massenträgheitsmomente bez. S Ixx = 2,8 kg mm2 , Iyy = 3,3 kg mm2 , Izz = 0,62 kg mm2
Hebellänge H = 24 mm
Schwerpunktslage sH = H /2
Anlenkmaße aH = 7 mm, bH = 20 mm
Federsteifigkeit kH = 106 N/m
Dämpfungskonstante dH = 10−4 kH Ns/m
Länge der entspannten Feder lF = bH + H sin π/8 + mH g/kH sH /H
Anfangswerte z. B. φ0 = π/8 rad; φ̇0 = 0,0 rad/s
8.4.3 Bewegungsgleichungen nach Lagrange
Zu 1): Das System hat einen Freiheitsgrad. Wir arbeiten aber nicht mit einer Minimalkoordinate,
sondern führen bewusst – meist wegen einer besseren Übersichtlichkeit – überzählige Koordina-
ten Z xs (t), Z zs (t), φ (t) ein. Ausgang der Betrachtung ist deshalb die L AGRANGEsche Gleichung
1. Art nach Kapitel 5
T T T
d ∂L ∂L ∂gg
− − λ = Q; pT = [Z xs , Z zs , φ ] (8.43)
dt ∂ ṗp ∂p ∂p
mit den Bindungsgleichungen g = 0 und dem Vektor der L AGRANGEschen Multiplikatoren λ

sowie der L AGRANGEsche- Funktion L = T − V , wobei T die kinetische und V die potentielle
Energie ist.
Die kinetische Energie setzt sich aus einem translatorischen und einem rotatorischen Teil
zusammen:
1 1
T = mH I v Ts I v s + I ω T I I I ω (8.44)
2 2
Index: I Inertialsystem, s Schwerpunkt SH .
Da der Trägheitstensor I I zeitabhängig ist, ist es zweckmäßig, die Rotationsenergie mit Hilfe
der Größen K ω , K I im körperfesten K-System auszudrücken. Mit
Iω = T IK K ω ,
wobei T IK die Transformationsmatrix (vom K-System ins I-System, vgl. Kapitel 2), folgt
1 1
Trot = K ω T KI I I T IK K ω =
T
Kω KI Kω ,
T
2 2
KI
darin ist K I bezogen auf das körperfeste Koordinatensystem (K) und somit zeitunabhängig. Die
Transformationsmatrix T IK ergibt sich aus zwei Teildrehungen, der Drehung γ um die Z z-Achse
und der Hebeldrehung φ

⎡ ⎤⎡ ⎤
cos φ 0 − sin φ cos γ sin γ 0
T IK = T φT γ = ⎣ 0 1 0 ⎦ ⎣ − sin γ cos γ 0 ⎦ .
sin φ 0 cos φ 0 0 1
Die Schwerpunktsgeschwindigkeit von SH folgt aus der zeitlichen Ableitung des Ortsvektors
im Inertialsystem. Hierfür bestimmt man zunächst den Ortsvektor Z r s im Z-System, welches
Ir s
die Rotordrehung γ mitmacht
⎡ ⎤
Z xs
Zr s = ⎣ 0 ⎦
Z zs
und anschließend (Transformation von (Z) → (I))
Ir s = T Tγ Z r s
T
I ṙr s = Ṫ
T γ Z r s + T Tγ Z ṙr s
⎡ ⎤⎡ ⎤ ⎡ ⎤⎡ ⎤
−γ̇ sin γ −γ̇ cos γ 0 Z xs cos γ − sin γ 0 Z ẋs
= ⎣ γ̇ cos γ −γ̇ sin γ 0 ⎦ ⎣ 0 ⎦ + ⎣ sin γ cos γ 0 ⎦⎣ 0 ⎦
0 0 0 Z zs 0 0 1 Z żs
bzw. ausmultipliziert
⎡ ⎤ ⎡ ⎤
−γ̇ Z xs sin γ Z ẋs cos γ
I v s = ⎣ γ̇ Z xs cos γ ⎦ + ⎣ Z ẋs sin γ ⎦ .
0 Z żs
Die Winkelgeschwindigkeit K ω bilden wir mit den Elementarwinkelgeschwindigkeiten γ̇, φ̇ zu

⎡ ⎤ ⎡ ⎤ ⎡ ⎤
0 0 −γ̇ sin φ
K ω = T φ ⎣ 0 ⎦ + ⎣ φ̇ ⎦ = ⎣ φ̇ ⎦ .
γ̇ 0 γ̇ cos φ
Damit schreiben wir die kinetischen Energien (8.44) um:
1
Ttrans = mH γ̇ 2 Z xs2 + Z ẋs2 + Z ż2s
2
1 1 1 (8.45)
Trot = γ̇ 2 Ixx sin2 φ + γ̇ 2 Izz cos2 φ + φ̇ 2 Iyy .
2 2 2
Die potentielle Energie bildet sich zu
1
V = mH g [1, 0, 0] I r s + kH (Z xs + (H − sH ) sin φ − F )2 , (8.46)
2
wenn F die Federlänge der entspannten Feder ist, die generalisierte Kraft infolge der Dämpfung
390 8 Projekte
zu
⎡ ⎤
−dH Z ẋs + (H − sH )φ̇ cos φ
Q=⎣ 0
⎦. (8.47)
−dH Z ẋs + (H − sH )φ̇ cos φ (H − sH ) cos φ
Die Bindungsgleichungen formulieren wir mit Bild 8.25 bezüglich SH im Z-Systems, d. h.

Z xs − bH − sH sin φ
= 0 oder kurz g = 0 .
Z zs − aH − sH cos φ
Mit der JACOBI-Matrix der Bindungsgleichung ∂∂ggp und dem Vektor der L AGRANGEschen Multi-
plikatoren λ = [λ1 , λ2 ]T folgt der letzte Term auf der linken Seite von (8.43)
⎡ ⎤
T T λ1
∂gg 1 0 −sH cos φ
λ = λ =⎣ λ2 ⎦. (8.48)
∂p 0 1 sH sin φ
−λ1 sH cos φ + λ2 sH sin φ
Setzen wir (8.45) - (8.48) in (8.43) ein und werten diese, z. B. mit Hilfe der Computeralgebra, für
eine stationäre Rotordrehung γ̇ = Ω , γ = Ωt aus, dann erhalten wir die nichtlineare Bewegungs-
gleichungen für p = (Z xs , Z zs , φ )T sowie λ1 , λ2 im mit Ω rotierenden Z-System:

mH Z ẍs = mH Ω 2 Z xs − dH Z ẋs + (H − sH )φ̇ cos φ
− kH (Z xs + (H − sH ) sin φ − lF ) + λ1 − mH g cos Ωt
mH Z z̈s = λ2
1
Iyy φ̈ = Ω 2 (Ixx − Izz ) sin 2φ
2
− kH (Z xs + (H − sH ) sin φ − lF ) (H − sH ) cos φ (8.49)

− dH Z ẋs + (H − sH )φ̇ cos φ (H − sH ) cos φ
− λ1 sH cos φ + λ2 sH sin φ
0 = Z xs − bH − sH sin φ
0 = Z zs − aH − sH cos φ .
Dies ist ein differenzial-algebraisches Gleichungssystem vom Index 3. Für eine Simulation unter
MATLAB ist es in ein Index-1-Problem zu überführen. Hierzu müssen die Bindungsgleichungen
zweimal nach der Zeit differenziert werden, also
0 = Z ẍs − sH (φ̈ cos φ − φ̇ 2 sin φ )

(8.50)
0 = Z z̈s + sH (φ̈ sin φ + φ̇ 2 cos φ ).
Statt der auf Lageebene basierenden Bindungen in (8.49)4, 5 sind die auf Beschleunigungsebene
basierenden (8.50) zu verwenden. Eine semi-explizite Form erhält man, wenn auf der linken Sei-
te der obigen drei Differenzialgleichungen nur die zweiten zeitlichen Ableitungen stehen, d. h.
wir müssen durch mH bzw. Iyy dividieren.
8.4.4 Das M-File, erste Ergebnisse

Zu 2): Da wir die Parameter aus Tabelle 8.2 einerseits im M-File für die Simulation unter MAT-
LAB und andererseits für die unter Simulink benötigen, ist es zweckmäßig, das separate M-File
Hebel_Daten.m in [52], das alle gemeinsamen Parameter enthält, anzulegen.
Auf der Basis des unten abgedruckten Programmausschnittes aus Hebel.m folgen einige
Bemerkungen: Mit dem Aufruf von Hebel_Daten werden die Parameter in den Workspace
geschrieben und sind somit in Hebel.m verfügbar. Zum Transfer in die Function der Differen-
zialgleichung (8.49) aus [52] sind sie teilweise als globale Variable zu vereinbaren.
Die konsistenten Anfangswerte p (0), ṗp(0) können wir ausgehend von φ0 , φ̇0 berechnen. Da
wir eine DAE mit singulärer aber konstanter Massenmatrix M bearbeiten, muss diese Option
aufgenommen und M gleichzeitig im Hauptprogramm formuliert werden. Als Integrator bieten
sich ode23t und ode15s an. Die restlichen Programmzeilen – vgl. auch Hebel.m – sind selbster-
klärend. Dies gilt auch für die Function fhebel.m, in der (8.49) mit den Bindungsgleichungen
(8.50) zu programmieren sind.
Ausschnitt aus Hebel.m, [52]:
global m_H Ixx Iyy Izz ell_H b_H Om g k_H s_H d_H lF
% ---- Parameter:
Hebel_Daten % Parameter einlesen
% ---- Massenmatrix
M = diag([1 1 1 1 1 1 0 0]); % Massenmatrix
% ---- Anfangszustände
phi=phi_0; % Hebelwinkel, phi_0 oben gegeben
phi_p=0; % Hebelwinkelgeschw.
xs=b_H+s_H*sin(phi); % Schwerpunktskoordinaten
zs=a_H+s_H*cos(phi);
xsp=s_H*phi_p*cos(phi); % Translat.-Geschwindigkeiten
zsp=-s_H*phi_p*sin(phi);
% ---- Anfangswerte
y0=[xs; zs; phi ; xsp; zsp; phi_p; 0; 0]; % Anfangswerte
%..............................................................
tspan=[0 1]; % Integrationsintervall
options = odeset(’Mass’,M,’MassSingular’,’yes’,’RelTol’,1.0e-5);
[t,y] = ode23t(@fhebel,tspan,y0,options); % Int.-Aufruf
In Bild 8.26 ist ein Einschwingvorgang aufgezeichnet. Danach schwingt der Hebel infolge der
Dämpfung in seine stationäre Lage zu Ω = 250 rad/s. Weil der Gewichtseinfluss des Hebels sehr
gering ist, unterscheidet sich die stationäre Lage nur unwesentlich von der Gleichgewichtslage
im schwerelosen Zustand (g = 0). Die Größen λ1 , λ2 sind nach (8.48) bzw. (8.49) Bindungs-
kräfte, die hier in SH angreifen und in die positiven Koordinaten-Richtungen von Z xs , Z zs des
mitdrehenden Z-Systems weisen, die dritte Komponente (8.48)3 entspricht einem Moment um
die Z ys -Achse, so dass die Bindung im Gelenk 0H eingehalten wird. Eine Reduktion der Kräfte
von SH in das Gelenk 0H zeigt, dass λ1 , λ2 gleichzeitig die Gelenkkräfte sind. Wir vergleichen
die Kräfte später mit einem Ergebnis aus dem modellbasierten Entwurf.
8.4.5 Modellbasierter Entwurf mit SimMechanics

Zu 3): Ergänzend zum Hebelmechanismus von Bild 8.25 sei jetzt die Gleithülse massebehaftet
392 8 Projekte
Bild 8.26: Simulationsergebnis zum Hebelmechanismus
und bewegt sich, wie in Bild 8.24, gegen ein Feder-Dämpfer-Element (k, d). Die zugehörigen Pa-
rameter sind direkt im Block-Modell Hebelsm.mdl aus [52] eingetragen. Wir machen einige
Erklärungen zum Block-Modell Hebelsm.mdl nach Bild 8.27: Der Koordinatenursprung 0 des
Inertialsystems (I, World) fällt mit dem des drehenden Z-Systems in Bild 8.25 zusammen. Die Ur-
sprünge der körperfesten Koordinatensysteme u. a. in 0H , am Hebelende und auf der Gleithülse
lassen sich unmittelbar mit Hilfe der Abmessungen im drehenden System für t = 0 angeben, vgl.
Bild 8.28. Bei der Modellierung gehen wir von einem Dreikörpersystem aus Rotor, Hebel, Gleit-
hülse aus, jedem Körper ist ein Body Block zuzuordnen. Die Zwangsdrehung des Rotors – Win-
kel, Winkelgeschwindigkeit, -beschleunigung – erzeugen wir mit dem MATLAB Function Block1 .
Die Anbindung zur SimMechanics-Umgebung erfolgt mit dem Joint Actuator Block. Die Rotor-
lagerung ist das Drehgelenk (Revolute) mit einer Verbindung zur Umgebung (Ground Block) und
einer zum Body Block des rotierenden Rotors. Die Ports CS3, CS4 entsprechen den Ursprüngen
der Koordinatensysteme von Gelenkpunkt 0H und Gleithülse. Demzufolge schließen sich hieran
die Basen (B) des Drehgelenks (Revolute1) und des Schubgelenks (Prismatic) an. An (F) folgen
dann der Hebel (Body1) und die Gleithülse (Body2). Schließlich sind noch die Feder-Dämpfer-
Elemente einerseits zwischen zwei Body Blöcken, andererseits zwischen Gleithülse und Ground
– Dreh- und Inertial-Achse fallen zusammen – einzubringen. Die restlichen Komponenten kön-
nen als bekannt vorausgesetzt werden. Das Datenfile Hebel_Daten.m muss vor dem Start
ausgeführt werden, hierzu tragen wir den Filenamen unter Model Properties/Callbacks
ein.
1 Simulink 7.7; bei Vorgängerversionen ist der Embedded MATLAB Function Block oder eine andere Modellierung zu
wählen
Bild 8.27: SimMechanics-Modell zum Hebelmechanismus
Bild 8.28: Automatische Modellgenerierung im Visualisierungsfenster
8.4.6 Vergleich der Ergebnisse bezüglich der Gelenkkräfte

Zu 4): Die Ergebnisdiskussion führen wir anhand der Gelenkkräfte in 0H . Sie werden in der
Dialogbox zum Joint Sensor1 durch Auswahl von Reaction force an den Port gelegt und
mit dem Scope2 zur Anzeige gebracht sowie zusätzlich in den Workspace geschrieben. Die Kraft-
komponenten einschließlich deren Vorzeichen beziehen sich auf das World-System, welches die
Drehung Ω nicht mitmacht. Demgegenüber beziehen sich die Kräfte λ1 , λ2 aus der vorangegan-
genen Simulation auf das Z-System. Wählen wir zum Vergleich das World-System, dann müssen
die λk transformiert werden. Beschränken wir uns auf die Kräfte in der x, y-Ebene, dann bedeutet
dies
I Fx = λ1 cos Ωt, I Fy = λ1 sin Ωt .
Die programmseitige Darstellung, der grafische Vergleich und Verfahrenshinweise sind in He-
bel.m angegeben. Bild 8.29 zeigt ein Ergebnis. Danach erhalten wir – wie zu erwarten – über-
einstimmende Verläufe. Die Parameter und Anfangswerte der Gleithülse müssen allerdings so
394 8 Projekte
abgestimmt sein, dass dadurch das Schwingungsverhalten nur unwesentlich beeinflusst wird, d. h.
k, d → 0.
Bild 8.29: Vergleich der Gelenkkraft I Fy aus beiden Modellierungen
8.4.7 Stationäre Lage, die Trimming-Methode
Zu 5): Die Analyse-Methode Trimming (vgl. Machine Environment Block) bestimmt in Abhän-
gigkeit von anfänglichen Störungen eine mögliche stationäre Lösung oder eine Gleichgewichts-
lage. Da sich in unseren Fall die Gleithülse ungehindert auf der Rotorlängsachse bewegen kann,
existieren zwei stationäre Lagen, d. h. die Hülse kann sich einerseits auf der positiven, anderer-
seits auf der negativen Z z-Achse befinden, dementsprechend folgt der Hebel. Welche Lage sich
einstellt, hängt u. a. von den vorgegeben Anfangswerten ab.
Einen Überblick bezüglich möglicher Lagen erhalten wir am einfachsten für den schwerelosen
Zustand (g = 0) mit (8.49). Zu der jetzt existierende Gleichgewichtslage (Index 0) verschwinden
die zeitlichen Ableitungen in (8.49). Wir lesen direkt ab:
λ20 = 0, Z z s0 = aH − sH cos φ0 .
Die restlichen drei Größen in p 0 = [Z xs0 , φ0 , λ10 ]T folgen aus der nichtlinearen Vektorfunktion
⎡ ⎤
mH Ω 2 Z xs0 − kH Z xs0 + (H − sH ) sin φ0 − lF + λ10
⎢ 1 Ω 2 (Ixx − Izz ) sin (2φ0 )− ⎥
f (pp0 ) = ⎢ ⎥
⎣ kH Z xs + (H − sH ) sin φ0 − lF (H − sH ) cos φ0 − λ10 sH cos φ0 ⎦ . (8.51)
2
0
Z xs0 − bH − sH sin φ0
Ausgehend von Schätzwerten zur Gleichgewichtslage können wir (8.51) mit Hilfe des N EWTON-
Verfahrens näherungsweise lösen. Hierzu bilden wir die TAYLOR-Entwicklung bis zum linearen
Glied

∂ f !
f (pp0 + Δpp) = f (pp0 ) + Δpp = 0 , (8.52)
p 0 0
woraus sich die Verbesserung

∂ f
Δp = −
p f (pp0 ) (8.53)
p 0 0
errechnet. Hiermit schreiben wir die Iterationsfolge
Δppk−1
0 = −JJ −1 (ppk−1
0 ) f (p 0 ), J regulär
pk−1
(8.54)
p k0 = p k−1
0 + Δp
p0k−1
an, wobei J = ∂ f /∂ p 0 und f (pp0 ) mit den Werten aus dem k − 1 Schritt zu bilden sind. f (pp0 )
und J (pp0 ) berechnen wir z. B. symbolisch (oder analytisch). Die zugehörigen Schritte sind in
dem Programm Gleich_Lage.m [52] nachzulesen. Wir erhalten die Ergebnisse
0,525 rad ≈ 30°

φ0 = , Z xs0 = 0,026 m, λ10 = 2845,6 N,
2,616 rad ≈ 150°
sie entsprechen in etwa den Mittelwerten der stationären Lösungen nach der Trimming-Methode.
Damit sich stets eine definierte stationäre Lage einstellt, ist es sinnvoll, die Bewegung der Gleit-
hülse zu begrenzen.
8.4.8 Der Verdichter als SimMechanics-Modell

In Klima_Verd.mdl aus [52] ist der vollständige Verdichter nach Bild 8.24 mit sieben Kolben
und Arbeitsprozessen aus pV -Diagrammen modelliert. Bild 8.30 zeigt eine Momentaufnahme
der Simulation im Visualisierungsfenster des gegenüber Bild 8.24 um 90° gedrehten Verdichters.
Bild 8.30: SimMechanics-Modell des Verdichters, stehende Anordnung

396 8 Projekte
8.5 Dreifachpendel
Schlagworte: Lagrange’sche Gleichung 2. Art, Newton-Euler-Formalismus, symbolische Auswer-
tung, Übergang zur Numerik, Animationsmodell, Linearisierung, M-File, physikalisches Modell
unter SimMechanics, Vorwärtsdynamik, Inverse Dynamik
Programme: Drei_P.m, Drei_PNE.m, fDrei_P.m, om_tilde.m, Drei_Psm.mdl, Drei_Psm_I.mdl
Die nichtlinearen Schwingungen des skizzierten symmetrischen Dreifachpendels sind ausgehend

von unterschiedlichen Anfangswerten zu untersuchen. Für die Simulation unter MATLAB sind ins-
besondere die Herleitung der Bewegungsgleichungen nach Kapitel 2 mit der Computeralgebra
nach Abschn. 1.8 und die Animation der Schwingungen auf der Basis von Abschn. 1.7.3 vorzu-
nehmen. Diese Ergebnisse sind denen aus einer physikalischen Modellierung unter Simulink mit
Hilfe der SimMechanics Toolbox nach Kapitel 7 gegenüberzustellen.
Bild 8.31: Dreifach-Pendel: Demo-Modell, Skizze mit Bezeichnungen
Tabelle 8.3: Parameter zum Dreifachpendel
Hauptpendel
Masse m1 0,613 kg
Drehträgheit bezüglich S1 C1 1,64 10−2 kg m2
Schwerpunktsabstand s1 0,1065 m
Lagerabstand 01 ,02 , 01 ,03 0,18 m
Nebenpendel
Masse m2 = m3 0,210 kg
Drehträgheit bezüglich S2 , S3 C2 = C3 6,53 10−4 kg m2
Schwerpunktsabstand s2 = s 3 0,1145 m
Erdbeschleunigung g 9,81 m / s2
8.5 Dreifachpendel 397
Im Einzelnen sind folgende Punkte zu bearbeiten:
1. Leiten Sie die Bewegungsgleichungen symbolisch mit Hilfe

a. der L AGRANGEschen Gleichung 2. Art nach Abschn. 2.5
b. des N EWTON -E ULER Formalismus nach Abschn. 2.4.1
her, erstellen Sie für jede Modellierung ein M-File und vergleichen Sie die Ergebnisse.
2. Schaffen Sie einen Übergang zur Numerik nach Abschn. 1.8.9. Binden Sie die numerische
Integration der Bewegungsgleichungen ins Programm ein und erstellen Sie die Function der
Differenzialgleichungen.
3. Erstellen Sie ein Animationsmodell des Pendels auf der Basis der Einzelteile nach Bild 8.32,
vgl. Abschn. 1.7.3.
4. Führen Sie für unterschiedliche Anfangswerte, z. B. ϕ1 = 0, ϕ2 = ϕ3 = π; ϕ̇k = 0, einige
Simulationen durch und beurteilen Sie die Schwingungen.
5. Modellieren Sie das Dreifachpendel unter Simulink mit der SimMechanics Toolbox und
führen Sie eine Vorwärtsdynamik durch, vgl. Kapitel 7.
6. Beurteilen Sie die Gelenkmomente, wenn die Nebenpendel eine gleichförmige Drehung mit
ϕ j = (−1) j ( j − 1) Ω t, j = 2, 3 vollführen und das Hauptpendel um ϕ1 = π/8 verdreht
ist – inverse Dynamik.
Bild 8.32: Pendel-Abmessungen, Maße in mm
Das System hat 3 Freiheitsgrade ( f = 3). Als generalisierte Koordinaten (Minimalkoordinaten)

wählen wir die in Bild 8.31 eingezeichneten Winkel ϕi jeweils gegen die Vertikale der Gleichge-
wichtslage gemessen, womit der Koordinatenvektor
q = [ϕ1 , ϕ2 , ϕ3 ]T , Minimalkoordinaten (8.55)
fest liegt. Die Bezugspunkte der körperfesten Koordinatensysteme sollen mit den Massenmittel-
punkten (Schwerpunkten) der Körper zusammenfallen.
398 8 Projekte
8.5.1 Lagrange’sche Gleichung 2. Art

Zu 1a): Der Vorgehensweise liegen die Grundlagen aus Abschn. 2.5 zugrunde. Die Ortsvektoren
r si vom Koordinatenursprung 01 zu den einzelnen Schwerpunkten Si lauten:
Körper 1-3:
r s1 , = [−s1 sin ϕ1 , −s1 cos ϕ1 , 0]T
r s2 = [− cos ϕ1 − s2 sin ϕ2 , sin ϕ1 − s2 cos ϕ2 , 0]T (8.56)
T
r s3 = [ cos ϕ1 − s3 sin ϕ3 , − sin ϕ1 − s3 cos ϕ3 , 0] .
Die Absolutgeschwindigkeiten ṙr si ermitteln wir symbolisch
∂rr s1 ∂rr s1
ṙr s1 = q̇1 oder ṙr s1 = q̇q
∂ q1 ∂qq
∂rr s2 ∂rr s2 ∂rr s2
ṙr s2 = q̇1 + q̇2 oder ṙr s2 = q̇q (8.57)
∂ q1 ∂ q2 ∂qq
∂rr s3 ∂rr s3 ∂rr s3
ṙr s3 = q̇1 + q̇3 oder ṙr s3 = q̇q
∂ q1 ∂ q3 ∂qq
MATLAB: (Version 1 mit dem diff Befehl oder Version 2 mit Hilfe der JACOBI-Matrix jacobian)
v_S1=diff(r_S1,q1)*q1p;
v_S2=diff(r_S2,q1)*q1p+diff(r_S2,q2)*q2p;
v_S3=diff(r_S3,q1)*q1p+diff(r_S3,q3)*q3p;
Wegen der ebenen Bewegungen lauten die Winkelgeschwindigkeitsvektoren nach Bild 8.31
ω i = [0, 0, −ϕ̇i ]T , i = 1, 2, 3 . (8.58)
Die Trägheitstensoren I i bezüglich der körperfesten Hauptachsen in Si haben Diagonalgestalt
I i = diag(Ai , Bi , Ci ), i = 1, 2, 3, (8.59)
wobei in die Bewegungsgleichung nur Ci eingeht. Damit können wir die kinetische Energie T =
T1 + T2 + T3
1
T = m1ṙr Ts1 ṙr s1 + m2ṙr Ts2 ṙr s2 + m3ṙr Ts3 ṙr s3 + ω T1I 1ω 1 + ω T2I 2ω 2 + ω T3I 3ω 3 (8.60)
2
und die potentielle Energie V = V1 +V2 +V3 infolge der Erdbeschleunigung g
V = −m1 [0, −g, 0] r s1 − m2 [0, −g, 0] r s2 − m3 [0, −g, 0] r s3 (8.61)
angeben. Da keine weiteren eingeprägten Kräfte/Momente auftreten und darüber hinaus T nicht
explizit von der Zeit t abhängt, lautet die L AGRANGEsche Gleichung nach (2.112) für eine sym-
bolische Auswertung
T T T
∂ ∂T ∂ ∂T ∂ (V − T )
q̈q + q̇q + =0 (8.62)
∂ q̇q ∂ q̇q ∂qq ∂ q̇q ∂qq
oder kurz
M (qq)q̈q + f (qq, q̇q) = 0 . (8.63)
Zur Ermittlung der Massenmatrix M sowie der Vektorfunktion f in (8.63) dient der Programm-
ausschnitt von Drei_P.m aus [52], die Gleichheit der Nebenpendel wird durch Substitution der
Größen des 2. Nebenpendels (m3 , s3 , C3 ) erreicht.
%---- kinetische Energie vgl. Drei_P.m

T=1/2*(m1*v_S1.’*v_S1+m2*v_S2.’*v_S2+m3*v_S3.’*v_S3+...
om1.’*I_1*om1+om2.’*I_2*om2+om3.’*I_3*om3);
%---- potentielle Energie
V=-[0, -g, 0]*(m1*r_S1+m2*r_S2+m3*r_S3);
%---- gleiche Nebenpendel, s3=s2 usw.
T=subs(T,{s3,m3,C3},{s2,m2,C2}); % Substitution
V=subs(V,{s3,m3},{s2,m2});
%---- Ausdrücke vereinfachen
T=simple(simple(T));
V=simple(simple(V));
%---- Ableitungen für LAGRANGEsche Gleichung 2. Art
dTdv=simple(jacobian(T,q_p).’);
dTdq=simple(jacobian(T,q).’);
dVdq=simple(jacobian(V,q).’);
%---- Elemente der Bewegungsgleichung M*q_pp + f = 0, f = K*q_p + h
M=simple(jacobian(dTdv,q_p)); % Massenmatrix
K=simple(jacobian(dTdv,q)); % Geschw.-Term
h=simple(simple(dVdq-dTdq)); % Vektorfunktion h
f=K*q_p+h; % f(q,q_p)
8.5.2 Newton-Euler-Formalismus
Zu 1b: Die Grundlagen stehen in Abschn. 2.4.1. Das Pendel besteht aus N = 3 starren Körpern,
der Koordinatenvektor q nach (8.56) gilt weiterhin. Die N EWTON -E ULER Gleichung nach (2.97)
lautet:
n T
∑ J Ti (ṗpi − f ei ) + J TRi L̇
Li − m ei = 0 . (8.64)
i=1
Für die JACOBI-Matrizen der Translation J Ti und der Rotation J Ri gilt
∂rr si ωi
∂ω
J Ti = , J Ri = . (8.65)
∂qq ∂ q̇q
Da ein ebenes Problem vorliegt und wir die Massenmittelpunkte Si als Bezugspunkte gewählt
haben, vereinfachen sich die zeitlichen Ableitungen – vgl. (2.98) – für den Impuls p und Drall L
ṗpi = mir̈r si , ω i.
Li = I iω̇
L̇ (8.66)
400 8 Projekte
Die eingeprägten Kräfte/Momente werden durch die Gewichtskräfte verursacht
f ei = [0, −mi g, 0]T ; m ei = 0 . (8.67)
Wegen der ebenen Bewegung können wir von der reduzierten Gleichung (2.99) – der mittlere
Term verschwindet – ausgehen:

M1 0 z̈z1 fe
JT − =0 (8.68)
0 M2 żz2 me
mit den an (2.100)-(2.107) angepassten Matrizen für N = 3 und f = 3:

T T
J = J TT1 , J TT2 , J TT3 , J TR1 , J TR2 , J TR3 = J TT , J TR ; J ∈ R9,3 , (8.69)
M 1 = diag (m1E 3 , m2E 3 , m3E 3 ) ; M 1 ∈ R9,9 , E 3 ∈ R3,3 (8.70)

M 2 = diag (II 1 , I 2 , I 3 ) ; M 2 ∈ R9,9 , (8.71)
T
z 1 = r Ts1 , r Ts2 , r Ts3 ; z 1 ∈ R9 (inertiale Basis) (8.72)
T
z2 = ω T1 , ω T2 , ω T3 ; z2 ∈ R9 , ( ωi jeweils in der körperfesten Basis), (8.73)
T
f e = f eT1 , f eT2 , f eT3 ; f e ∈ R9 , (8.74)
T
m e = m Te1 , m Te2 , m Te3 ; m e ∈ R9 (8.75)
ausgehen.
In den Ortsvektoren (8.56) sowie den Geschwindigkeitsvektoren (8.57) tritt die Zeit t nicht
explizit auf – holonome, skleronome Bindungen –, d. h.
z 1 = z 1 (qq), żz1 = żz1 (qq, q̇q), z 2 = z 2 (qq, q̇q) .
Die zeitlichen Ableitungen lassen sich mit (8.65), (8.69) in der Form
żz1 = J T q̇q und z̈z1 =J˙T q̇q + J T q̈q,

(8.76)
z 2 = J R q̇q und żz2 =J˙R q̇q + J R q̈q
schreiben. Setzen wir (8.76) noch in (8.68) ein, dann folgt

fe
J TM J q̈q + J TM J˙q̇q − J T =0 (8.77)
me
mit der Blockdiagonalmatrix M = diag(M

M 1 , M 2 ) aus (8.68). Die Elemente M , f aus (8.63)
sind mit (8.77) direkt zuzuordnen.
Der folgende Programmausschnitt von Drei_PNE.m aus [52] zeigt die symbolische Ermitt-
lung der Elemente der Bewegungsgleichung (8.77) in der Form von (8.63).
%---- JACOBI-Matrizen der Translation Drei_PNE.m

J_T1=jacobian(v_S1,q_p); % oder J_T1=jacobian(r_S1,q);
J_T2=jacobian(v_S2,q_p);
J_T3=jacobian(v_S3,q_p);
J_R1=jacobian(om1,q_p);
%---- Elemente der Bewegungsgleichung
J=[J_T1;J_T2;J_T3;J_R1;J_R2;J_R3]; % Gesamt-JACOBI-M.
%---- Massenmatrix
M1=blkdiag(m1*eye(3), m2*eye(3), m3*eye(3));% Massen-M., Transl.
M2=blkdiag(I_1, I_2, I_3); % Massen-M., Rotat.
M_star=blkdiag(M1,M2); % Gesamt-Massen-M.^*
M=J.’*M_star*J; % Massenmatrix
M=simple(simple(M)); % vereinfacht
M=subs(M,{s3,m3,C3},{s2,m2,C2}); % gleiche Nebenp.
%---- zeitl. Ableitung der JACOBI-M. J
J_p=diff(J,q1)*q1p+ diff(J,q2)*q2p+ diff(J,q3)*q3p; % zeitl. Abl.
gf=simple(simple(J.’*M_star*J_p*q_p)); % Vektorfunkt. gf
%---- eingeprägte Kräfte und Momente
F1=[0; -m1*g; 0]; F2=[0; -m2*g; 0]; F3=[0; -m3*g; 0];
f_e=[f_e1;f_e2;f_e3]; % Kraftvektor
m_e=zeros(3*frg,1); % Momentenvektor
kf=J.’*[f_e;m_e]; % Projektionen
f=simple(simple(gf-kf)); % f(q,q_p)
f=subs(f,{s3,m3,C3},{s2,m2,C2}); % Substitution (gleiche Nebenp.)
Damit erhalten wir die Elemente in der Form von (8.63) (Ausgabe: latex(M) usw.):
⎡ ⎤
m1 s1 2 + 2 m2 l 2 + C1 −m2 ls2 sin(q1 − q2 ) m2 ls2 sin(q1 − q3 )
⎢ ⎥
⎢ ⎥
M = ⎢ −m2 ls2 sin(q1 − q2 ) C2 + m2 s2 2 0 ⎥
⎣ ⎦
m2 ls2 sin(q1 − q3 ) 0 C2 + m2 s2 2
⎡ ⎤
s2 m2 cos (q1 − q2 ) q̇22 l − s2 m2 q̇23 l cos (q1 − q3 ) + gm1 s1 sin (q1 )
⎢ ⎥
⎢ ⎥
f =⎢ −s2 m2 q̇21 l cos (q1 − q2 ) − g sin (q2 ) ⎥
⎣ ⎦

s2 m2 q̇21 l cos (q1 − q3 ) + g sin (q3 )
Mit dem Zustandsvektor ẋx = [qqT , q̇qT ]T , x ∈ R2 f ist aus (8.63) bzw. (8.77) die nichtlineare
Zustandsgleichung

q̇q q̇q
ẋx = = (8.78)
M (qq)−1 f (qq, q̇q) f (qq, q̇q)
abzuleiten, sie muss numerisch ausgewertet werden.

402 8 Projekte
8.5.3 Übergang zur Numerik und Integration

Zu 2.: Bevor wir (8.78) in der Function der Differenzialgleichung (fDrei_P.m) auswerten,
substituieren wir bereits im Hauptprogramm die Symbole der Systemparameter durch die nume-
rischen Werte und bilden gleichzeitig f = M −1 f , das Ergebnis ist vom Typ sym:
%---- Parameter für Simulation
%---- Hauptpendel
m1=0.613; % Masse
s1=0.1065; % Schwerpunktsabstand
l=0.18; % Lagerabstand, Quertraverse
C1=1.6408e-02; % Massenträgh. bez. Schwerpunkt
%---- Nebenpendel
m2=0.210; % Masse
s2=0.1145; % Schwerpunktsabstand
C2=6.53e-04; % Massenträgheitsmoment
g=9.81; % Erdbeschleunigung
%---- Parameter substituiert
M=subs(M); % Massenmatrix
f=subs(f); % Vektorfunktion
f_star=inv(M)*f; % Vektorfunktion M^(-1)*f
Die Vektorfunktion f_star ist immer noch exakt dargestellt, dadurch werden die Zahlen-
werte z. T. aus Integergrößen – vgl. mit subs(subs(M)) –, oft mit hoher Stellenzahl, gebildet;
beim Übergang zur Numerik wird gerundet. Bei größeren Systemen kann es übersichtlicher sein,
die Zahlenwerte teilweise auszuwerten und in Gleitkommazahlen (class sym) darzustellen.
Hierzu dient die Variable precision arithmetic (vpa), z. B. mit dem Aufruf für 16 Stellen
digits(16); M=vpa(M) oder kurz M=vpa(M,16).
Das Ergebnis ist weiterhin vom Typ sym – vgl. auch Abschn. 1.8.9.
Damit bei der Animation der Schwingungen eine zeitgetreue Bewegung entsteht, wählen wir
gleiche Zeitinkremente für die Berechnung des Zustandsvektors, z. B.
ta=0; te=60; % Startzeit/Endzeit
tspan=linspace(ta,te,(te-ta)/0.015); % Zeitv., gleiche Zeitdifferenzen
Mit dem Integratoraufruf organisieren wir auch die Übergabe von f_star entsprechend
(8.78)
[t,y]=ode45(@fDrei_P,tspan,y0,options,f_star);
wobei zuvor die Anfangswerte und Optionen festgeschrieben werden müssen. Die Functi-
on der Differenzialgleichung hat damit Standardform, wobei wir den symbolischen Größen qi ,
q̇i , 1 = 1, 2, 3 in f_star die Elemente des Zustandsvektors (hier x) zuweisen müssen – zweck-
mäßiger wäre eine Umbenennung im Hauptprogramm, vgl. mathp_1.m, DAE_KKL.m. Der
Übergang zur Numerik erfolgt dann durch eval- oder subs-Auswertungen.
function xp = fDrei_P(t,x,f_star)
%---- zu substituierende Größen
q1=x(1); q2=x(2); q3=x(3); q1p=x(4); q2p=x(5); q3p=x(6);
xp=[x(4:6); % Differenzialgleichung
-eval(f_star)];
8.5.4 Animationsmodell
Zu 3.: Die Einzelpendel beschreiben wir, wie in Abschn. 1.7.3, durch geschlossene Polygonzüge.
Hierzu führen wir die in Bild 8.33 angegebenen Knoten ein. Die Positionen der Knoten (xi , yi )
Bild 8.33: Knoten der Pendelelemente zur Erstellung des Animationsmodells
in dem x1 , y1 − und x2 , y2 −Achssystem sind Elemente der zur grafischen Darstellung benötigten
Vektoren:
Hauptpendel:
x 1 = [ −10, −37,5, −37,5, 37,5, 37,5, −10, −10, 190, 190, −190, −190, 10, 10 ]T
y 1 = [ −263, −263, −338, −338, −263, −263, −10, −10, 10, 10, −10, −10, −263 ]T
Nebenpendel:
x 2 = [ −10, −25, −25, 25, 25, 10, 10, −10, −10, 10 ]T

y 2 = [ −130, −130, −180, −180, −130, −130, 10, 10, −130, −130 ]T
Pendel-Lager
x L = [ 50, −50, −10, 10, 50 ]T

y L = [ 50, 50, −8, −8, 50 ]T .
Zur Darstellung des Pendels im x1 , y1 -Achssystem sind zusätzlich die Verschiebungen in die
Anlenkpunkte 02,3 der Nebenpendel, Bild 8.31, additiv hinzuzufügen und ggf. die Lagerorte z. B.
durch Kreise zu kennzeichnen.
Die Animation baut auf den Lösungen ϕk (ti ), k = 1,2,3 zu den Zeitpunkten ti auf. Um die
Bewegung der Pendelelemente zu allen ti darzustellen, führen wir die Drehmatrix

cos ϕk (ti ) sin ϕk (ti )
T k (ti ) = , k = 1,2,3, i = 1,2,3, . . .
− sin ϕk (ti ) cos ϕk (ti )
404 8 Projekte
ein. Die zeitabhängigen Pendelkoordinaten x̃xk , ỹyk genügen dann:
Hauptpendel:

x̃xT1 (ti ) x T1
= T 1 (ti )
ỹyT1 (ti ) yT
1
Null-Lage
Nebenpendel:

x̃xTk (ti ) x Tk (−1)k−1
= T k (ti ) + 1 (ti )
T , k = 2,3.
ỹyTk (ti ) yT 0
k
Null-Lage Lage von 02,3
Die MATLAB-Umsetzung geben wir hier für das Nebenpendel 2 an. Der vollständige Code ist
in Drei_P.m bzw. Drei_PNE.m [52] zu finden.
%---- Animation der Bewegung vgl. Drei_P.m, Drei_PNE.m
%---- Dreifach-Pendel, Geometrie, Maße in mm
lq=1000.0*l; % Quertraverse in mm
%---- Nebenpendel 2, 3 (links, rechts) Null-Lage
x2=[-10, -25, -25, 25, 25, 10, 10, -10, -10, 10];
y2=[-130, -130, -180, -180, -130, -130, 10, 10, -130, -130];
figure(1), clf % Standardgröße

set(gcf,’NumberTitle’,’off’,’Name’,’Animation’,’MenuBar’,’none’)
%---- Nebenpendel 2 (links)
h2=fill(x2-lq,y2,[0.9 0.9 0.9]); % Null-Lage + Farbe
hL2=plot(-lq,0,’o’,’markerfacecolor’,’w’); % Lagerbolzen
axis(2.0*[-lq lq -lq lq]); % Achsskalierung

axis equal, L=axis;
axis off % Achsen ausblenden
set(gca,’Visible’,’off’)
%---- Lösungsvektor y=(phi_1, phi_2, phi_3, phi_1p,...)

set(gca,’Drawmode’,’Fast’); % Zeichenmodus
numframes=length(y); % Anzahl Zeitschritte
for count=1:numframes % Animationsschleife
%---- Hauptpendel
phi_1=y(count,1); % Winkelsignal phi_1
T1=[cos(phi_1) sin(phi_1); -sin(phi_1) cos(phi_1)]; % Drehmatrix
%---- Nebenpendel 2
phi_2=y(count,2); % Winkelsignal phi_2
Xq=T1*[lq;0]*ones(1,length(x2)); % Lage von 0_1, 0_2
T2=[cos(phi_2) sin(phi_2); -sin(phi_2) cos(phi_2)]; % Drehmatrix
XY2=T2*[x2;y2]-Xq; % gedrehte Koord.
set(h2,’xdata’,XY2(1,:),’ydata’,XY2(2,:)); % Datenübergabe
set(hL2,’xdata’,-Xq(1,1),’ydata’,-Xq(2,1));% Lagerbolzen
axis(L) % gleiche Achsskalierung
pause(0.015) % Zeitverzögerung + Bilderneuerung
end;
8.5.5 Schwingungsverhalten
Zu 4.: Zur Interpretation der Schwingungen betrachten wir vorab kleine Schwingungen Δϕi um
die Gleichgewichtslage ϕi ≡ 0, ϕ̇i ≡ 0, i = 1,2,3. Hierzu linearisieren wir die Bewegungsglei-
chung (8.63) – vgl. Abschn. 2.6 –
p(qq, q̇q, q̈q) := M (qq)q̈q + f (qq, q̇q) = 0
um die Gleichgewichtslage q ≡ 0 . Die TAYLOR-Reihenentwicklung bis zum linearen Term ergibt
∂p ∂p ∂p
p (qq, q̇q, q̈q) ≈ p (00, 0 , 0 ) + |0 Δq̈q + |0 Δq̇q + |0 Δqq ≈ 0
∂ q̈
q ∂ q̇
q ∂qq
bzw. wegen p (00, 0 , 0 ) = 0
∂f ∂f
M (00) Δq̈q + |0 Δq̇q + |0 Δqq = 0,
∂ q̇q ∂qq
so dass die lineare Variationsgleichung
M 0 Δq̈q + P Δq̇q + Q Δqq = 0
vorliegt. Die Koeffizienten-Matrizen M 0 , P , Q sind konstant; wir ermitteln sie symbolisch:
f_qp=jacobian(f,q_p); % JACOBI-Matrizen
f_q=jacobian(f,q);
% ---- Gleichgewichtslage
q1=0; q2=0; q3=0; q1p=0; q2p=0;q3p=0; q1pp=0; q2pp=0;q3pp=0;
M_0=subs(M); % Gleichgew.-Lage
Q=subs(f_q); % eingesetzt ->
P=subs(f_qp); % M_0*ypp+P*yp+Q*y=0
% ---- Eigenwerte für P=0
if any(P(:)) == 0, e=sqrt(eig(Q,M_0)), end % y=v*cos(omega*t)
Es ergibt sich:
M_0 = 3.6969e-002 0 0 P = 0 0 0
0 3.4062e-003 0 0 0 0
0 0 3.4062e-003, 0 0 0
Q = 6.4044e-001 0 0
0 2.3588e-001 0
0 0 2.3588e-001
406 8 Projekte
Danach wären alle Einzelpendel voneinander entkoppelt. Mit Δqq = v cos ωt nach Kapitel 3
folgen unmittelbar die Eigenwerte
ω1 = 4,1622 rad/s, ω2 = 8,3218 rad/s, ω3 = 8,3218 rad/s .
Das linearisierte System ist also bezüglich der Gleichgewichtslage grenzstabil (schwach stabil).
Aufgrund der Entkopplung müssten wir z. B. ein Nebenpendel anfänglich auslenken können, so
dass es mit seiner Eigenkreisfrequenz schwingt, ohne die anderen dadurch anzuregen. Wir wollen
klären, ob dies auch für das nichtlineare System gilt und geben die speziellen (kleinen) Anfangs-
werte
ϕ1 = ϕ3 = 0, ϕ2 = 1/18 · π, ϕ̇i = 0
vor. Die sich einstellenden Schwingungen sind in Bild 8.34 dargestellt. Demnach verhält sich das
nichtlineare System nur über ein kurzes Zeitintervall 0 ≤ t < 10 s wie das lineare System. Das
linearisierte Modell gibt offensichtlich die Schwingungen falsch wieder.
Bild 8.34: Nichtlineare Schwingungen nach kleinen Anfangsauslenkungen, ϕi (t) in rad
Die L JAPUNOVschen Stabilitätssätze, vgl. [9], lösen das Problem. Wir geben eine allgemeine
Formulierung an:
• Ist das zu M (qq)q̈q = f (qq, q̇q) linearisierte System asymptotisch stabil bzw. instabil, so ist auch
das nichtlineare System asymptotisch stabil bzw. instabil.
• Ist das linearisierte System grenzstabil, wie hier, so erhalten wir keine Aussage über die
Stabilität des nichtlinearen Systems. Die Terme höherer Ordnung in der TAYLOR-Reihe
entscheiden das Stabilitätsverhalten.
Damit ist das obige Ergebnis erklärbar. Es lässt sich aber auch anschaulich verdeutlichen: Da die
Frequenz des anfänglich ausgelenkten Nebenpendels mit der Eigenfrequenz des anderen Neben-
pendels und mit der zweifachen Eigenfrequenz des Hauptpendels schwingt, werden letztere im
richtigen Takt angeregt, so dass es zu den aufschaukelnden Schwingungen, zunächst bezüglich
des Hauptpendels ϕ1 , wie in Bild 8.34, kommen muss. Es findet ein permanenter Energieaus-
tausch statt, wie dies auch in Bild 8.35 für die großen Anfangswerte
ϕ1 (0) = 0, ϕ2 (0) = ϕ3 (0) = π, ϕ̇i (0) = 0, indifferente Gleichgewichtslage

zu beobachten ist. Die Nebenpendel ϕ2 , ϕ3 überschlagen sich mehrfach. Eine Wiederholung der
Schwingung, also eine Periodizität, ist nicht erkennbar. Die Schwingungen zeigen chaotisches
Verhalten.
Bild 8.35: Nichtlineare Schwingungen nach großen Anfangsauslenkungen, ϕi (t) in rad
Anschaulicher wird der Vorgang in einer Animation. Bild 8.36 zeigt eine Momentaufnahme
eines solchen Vorgangs. Die simulierten Bewegungen stimmen quantitativ mit experimentellen
Ergebnissen am Demo-Modell nach Bild 8.31 überein.
8.5.6 Vorwärtsdynamik mit SimMechanics

Zu 5.: Aufbauend auf den Grundlagen aus Kapitel 7 soll anhand des Block-Diagramms nach
Bild 8.38 mit den zugrunde gelegten Koordinaten nach Bild 8.37 die physikalische Modellierung
des Dreifachpendels – offenes Schleifensystem – mit den wesentlichen Elementen und Funktio-
nen erläutert werden.
Das Pendel setzt sich aus drei Starrkörpern zusammen, die durch Drehgelenke miteinander
verbunden sind. Jedem Körper ist ein Body Block, vgl. Bild 8.38, zuzuordnen. Massen mi und
Trägheitsmomente Ci sind aus Tab. 8.3 in die Block-Dialog-Box zu übertragen, wobei die nicht
aufgeführten Trägheitsmomente A j , B j , j = 1, 2, 3 unwesentlich sind, da sie die Bewegung
nicht beeinflussen, sie sind aber auch nicht bekannt. Insofern ist die Darstellung in Form des
Trägheitsellipsoids im Visualisierungsfenster, vgl. Bild 8.37, nicht aussagekräftig. Darüber hin-
aus müssen mindestens die Schwerpunkte und die Gelenkpunkte in ausgewählten Koordinaten-
systemen angegeben werden. Zusätzliche Punkte dienen nur zur Vervollständigung des Modells
im Visualisierungsfenster, siehe Kapitel 7. Bezüglich der gewählten körperfesten Koordinaten-
systeme gehen wir von der Darstellung des Pendels im Visualisierungsfenster nach Bild 8.37 mit
eingeblendeten Koordinatensystemen aus. Das Inertial- oder World-System liegt in 01 , mit ihm
fällt der Ursprung des körperfesten 1 CS1(World)-Systems zusammen. Gegenüber diesem Sys-
tem sind Schwerpunkt 1 CG und Gelenkpunkte 02 , 03 des Hauptpendels, wie in Bild 8.37 gezeigt,
408 8 Projekte
Bild 8.36: Momentaufnahme der Animation mit Drei_P1.m
Bild 8.37: Koordinatensysteme zum Dreifachpendel im Visualisierungsfenster von SimMechanics
festzulegen. Z. B. bezeichnet 1 CS2(1 CS1) das Koordinatensystem 1 CS2 mit dem Ursprung in 02
festgeschrieben in 1 CS1. Dementsprechend können wir die zugehörigen Ortsvektoren
1 CS2(1 CS1): 1r CS2 = [−, 0, 0]T

1 CS3(1 CS1): 1r CS3 = [, 0, 0]T
1 CG(1 CS1) : 1r CG = [0, −s1 , 0]T
angeben, sie sind in der Dialog-Box einzutragen. Zur Festlegung der körperfesten Koordinaten-
systeme der Nebenpendel übernehmen wir zunächst die angrenzenden (adjoining) 1 CS2- und
1 CS3-Systeme, vgl. Eintrag in der Dialog-Box. Wir erhalten die körperfesten Systeme 2 CS1 und
3 CS1 der beiden Nebenpendel. In diesen Systemen sind die Schwerpunktslagen 2 CG, 3 CG mit
2,3r CG = [0, −s2,3 , 0]T
festzuschreiben.
Jedem Drehgelenk ist nach Bild 8.38 ein Revolute Block zuzuordnen. Die Drehrichtungen
aus Bild 8.31 sind in der Dialog-Box zu verwirklichen, d. h. wir müssen eine Drehung um die
Bild 8.38: Physikalische Modellierung des Dreifachpendels mit SimMechanics; Drei_Psm.mdl
negative z-Achse erreichen: (0, 0, -1). Darüber hinaus besteht in 01 eine Anbindung zur Umge-
bung, was wir durch den Ground Block modellieren müssen. Ab SimMechanics 2 ist stets einem
Ground Block der Maschine ein Machine Environment Block zuzuordnen. Die Dialogbox enthält
Einträge u. a. bezüglich des Gravitationsvektors und der Analyse-Methode, wie z. B. Forward
dynamics oder Inverse dynamics, vgl. Kapitel 7.
Da die oben eingebrachte Ausgangslage eine Gleichgewichtslage ist, müssen wir für die ak-
tuellen Anfangswerte der Körper Joint Initial Condition Blöcke verwenden. Messungen der Ge-
lenkwinkel (hier: Relativwinkel) werden mit den Joint Sensor Blöcken vorgenommen, sie stellen
die Schnittstelle zur Simulink-Umgebung her.
Um die Simulation im Visualiesierungsfenster zu verfolgen, ist u. a. im Fenster: Simulati-
on/Configuration Parameters unter SimMechanics/Visualization das Visuali-
sierungsfenster zu aktivieren, vgl. Kapitel 7.
Die Simulationsergebnisse aller behandelten Methoden stimmen bei nicht überschlagenden
Pendeln sehr gut überein. Überschlagen sich die Pendel, dann können nur innerhalb eines klei-
nen Zeitfensters 0 ≤ t ≤ 20 s bei hoher Genauigkeit, z. B. RelTol 1*10−6 , gute Übereinstim-
mungen erreicht werden. Auch bei leicht abweichenden Anfangswerten in den einzelnen Metho-
den unterscheiden sich die Schwingungen immer stärker mit fortschreitender Zeit. Diese Abwei-
chungen sind systembedingt: kleinste Integrationsfehler (Störungen) führen zu völlig anderem
Schwingungsverlauf. Dies ist einerseits auf die fehlende Dämpfung, andererseits aber auf das
410 8 Projekte
Bild 8.39: Modell zur inversen Dynamik; Drei_Psm_I.mdl
chaotische Verhalten zurückzuführen. D. h. geringfügig veränderte Anfangswerte führen zu völ-

lig anderen Bewegungsabläufen. Darüber hinaus beeinträchtigt die Stabilisierungsmethode, siehe
Abschn. 5.4.4.1, die Dynamik des SimMechanics-Modell.
8.5.7 Inverse Dynamik

Zu 5.: Anhand des Dreifachpendels wollen wir den Begriff der inversen Dynamik klären. Ausge-
hend von festgeschriebenen Bewegungen des Haupt- und der Nebenpendel sind die daraus resul-
tierenden Gelenkmomente zu ermitteln. Dies können wir einerseits recht einfach mit Hilfe der
beiden analytisch gewonnenen Bewegungsgleichungen, andererseits mit einem modellbasierten
Entwurf unter SimMechanics erreichen. Wir wählen die zweite Vorgehensweise. Hierzu gehen
wir von einer statischen Hauptpendel-Schrägstellung um ϕ10 = π/8 und einer gleichförmigen Ro-
tationsbewegung ϕ j0 = (−1) j ( j −1)Ωt, j = 2, 3 der Nebenpendel aus. Die dadurch verursachten
Gelenkmomente sind zu bestimmen, wobei das bisherige Block-Modell nach Bild 8.38 geringfü-
gig zu modifizieren ist. An die Stelle der IC Blöcke treten Simulink-Elemente zur Realisierung
der Zwangsbewegungen – Winkel, Winkelgeschwindigkeit, -beschleunigung. Die Anbindung an
die Drehgelenke erfolgt schließlich mit Joint Actuator Blöcken. Der konstante Anteil bezüglich
des Hauptpendels ergibt sich nach Bild 8.39 unmittelbar. Die gleichförmigen Drehungen der Ne-
benpendel fassen wir im Subsystem Drehbewegung zusammen, (−1) j ( j − 1)Ω , j = 2, 3 wird
8.6 Hubschwingungen eines Viertelfahrzeugs mit nichtlinearem Stoßdämpfer 411
Bild 8.40: Momentenverläufe mittels inverser Dynamik unter SimMechanics; Drei_Psm_I.mdl
über die zugehörige Parameter-Dialog-Box eingegeben.

Im Machine Environment Block ist letztendlich die Analyse-Methode Inverse dynamics aus-
zuwählen. In Bild 8.40 sind die Gelenkmomente m0 j in den Drehpunkten 0 j dargestellt. Ent-
sprechend der vorgegebenen gleichförmigen Drehung mit den Kreisfrequenzen Ω1 = 1 rad/s und
Ω2 = 2 rad/s erzeugen die Nebenpendel 2π- bzw. π-periodische Momentenverläufe. Diese Antei-
le sind im Wesentlichen dem konstanten Moment infolge des Hauptpendelgewichts, verursacht
durch die Schräglage ϕ10 = π/8, überlagert.
8.6 Hubschwingungen eines Viertelfahrzeugs mit nichtlinearem

Stoßdämpfer
Schlagworte: Differenzial-algebraische Gleichungen, eventgesteuertes Modell, strukturvariables
System, Schaltfunktion, Stoßmodelle, Programmier-Tipps
Programme: fahrz.m, ffahrz.m, efahrz.m
Bild 8.41: Viertelfahrzeugmodell mit nichtlinearem Stoßdämpfer
Das skizzierte Viertelfahrzeugmodell (Aufbau mA , Rad mR ) bewegt sich über eine unebene Fahr-
bahn u(t). Die Reifencharakteristik wird durch ein lineares Feder-Dämpfer-Element (kR , dR )
berücksichtigt. Der Stoßdämpfer aus [12] hat nach Bild 8.41 nichtlineares und unstetiges Verhal-
ten, die Fahrzeugfeder (kA ) sei linear. Die in Bild 8.41 verwendeten Fahrzeugkoordinaten von
412 8 Projekte
Aufbau (A) und Rad (R) sind:

xA , xR Auslenkung aus entspannter Feder
yA , yR Inertialkoordinaten
l0 , lR0 Längen der entspannten Federn.
Der hydraulische Stoßdämpfer wird nach [12] außerhalb des Sättigungsbereiches vD < vlim mit-
tels eines geschwindigkeitsabhängigen Dämpfungskoeffizienten
c1 (vD − α)
d(vD ) = ' + c2 , für vD < vlim , vD = ẋD − ẋR (8.79)
vD − α 2
α 1+
α
approximiert, wobei
α Übergangsparameter, α > 0 stetiger Verlauf von d(vD ), vgl. Bild 8.41
c1 = (de − dc )/2, c2 = (de + dc )/2.
Damit gilt für die viskose Dämpferkraft

d(vD )vD für vD < vlim
FDD = . (8.80)
d(vlim )vlim + db (vD − vlim ) für vD ≥ vlim
Dies ist eine stückweise stetige Kennlinie. Der Umschaltpunkt vD = vlim ist zustandsabhängig.
Die Stoßdämpferelastizität wird durch eine progressive Federcharakteristik
FDF = kD1 x + kD2 x3
beschrieben. Alle weiteren Feder- und Dämpferelemente seien linear. Die Fahrbahn wird punktu-
ell nachgefahren, so dass wir anschaulich von einem stehenden Fahrzeug mit Radanregung u(t)
ausgehen wollen. Die Reifenverformung wird durch ein K ELVIN -VOIGT-Modell berücksichtigt;
dies ist nur bedingt geeignet, wie später gezeigt.
Es soll das Schwingungsverhalten insbesondere mit Abhebephasen des Rades in einer Simu-
lation unter MATLAB untersucht werden. Hierzu sind die folgenden Punkte zu bearbeiten:
1. Bewegungsgleichungen für die Zustände mit und ohne Bodenkontakt des Rades sowie die
zugehörigen Schaltfunktionen bezüglich der Unstetigkeit in der Dämpferkennlinie und des
Abhebe- und Auftreffpunktes des Rades.
2. Erstellen eines M-Files für das eventgesteuerte differenzial-algebraische Modell.
3. Diskussion der Simulationsergebnisse. Beurteilung des Stoßkraftverlaufs beim Abheben
und Aufsetzen.
Die zugehörigen Lösungen sind in [52], Kap. 8 zu finden.
8.7 Dynamik des Levitron-Kreisels 413
8.7 Dynamik des Levitron-Kreisels
Schlagworte: Gyroskopisches System, komplexe Bewegungsgleichungen, Übergang auf neue Va-

riable, instabiles System, drehzahlabhängige Eigenwerte, Stabilisierungseffekte
Programme: Levitron.m, Levitron_D.m
Das abgebildete Kreisel-System besteht aus einem Basis- und einem

Kreisel-Permanentmagneten aus Keramik, die gleichpolig (abstoßend)
angeordnet sind [16], [32], [38]. Der Kreisel wird anfänglich auf einer
Lifterplatte, die zunächst auf dem Basismagnet liegt, zentrisch in Rota-
tion versetzt. Danach wird der Kreisel mit der Lifterplatte so weit an-
gehoben, bis er frei schwebt, die Lifterplatte kann entfernt werden. Der
Vorgang ist in vielen Videos festgehalten, z. B.
http://www.youtube.com/watch?v=iv8msBamA3M.
Wesentliche Systemgrößen sind die Magnetfeldstärke, die Kreiselpara-
meter (veränderbar durch Trimmscheiben) sowie die Temperatur und
eine präzise Ausrichtung des Basismagneten. Levitron-Kreisel
Für den permanentmagnetisch gelagerten Levitron-Spielzeug-Kreisel ist der Einfluss der Win-
kelgeschwindigkeit Ω bezüglich der Figurenachse auf das instabile Lagerungsprinzip – vgl. fol-
gende Skizze – zu untersuchen. Dabei wird von einem linearisierten Modell nach [19] für kleine
Schwingungen um die Gleichgewichtslage ausgegangen. Der schnelle Kreisel hat somit 5 Frei-
heitsgrade, nämlich die drei Verschiebungen x, y, z und die beiden Drehungen α, β um die
Kreiselquerachsen. Mit dem Lagevektor
y = [x, y, α, β , z]T
erhalten wir nach [19] für das dämp-

fungsfreie MGK-System die Bewegungs-
gleichung
M ÿy + Gẏy + Ky = 0 ,
M = diag(m, m, A, A, m), MT = M, (8.81)
der schiefsymmetrischen gyroskopischen Matrix

⎡ ⎤
0 2,2 0 2,2 0 2,1
0 ΩC
G = ⎣ 0 2,2 G̃ G 0 2,1 ⎦ , G̃G = , G T = −G
G (8.82)
−ΩC 0
0 1,2 0 1,2 0
sowie der symmetrischen Steifigkeitsmatrix

⎡ ⎤
K r K ϕr 0 2,1
K = ⎣ K Tϕr K ϕϕ 0 2,1 ⎦ , K T = K (8.83)
0 1,2 0 1,2 kz
414 8 Projekte
mit den Submatrizen

kr 0 0 kϕr kϕϕ 0
Kr = , K ϕr = , K ϕϕ = , (8.84)
0 kr −kϕr 0 0 kϕϕ
wobei wegen der Symmetrie u. a. des Magnetfeldes
kr := kx = ky ; kϕr := −kαy = kβ x ; kϕϕ = kαα = kβ β . (8.85)
Parameter nach [19]
Kreiselmasse m = 20 10−3 kg
Trägheitsmomente A = 1,32 10−6 kg m2
C = 2,20 10−6 kg m2
Axial-Steifigkeit kz = 0,82 N/m
Radial-Steifigkeit kr = −0,43 N/m
Kipp-Steifigkeit kϕϕ = −8,6 10−3 Nm/rad
Koppel-Steifigkeit kϕr = 0,11 N/rad
Folgende Punkte sind zu bearbeiten:
1. Bereiten Sie die Bewegungsgleichung für eine numerische Stabilitätsuntersuchung mit Hil-
fe der Eigenwerte auf. Berücksichtigen Sie dabei, dass ein rotationssymmetrisches Problem
vorliegt.
2. Berechnen Sie die Eigenwerte in Abhängigkeit von Ω für den Bereich 0 ≤ Ω ≤ 220
rad/s.
3. Stellen Sie die Eigenwerte in der komplexen Ebene mit Ω als Kurvenparameter (Eigenwert-
kurven) grafisch dar und beurteilen Sie die Stabilität.
4. Berechnen Sie die freien Schwingungen nach einer kleinen Störung der Gleichgewichtslage
bei Ω = 96, 98, 180 rad/s und stellen Sie die Zeitverläufe grafisch dar. Beurteilen Sie das
Schwingungsverhalten.
5. Wie wirkt sich eine äußere Dämpfung auf die Stabilität aus?
Die vollständige Lösung ist in [52], Kap. 8 zu finden.
8.8 Balancierender Roboter
Schlagworte: Modellbeschreibung räumlicher Systeme, differenzial-algebraische Gleichungen

mit nichtholonomen Bindungen, Übergang auf Minimalkoordinaten, instabile nichtlineare Stre-
cke, Linearisierung, nicht vollständig steuerbare Strecke, erste Stabilisierung, Regeleingriff
Programme: Balanc_Robot_Sym.m, Balanc_Robot_UeM.m, Balanc_Robot_Lin.m,
Balanc_Robot_Stab.m, Balanc_Robot_Sim.m
8.8 Balancierender Roboter 415
Bild 8.42: Aufbau des balancierenden Roboters
8.8.1 Motivation
Vielerorts wird an der Entwicklung mobiler Roboter gearbeitet. Auf den balancierenden Robo-
ter2 nach Bild 8.42 und [37] sollen die hier dargestellten Methoden zur mathematischen Modellie-
rung angewendet werden. Wesentlich soll eine systematische Herleitung und symbolische Um-
setzung in MATLAB der nichtlinearen Bewegungsgleichungen dieses räumlichen Modells sein.
Bezüglich der Stabilisierung werden erste Reglerentwürfe diskutiert. Die Parametrisierung er-
folgte in Anlehnung an [37] und ist in Balanc_Robot_Stab.m [52] festgeschrieben.
8.8.2 Modellvoraussetzungen und Annahmen

Das Roboter-Modell3 setzt sich nach Bild 8.42 aus fünf starren Körpern: Kugel K, Aufsatz A
sowie den drei Omniwheels W1 , W2 , W3 (Räder mit spezieller Radkonstruktion) zusammen. Die
unabhängig voneinander angetriebenen Omniwheels übertragen konstruktivbedingt nur tangen-
tiale Umfangskräfte auf die Kugel, quer hierzu werden keine Kräfte übertragen.
Die Rollbewegung der Kugel und das Abrollen von Kugel und Omniwheels sollen schlupffrei
ablaufen. D. h. die Tangentialgeschwindigkeiten in den jeweiligen Kontaktpunkten der Körper
stimmen überein. Dies führt auf holonome bzw. nichtholonome Bindungen.
Um die Komplexität des Modells einzuschränken, sind einige Vereinfachungen, die nicht die
Vorgehensweise der Modellbildung betreffen, eingeführt worden: Die Trägheitstensoren der star-
ren Körper, insbesondere der des Aufsatzes, seien diagonalförmig und jeweils auf den Schwer-
punkt bezogen. Zur Dämpfung der Rollbewegung der Kugel werden sehr einfache Dämpfungs-
bzw. Reibmodelle, die im Kontaktpunkt P wirken, eingeführt. Grund ist, dass im eingeschwun-
genen Zustand keine Sonderfälle numerisch abzufangen sind. Alle Bindungen sind zweiseitige,
2 Anregung von: R. Dessort, z. Z. Student an der TU-München
3 http://spectrum.ieee.org/automaton/robotics/robotics-software/042910-a-robot-that-balances-on-a-ball
416 8 Projekte
u. a. kann dadurch der Aufsatz die Kugel nicht verlassen. Es können damit nur verträgliche Aus-
lenkungen simuliert werden.
Wie unschwer zu erkennen ist, liegt ein instabiles System vor, welches durch einen Regelein-
griff über die Omniwheels stabilisiert werden muss. In einem ersten Entwurf bilden wir die hier-
für erforderlichen Stellmomente einerseits mit den messbaren Kugelwinkelgeschwindigkeiten
ζ̇ , η̇, ϑ̇ und andererseits mit den Motor-Winkelgeschwindigkeiten ϕ̇1 , ϕ̇2 , ϕ̇3 der Omniwheels.
Die Gewichtungskoeffizienten dieser Rückführungen ermitteln wir nach der LQ-Methode. Auf
eine gezielte (geplante) Bewegung des Roboter-Modells, z. B. über eine Sollwertvorgabe oder
eine Trajektorienplanung, wird nicht eingegangen. Beispielsweise: Durch überlagerte Motor-
Winkelgeschwindigkeiten werden Richtung, Geschwindigkeit und Drehung um die eigene Achse
festgelegt. Z. B. für eine geradlinige Bewegung müssen zwei Rädern gleiche Winkelgeschwindig-
keiten überlagert werden.
8.8.3 Herleitung der Bewegungsgleichungen

Die Bewegungsgleichungen werden mit den L AGRANGEschen Gleichung aufgestellt. Alternativ
bietet sich die N EWTON -E ULER-Methode nach Abschn. 2.4 an. Da es sich um ein System mit
holonomen und insbesondere mit nichtholonomen Bindungen handelt, müssen die L AGRAN -
GE schen Gleichungen 1. Art nach Abschn. 5.4.3.1 herangezogen werden. Zweckmäßiger Weise
sollen die so gefundenen differenzial-algebraischen Gleichungen in gewöhnliche Differenzial-
gleichungen bezüglich Minimalkoordinaten symbolisch bzw. numerisch überführt werden. Da
die Energiebilanzen und die damit hergeleiteten Elemente der Bewegungsgleichungen, Massen-
matrizen und Vektorfunktionen, erheblichen Umfang annehmen, ist es rechentechnisch vorteil-
haft jeden Körper für sich zu betrachten. Die endgültigen Elemente, wie Massenmatrix usw.,
setzen sich dann additiv aus den Teilergebnissen zusammen.
Koordinaten: Das Inertialsystem (I-System) I x, I y, I z liegt in der Rollebene der Kugel. Die körper-
festen Koordinatensysteme beziehen sich auf die jeweiligen Schwerpunkte SK , SA , SWi , i=1, 2, 3.
Die fünf freien starren Körper mit jeweils sechs Freiheitsgraden werden durch die Bindungen
• Anbindung der Kugel an die Ebene: eine holonome Bindung
• Rollbedingungen der Kugel: zwei holonome Bindungen
• Anbindung des Aufsatzes an die Kugel: drei holonome Bindungen
• Anbindung der Omniwheels an den Aufsatz: fünfzehn holonome Bindungen
• Rollbedingung zwischen Kugel und Omniwheels: drei nichtholonome Bindungen
eingeschränkt. Das Modell hat nach (5.78) somit f = 5 · 6 − 24 sechs Freiheitsgrade. Bis auf
die drei nichtholonomen Bindungen, die nur den Geschwindigkeitszustand einschränken, ließen
sich die restlichen holonomen, skleronomen Bindungen direkt bei der Aufstellung der Bewe-
gungsgleichungen einarbeiten. Wir werden die zwei holonomen Bindungen der Kugel, die ein
schlupffreies Abrollen festschreiben, sowie die drei nichtholonomen Bindungen davon ausschlie-
ßen. Die Bewegungen lassen sich dann mit elf verallgemeinerten Koordinaten beschreiben:
p = [ xSK , ySK , ζ , η, ϑ , α, β , γ , ϕ1 , ϕ2 , ϕ3 ]T . (8.86)

Kugel Aufsatz Wheels
Die vollständige Ausarbeitung mit Diskussion der Ergebnisse ist in [52], Kap. 8 nachzulesen.
Literaturverzeichnis
[1] MATLAB & Simulink , Release Notes for R2011a, PDF Documents aller Toolboxen, vgl.
Online-Hilfe. The MathWorks, Inc., 2011.
[2] Angermann, A.; Beuschel, M.; Rau, M.: MATLAB-Simulink-Stateflow. Oldenbourg Verlag,
München, 6. Auflage, 2009, ISBN 10: 9783486589856.
[3] Arnold, M.: Zur Theorie und zur numerischen Lösung von Anfangswertproblemen für differentiell-
algebraische Systeme von höherem Index. VDI-Verlag, Fortschr. Ber., VDI, Reihe 20, Nr. 264,
Düsseldorf, 1998.
[4] Babitsky, V. I.; Krupenin, V. L.: Vibration of Strongly Nonlinear Discontinuous Systems. Springer
Verlag, Berlin, 2001, ISBN 3-540-41447-9.
[5] Baumgarte, J.: Stabilization of Contraints and Integrals of Motion in Dynamik Systems. Comp.
Math. in Appl. Mech. and Eng. 1 pp. 1-16, 1972.
[6] Bestel, D.: Analyse und Optimierung von Mehrkörpersystemen. Springer Verlag, Berlin, 1994,
ISBN 3-540-57735-1.
[7] Betzler, K.: Graphik-Workshop. 2004. http://optmat.physik.uni-osnabrueck.de/

Skripten.
[8] Beucher, O.: MATLAB und Simulink. Pearson Studium, München, 4. Auflage, 2008,
ISBN 10: 9783827373403.
[9] Bremer, H.: Dynamik und Regelung mechanischer Systeme. B. G. Teubner Verlag, Stuttgart, 1988,
ISBN 3-519-02369-5.
[10] Brenan, K. E.; Campbell, S. L.; Petzold, L. R.: Numerical Solution of Initial-Value Problems in
Differential Algebraic Equations. Vol. 14 of Classics in Applied Mathematics, SIAM, Philadelphia,
PA, 1996.
[11] Brommundt, E.: Ein Reibschwinger mit Selbsterregung ohne fallende Reibkennlinie. ZAMM, 75,
11, S. 811-820, 1995.
[12] Cebon, D.: Handbook of Vehicle-Road Interaction. Swets & Zeitlinger B.V., 1999.
[13] Cellier, F. E.: Continuous System Modeling. Springer Verlag, Berlin, 1991, ISBN 0-387-97502-0.
[14] Dormand, J.; Prince, D.: Practical Runge-Kutta processes. SIAM J. Sci. Compt. 10(5), p 977-989,
1989.
[15] Eich-Soellner, E.; Führer, C.: Numerical Methods in Multibody Dynamics. B. G. Teubner Verlag,
Stuttgart, 1998, ISBN 3-519-02601-5.
[16] Faupel, D.; Groba, M.: Levitron geklont. www.myquilt.de/al/physalt/levitron/

levitron.htm.

DOI 10.1007/978-3-8348-8630-9,
418 Literaturverzeichnis
[17] Fischer, U.; Stephan, W.: Mechanische Schwingungen. Fachbuchverlag Leipzig GmbH, Leipzig,
1993, ISBN 3-343-00841-9.
[18] Gasch, R.; Knothe, K.: Strukturdynamik Bd 1/2. Springer Verlag, Berlin, 1987,
ISBN 0-387-16849-4.
[19] Gasch, R; Lang, M.: Levitron – ein Beispiel für die rein permanentmagnetische Lagerung eines
Rotors. ZAMM 80, 2, S. 137-144, 2000.
[20] Gekeler, E. W.: Mathematische Methoden zur Mechanik. Springer Verlag, Berlin, 2006,
ISBN 3540302670.
[21] Genta, G.: Vibration of Structures and Machines. Springer Verlag, Berlin, 1999,
ISBN 0-387-98506-9.
[22] Géradin, M.; Rixen, D.: Mechanical Vibrations, Theory and Application to Structural Dynamics.
Wiley, 1994, ISBN 0-471-93927-7.
[23] Glocker, C.: Dynamik von Starrkörpersystemen mit Reibung und Stößen. Dissertation, Lehrstuhl B
für Mechanik, TU München, 1995.
[24] Gramlich, G.: Eine Einführung in MATLAB. Hochschule Ulm, 2011. www.hs-ulm.de/
/users/gramlich/EinfMATLAB.pdf.
[25] Gulley, N.: Picking up the Pace with the MATLAB Profiler. MathWorks, MATLAB News &
Notes (Mai 2003), The MathWorks, Inc, 2003. http://www.mathworks.com/company/
newsletters/news_notes/may03/profiler.html.
[26] Gulley, N.: Working with Cell Mode in MATLAB 7. MathWorks, MATLAB News & Notes
(Dec. 2004), The MathWorks, Inc, 2003. http://www.mathworks.de/company/
newsletters/news_notes/dec04/cellmode.html.
[27] Hairer, E.; Wanner, G.: Solving Ordinary Differential Equations II. Springer Verlag, Berlin, 1991.
[28] Hatch, M. R.: Vibration Simulation Using MATLAB and ANSYS. Chapman & Hall, London, 2001.
[29] Heimann, B.; Gerth, W.; Popp, K.: Mechatronik. Carl Hanser Verlag, Leipzig, 2. Auflage, 2001,
ISBN 3-446-18719-7.
[30] Hoffmann, J.: MATLAB und Simulink: Beispielorientierte Einführung in die Simulation dynamischer
Systeme. Addison-Wesley, Bonn, 1998, ISBN 3-8273-1077-6.
[31] Hoffmann, J.; Brunner, U.: MATLAB und Tools. Addison-Wesley, Bonn, 2002, ISBN 3-8273-1895-5.
[32] Hones, W. G.: How the Levitron Works. http://www.fascinations.com/

LevitronScience.htm.
[33] Kauderer, H.: Nichtlineare Mechanik. Springer Verlag, Berlin, 1958.
[34] Kautsky, J.; Nichols, N. K.: Robust Pole Assignment in Linear State Feedback. Int. J. Control 41 pp
1129-1155, 1985.
[35] Kessel, S.; Fröhling, D.: Technische Mechanik. B. G. Teubner Verlag, Stuttgart, 1998.
Literaturverzeichnis 419
[36] Kopka, H.: LaTex, Bd. 1: Einführung. Addison-Wesley, Bonn, München, 2005, ISBN 3827370388.
[37] Kumagai, K.; Ochiai, T: Development of a Robot Balanced on a Ball. Journal of Robotics and
Mechatronics, Vol. 22 No. 3, 2010.
[38] Levitron. Levitron Homepage. http://www.levitron.de/.
[39] Lunze, J.: Regelungstechnik 1. Springer Verlag, Berlin, 1996, ISBN 3-540-61404-4.
[40] Lunze, J.: Regelungstechnik 2. Springer Verlag, Berlin, 1997, ISBN 3-540-61898-8.
[41] Moler, C.: Numerical Computing with MATLAB. SIAM, Philadelphia, 2004, ISBN 0-89871-560-1.
www.mathworks.com/moler/.
[42] Müller, P. C.; Lückel, J.: Zur Theorie der Störgrößenaufschaltung in linearen Mehrgrößenregelsyste-
men. Regelungstechnik, 25, S. 54-59, 1977.
[43] Müller, P. C.: Stabilität und Matrizen. Springer Verlag, Berlin, 1977, ISBN 3-540-07981-5.
[44] Müller, P. C.; Schiehlen, W.: Lineare Schwingungen. Akademische Verlagsgesellschaft, Wiesbaden,
1976.
[45] Otter, M.; Elmqvist, H.; Mattson, S. E.: Objektorientierte Modellierung Physikalischer Systeme, Teil
8. at-Automatisierungstechnik 48, R. Oldenbourg Verlag, 2000.
[46] Otter, M.: Modeling Friction in Modelica with the Lund-Grenoble Friction Model. 2. International
Modelica Conference, Proceedings, pp 285-294, 2002. http://www.Modelica.org/
events/conference2002.
[47] Pelz, G.: Modellierung und Simulation mechatronischer Systeme. Hüthig, Heidelberg, 2001,
ISBN 3-7785-2848-3.
[48] Pfeiffer, F.; Glocker, C.: Multibody Dynamics with Unilateral Contacts. Springer Verlag, Berlin,
2000, ISBN 3-211-83330-7.
[49] Pfeiffer, F.: Einführung in die Dynamik. B. G. Teubner Verlag, Stuttgart, 2. Auflage, 1992,
ISBN 3-519-12367-3.
[50] Pietruszka, W. D.; Wagner, N.: Aktive Beeinflussung des Schwingungsverhaltens eines magnetisch
gelagerten Rotors. VDI-Berichte Nr. 456, 1982.
[51] Pietruszka, W. D.: Digitale Regelung und Störgrößenkompensation magnetisch gelagerter Rotoren.
VDI-Berichte Nr. 550, 1985.
[52] Pietruszka, W. D.: Programmsammlung auf der Homepage zum Buch: MATLAB und Simulink in der
Ingenieurpraxis. Vieweg+Teubner Verlag, Wiesbaden, 2011. www.viewegteubner.de.
[53] Pratap, R.: Getting Started with MATLAB. Oxford University Press, New York, Oxford, 2010,
ISBN -10: 9780199731244.
[54] Rill, G., Schaeffer, T.: Grundlagen und Methodik der Mehrkörpersimulation. Vieweg+Teubner
Verlag, Wiesbaden, 2010, ISBN 978-3-8348-0888-2.
[55] Roddeck, W.: Einführung in die Mechatronik. B. G. Teubner Verlag, Stuttgart, 3. Auflage, 2006,
ISBN 3-8351-0071-8.
420 Literaturverzeichnis
[56] Schiehlen, W.; Eberhard, P.: Technische Dynamik. B. G. Teubner Verlag, Stuttgart, 2. Auflage, 2004,
ISBN 3-519-12365-7.
[57] Schweizer, W.: MATLAB kompakt. Oldenbourg Verlag, München, 3. Auflage, 2009,
ISBN 10: 9783486591934.
[58] Sextro, W. K.; Popp, K.; Magnus, K.: Schwingungen. Vieweg+Teubner Verlag, Wiesbaden,
8. Auflage, 2008.
[59] Shampine, L. F.: Numerical Solution of Ordinary Differential Equations. Chapman & Hall, London,
1994.
[60] Shampine, L. F.; Kierzenka, J. M.; Reichelt, M. W.: Solving Boundary Value Problems for Ordinary
Differential Equations in MATLAB with bcp4c. 2000. http://www.mathworks.com/bvp_
tutorial.
[61] Shampine, L. F.; Reichelt, M. W.: The MATLAB ODE Suite.
[62] Shampine, L. F.; Reichelt, M. W.; Kierzenka, J. A.: Solving Index-1 DAEs in MATLAB and Simulink.
SIAM Review, 41, pp. 538-552, 1999.
[63] Tiller, M.: Introduction to Physical Modeling with Modelica. Kluver Academic Publishers, 2001,
ISBN 0-7923-7367-7.
[64] Ulbrich, H.: Maschinendynamik. B. G. Teubner Verlag, Stuttgart, 1996.
[65] Voss, H.: Numerische Grundlagen der digitalen Simulation dynamischer Systeme. TU
Hamburg-Harburg, Report 19, 1998. www.tu-harburg.de/mat/.
[66] Wittenburg, J.: Schwingungslehre. Springer Verlag, Berlin, 1996, ISBN 3-540-61004-9.
[67] Woernle, C.: Mehrkörpersysteme: Eine Einführung in die Kinematik und Dynamik von Systemen
starrer Körper. Springer Verlag, Berlin, 1. Auflage, 2011, ISBN 10: 3642159818.
[68] Wood, G. D.; Kennedy, D. C.: Simulating Mechanical Systems in Simulink with SimMechanics.
Mathworks, The MathWorks, Inc., 2003. http://www.mathworks.com.
Stichwortverzeichnis
< , <= kleiner, kleiner gleich, 26 – Flächenmodell, 68

\ / Links-, Rechts-Division, 17 – getframe, 68, 76
\n Zeilenumbruch im String, 32 ff, 179 – Linienmodell, 70
&, && Und; Matrix-, Skalar-Vergl., 26 – – komplexe, 72
∼ Negation, 26 – Modellerstellung, 66
’ ’ String, 32 ff, 35, 47, 50 – Movie, 67 f, 70
’ Transposition, konj.-kompl., 17 – Rotorelement, 73
+ − * / \ ˆ Rechenoperatoren, 6 – Schraubenfeder, 71
, ; Abschluss mit/ohne Ausgabe, 6 – Volumenmodell
.’ Transposition, 17 – – cylinder, 77 ff
.* .\ ./ .ˆ elementweise Op., 17 – – ellipsoid, 77
... Zeilenumbruch, 30 – – sphere, 77 ff
. Separator im Structure, 24 ff – Wellenelement, 73
: Doppelpunkt-Operator, 11 ff Anonymous Function, siehe Function
==, ∼= gleich, ungleich, 26 Anstückelmethode, 371
= Zuweisung, 6 Arbeitspunkt, siehe Schwingung, 337
[ ] Matrix-Klammer, 11 ff Ausführbarer Code, Funktionstaste F9, 6
%% Cell Divider, 30 Ausgangsmatrix, 145, 195
%{...%} Kommentarblock, 30
% Kommentarzeile, 30 Backslash-Operator, 20 f
|, || Oder; Matrix-, Skalar-Vergl., 26 Balancierender Roboter, 414 ff
> , >= größer, größer gleich, 26 Basisvektor, 98
{ } Cell Array Element, 25 Befehlsübersicht
– 2D Plot-Befehle, 47
Algebraische Schleife, 205 – 3D-Grafik, 60
– Elimination, 207 – Achs-Skalierung und Grafik-Beschriftung, 49
algebraisches Gleichungssystem, 87, 145, 151, 373 – Color (Grund-, Mischfarben), 56
– inhomogen, 149 f, 155 – Ein- und Ausgabebefehle, Konvertierung, 32
– linear, 378 – Farben, 48
– nichtlinear, 123, 344 – Grafikfenster-Befehle, 46
Amplitudenfrequenzgang, 50, 377 – Linien, 48
Analogiebeziehung, 95 – Linien-, Marker-Spezifikationen und Farben, 56
analytische Lösung, 370 – Logische Operatoren, 26
Anfangswert, 149, 160 – Mathematische Funktionen, 9
– Anpassung, 373 – Operationszeichen, Built-In Variable, Online-Hilfe,
– konsistent, 251, 255, 273, 391 6
Anfangswertproblem, 225, 241, 254 – Optischer Effekt, Ausleuchten, 65
Animation, 66 – Script- und Function-Befehle, 30
– 3D-Modell, 73 – Variablenverwaltung, 8
– Drehbewegung, 76, 80 – Vektor- und Matrix-Formulierung, 11
– Dreifachpendel, 403 – Vektor- und Matrix-Operationen, Built-In Functions,
– EraseMode, 67 ff 17
– – background, 67 – Vergleichsoperatoren, 26
– – none, 67 – Verzeichnis- und File-Verwaltung, 31
– – normal, 67 – Verzweigungen und Schleifen, 27
– – xor, 67 Beobachtbarkeitsmatrix, 360
– Fachwerk, 71 Beobachterentwurf, 367

DOI 10.1007/978-3-8348-8630-9,
422 Stichwortverzeichnis
Beschleunigung, 100, 102 – lsim, 231

Bewegungsgleichung – place, 361, 369
– analytische Methode, 95 – Riccati-Regler, 361
– autonom, 97, 310 – ss Zustandsmodell, 231
– D’Alembert, 115, 243 – step, 160, 231
– explizite Vektor-Form, 97 Corioliskraft, 351
– implizite Vektor-Form, 97 Coulomb-Reibung, 289, 291, 317, 324, 345
– Klassifizierung, 133
– Lagrange, siehe Lagrange Dämpfungsmaß
– linear, 132 – Lehrsches, 147
– Newton-Euler, siehe Newton-Euler – logarithmisches Dekrement, 147
– nichtautonom, 97, 312 Datentyp, 7
– nichtlinear, 125, 233 – class, siehe MATLAB-Befehl
– Normalform, 97 – double, single, int8,..., 7
– synthetische Methode, 95 – sym, siehe Symbolic Math Toolbox
– Trägheitskopplung, 205 Defekt, 91
Bewegungsraum, 61 Desktop
Bifurkationen, 250 – Command History, 2
Bindungen, 252, 262, 338 – Command Window, 2
– Übergang, 269 – Current Directory, 2
– JACOBI-Matrix, 269 – Workspace, siehe Workspace
– Beschleunigungsebene, 254 differenzial-algebraische Gl., 226, 249, 351, 416
– explizit, 95 – DAE, 249
– Geschwindigkeitsebene, 254 – Deskriptorform, 253
– holonom, 268 – Index, 249 ff, 352
– holonom rheonom, 252 – semi-explizit, 254, 257
– holonom skleronom, 252 Differenzialgleichung
– implizit, 95 – autonom, 225
– kinematische, 268 – explizit, 225
– Lageebene, 254 – gewöhnlich, 249
– Mannigfaltigkeiten, 249 – – Index 0, 261
– nichtholonom, 268, 416 – implizit, 225, 227, 272
– Schleifen-Schließbedingung, 262 – kinematische, 253
– versteckte, 255 – kinetische, 253
– Zwangsbedingungen, 252 – linear, 131, 228
Bodenkontakt, 412 – nichtlinear, 233, 243
Butcher-Tabelle, 166 – semi-explizit, 251
Butterworth-Tiefpass, 190, 383 – Steifigkeit, 169
Doppelpendel, 105, 111, 117, 121, 124, 262
C Code S-Function, siehe Simulink Drall, 109 f, 116, 143, 399
Code-Beschleunigung, 42 – Stabilisierung, 143
Code-Erzeugung, 60 Drallsatz, 95, 108 ff, 125, 127
– Show Code, 60 Drehgelenk, 341, 345, 392, 407, 408
Computeralgebra, siehe auch Symbolic Math Toolbox Drehtransformation, 100
– MuPAD, 81 Dreifachpendel, 396
– symbolische Auswertung, 400 Dreipunkt-Schaltlogik, 289, 294, 324
– symbolische Variable, 106 Drift, 259 f, 265, 351 f
Control System Toolbox, 369
– acker, 361, 369 Editor, 30
– bode, 156 ff – Cell divider, 34
– dlqr, 361 Eigenschwingung, 131, 134 ff
– freqresp, 156, 158 Eigenschwingungsform, 138 ff, 144
– impulse, 160, 231 – Schwingerkette, 141
– initial, 231 Eigenwerte, 137 ff, 414
– lqr, 361 Eigenwertproblem, 91, 137 ff, 142, 144, 373 f, 378
– lqry, 361 – condeig, 91
– gewöhnliche, 135 – DefaultLineLineWidth, 45

– in MATLAB, 134 ff – delete, 46
– spezielle, 135 – drawnow, 46, 70, 80
– Stabilitätsaussagen, 137 – ellipsoid, 77
– Zustandsgleichung, 143 – ezplot, 89
Einschrittverfahren, 164 – FaceAlpha, 71
elektrisches Netzwerk, 229 – figure, 46, 50, 56 f, 61, 404
Elementardrehung, 99 f – fill, 67, 71, 404
Elementarwinkelgeschwindigkeit, 101 – fill3, 63, 75
erzwungene Schwingungen, siehe Schwingung – findobj, 45, 53 ff
Euler-Approximation, 37 – fplot, 47
Euler-Winkel, 100 – gca, 44, 49, 56, 139, 404
Event, siehe Unstetigkeit – gcf, 44, 46, 57, 139, 183, 404
– get, 45 ff, 53 ff
Feder-Animation, 80 – gplot, 72
FFT-Analyse, 210 – grid, 49 f, 63
Freiheitsgrad, 104, 416 – Handle Graphics, 53
– holonome Bindung, 266 – hold on, off, 37, 47, 49 f, 61, 75, 241
– nichtholonome Bindung, 268 – interpreter
frequenzmodulierte Schwingung, 377 – – TEX-, LATEX-Mode, 49
Function – legend, 49 f
– Anonymous Function, 41, 241 f – line, 47, 57 f
– clear, 30 – Linien-Eigenschaften, 56
– Function Function, 35 – linkaxes, 51
– Function Functions, 37 – loglog, 47
– Function Handle, 36 – Marker-Eigenschaften, 56
– inline, 30 – mesh, 60, 63, 77
– Kopfzeile, 30 – meshgrid, 60, 63, 68, 241
– Nested Function, 38 – nextplot, 54 ff
– – Parent Function Workspace, 38 – patch, 60, 62 ff
– Schlüsselwort, 35 – plot, 47, 49 f, 56 f, 404
– Standard Function, 35 – plot3, 60 f, 80, 180
Fundamentalmatrix, 145, 158 – plotstil, 47 ff
– – Color, 48 f
Gelenkkräfte, 391 – – Line Style, 48
Geschwindigkeit, 100 – – Marker, 48
– verallgemeinerte, 270 – plottools on/off, 58
Gleichgewichtslage, 123, 131, 149, 160, 200, 337, 340 f, – quiver, 241
394, 397, 413 – rotate, 80
– Linearisierung, 124, 129, 405 – semilogx, 47
Grafik, 2D, siehe Grafik-Befehl – semilogy, 47
Grafik, 3D, siehe Grafik-Befehl – set, 45 ff, 53 ff, 68 ff, 79 ff
Grafik-Befehl, 44, 47, 49, 60 – shg, 46
– Achsen und Beschriftung, 49 – sphere, 77 ff, 80
– Animation, siehe Animation – spy, 16, 47
– axis, 35, 49 f, 61, 76, 140, 404 – stairs, 47
– box, 60 f, 63 – stem, 47
– clf, 46, 47, 50, 57 – subplot, 46 f, 50, 63 f, 139
– close, 46 – surf, 60, 63 f, 68 ff, 74 f, 77 ff
– close all, 46, 89 – surf2patch, 63
– comet, 47 – surfc, 60, 64
– comet3, 60 – surfl, 67
– contour, 60 – text, 49 f, 57
– contour3, 60, 63 – title, 35, 49 f, 183
– cplxroot, 180 – view, 60 f, 63
– cylinder, 77, 78 ff – waterfall, 60, 63
– xlabel, ylabel, 49 f, 57, 61, 89, 183 – Kardangelenk, 105

– xlim, ylim, zlim, 49, 140 – Kugel, 270
– zlabel, 60 f Kaskadenregler, 358
Grafik-Objekt-Hierarchie, 44 Kelvin-Voigt-Modell, 226
Grafikfenster, 46 Kennlinienumschaltung, 284
– figure, siehe Grafik-Befehl Kinematik, 97
– subplot, siehe Grafik-Befehl – Lage, 97
Gravitationsvektor, 340 – Mehrkörpersystem, 103
gyroskopischer Einfluss, 141 – Orientierung, Drehung, 97
– Eigenwerte, 142 Knotenlinie, 99
– Kreiseleinfluss, 143 Kollokation, 303
konservatives System, 136, 203
Handle Graphics, 45, 53 ff – Eigenwerte, 137
Hauptträgheitsmoment, 350 – gyroskopischer Einfluss, 141
Hebelmechanismus, 388 Koordinaten
help, siehe MATLAB-Befehl – abhängige, 95
Help Browser, 4 – generalisierte, 104
Hilfs-Schaltfunktion, 292, 325 – redundante, 252, 262
HTML Dokument, 34 – unabhängige, 95
Hubschwingungen, 411 – verallgemeinerte, 116
Koordinatensystem, 98
I-Anteil, 356 – CS, 338 ff
Impuls, 116, 399 – Inertialsystem (I), 98
Impulssatz, 95, 108, 111, 113, 125 – körperfest (K), 98
Index, 254 – raumfest, 98
instationäre Schwingungen, 377 – World (W), 340
Integralanteil, 362 Kreuzprodukt, 111
Integrationsaufruf, 238 Kurbeltrieb, 262
– Optionen, 238 Kurzschluss-Operator, 27
Integrationskonstante, 140, 373
Integrationsverfahren
Lageregler, 358
– Dormand-Prince, 167
Lagrange, 95, 118, 121
– Einschrittverfahren, 164 f
– Formalismus, 95
– Euler, 168
– Gleichung 1. Art, 252, 271, 388
– – rückwärts, 165
– Gleichung 2. Art, 96, 108, 118, 121, 125, 398
– – vorwärts, 165
– Multiplikator, 253, 351, 388
– explizit, 165, 167
Levitron-Kreisel, 228, 413 ff
– implizit, 165, 167
lineare Gleichungssysteme, 20
– Mehrschrittverfahren, 164 f, 168
– – Adams-Bashforth, 165, 168 – überbestimmtes, 22
– – Adams-Moulton, 165, 168 – Backslash-Operator, 20
– – BDF, 164, 165 – Beispiele, 21
– – NDF, 164 – direkte Methoden, 20 f
– Prädiktor-Korrektor, 165, 168 – Gradientenmethoden, 21
– Runge-Kutta, 164 – iterative Methoden, 21 f
– Trapez-Regel, 167 – Residuen Verfahren, 21
Integratorwahl, 170 – Symmetrisches LQ-Verfahren, 21
– Diskontinuität, 204 – unterbestimmtes, 22
Interaktive Plot-Erstellung, 58 lineare Schwingungsmodelle, 131 ff
inverse Dynamik, 352 Linearisierung, 122, 129, 405
Lissajous-Figuren, 221
Jacobi-Matrix, 108, 115–121
– Zwangsbedingungen, Bindungen, 253 magnetisch gelagerter Rotor, 355
JIT-Accelerator, 5 – aktive Stabilisierung, 356
Jordan-Matrix, siehe Symbolic Math Toolbox MATLAB Function, 35 ff
MATLAB Script, 33 ff
Kardan-Winkel, 99 f MATLAB-Befehl
– abs, 9, 27, 29, 38 f, 42, 138, 154, 158, 218, 286 f, – if Abfrage, 27, 37, 42, 50, 91, 218, 297, 325, 405
297 – imag, 9, 144, 145
– addpath, 31 f – inline, siehe Function
– angle, 9 f – input, 32 f, 180, 286
– asin, 264 – int2str, 32
– atan, atan2, 9, 50 f, 61 f, 151 f – interp1, 241
– bicg, 21 – inv, 17, 91, 154, 158, 264 f, 402
– bicgstab, 21 – isempty, 30, 33, 199
– blkdiag, 117 – length, 17, 50, 91, 117, 144, 151 f, 404
– break, 27 – linsolve, 17, 21, 145
– bvp4c, bvp5c, 303 ff – linspace, 11, 35, 37, 50, 61, 70 f, 73, 140, 145, 151 f,
– bvpinit, 306 160, 241, 374, 402
– bvpset, 306 – load, 8
– cd, 31 – log, log10, 9
– cell, 25 – logspace, 11
– – cellplot, 25 – lookfor, 4, 31 f
– cgs, 21 – lu, 21
– char, 24 – min, max, 17, 61, 138, 297
– chol, 21 – nargchk, 30
– class, 6, 8, 83 – nargin, nargout, 30, 37
– clear, 8, 30 – nthroot, 9
– condeig, 91 – num2str, 32, 35
– conj, 9 f – odeplot, 241
– continue, 27 – odeset, 238 ff, 251, 258, 283
– ctranspose oder ’, 17 – odex, 164 ff
– decic, 257, 261 – odexx, 226, 238 ff
– det, 17, 91 – – ode113, 168, 204
– deval, 241, 307 – – ode15i, 272
– diag, 11 ff, 91, 113 f, 117, 140, 144 f, 258, 342, 374, – – ode15s, 170, 204, 251 ff, 258, 391
391, 401 – – ode23, 283
– diary, 8 – – ode23s, 204
– dir, 31 – – ode23t, 251 ff, 391
– disp, 32, 122, 179 – – ode45, 204, 245, 258, 263
– doc, 4 – ones, 11, 13, 23, 27, 61, 64, 73, 75 f, 241, 273, 404
– Doppelpunkt-Operator, 11 ff – path, 31
– double, 6 f, 16, 25, 83 ff, 93 ff – pause, 32, 70, 404
– eig, 17, 91, 135, 138, 374, 405 – persistent, 30, 36
– eigs, 135, 144 – pi, 6
– end Op., 11, 50, 61, 283, 286, 374 – prod, 17
– eps, 6 – Profiler
– error, 30, 218 – – profile on, 42
– eval, 30, 41, 50, 93 f, 402 – – profile viewer, 42
– exist, 26 – Punktoperation, 132
– exp, 9, 84, 86 ff, 94, 145, 154, 158 f, 374 – – elementweise Verknüpfung, 16
– expm, 145, 160 – pwd, 31
– eye, 11 ff, 91, 108, 117, 144, 158, 195, 374, 401 – qmr, 23
– feval, 30, 36 – quiver, 241
– find, 17 – rand, 11, 15, 84
– fliplr, 11 – rank, 17, 91, 360
– fopen, 32 f – real, 9, 145, 154, 158, 374
– for Schleife, 27, 28 ff, 38, 42, 50 ff, 70, 76 ff – realmax, realmin, 6
– format, 6 – repmat, 11, 14
– fprintf, 32, 179, 325 – return, 30, 33, 37
– global, 30, 36, 218, 245 f, 264, 283, 391 – rmpath, 31 f
– help, 4, 6, 30 – rref, 21
– helpwin, 4 – save, 8
– sign, 9, 218, 286 f – Structure, 24, 286

– sin, cos, 9, 18, 35, 41, 61, 70, 75 f, 86 f, 93, 107 f, – – struct, siehe MATLAB-Befehl
151 f, 264 ff, 391, 404 – Unendlich inf, 6
– single, 6 f, 12, 16, 25, 93 – Value Editor, 3
– size, 17, 61, 73, 75 f, 218 – Variable Editor, 8
– sort, 17, 91, 138, 144 – Variablenverwaltung, 8
– sparse, 11, 15 – Vektor- und Matrix-Formulierung, 11
– sprintf, 32, 50 – Vektor-Operationen, 16
– sqrt, 9, 50, 61, 83 f, 138, 151 ff, 163, 284, 378 f, 405 – Vergleichsoperatoren, 26
– ss, 158 – While-Schleife, 28
– struct, 24 – Workspace Browser, 8
– sum, 17 – Zeichenketten, 24
– switch, 27, 29 Matrixformulierung, 96
– tan, 9 MATRIXx, 1
– tic, toc, 28, 32 Mehrkörpersystem, 95, 335
– transpose oder .’, 17 – Baumstruktur, 267, 351
– vectorize, 94 – geschlossene Schleifen, 351
– what, 31 – mechanisch, 254
– which, 31 – Mehrkörpermodell, 351
– while Schleife, 27, 39, 286 ff – MKS, 95
– who, whos, 8 – offenen Schleife, 256
– xor, 26 – Schleifensystem, 267
– zeros, 11, 13, 23, 28, 117, 144, 151 f, 154, 158, 195, Mehrschrittverfahren, 168
273, 374, 401 Minimalgeschwindigkeiten, 235
MATLAB-Element Minimalkoordinaten, 95, 104, 249, 266
– 3D-Matrix, 23, 152 Mitnahme-Effekt, 313
– Anonymous Function, siehe Function Mitnahme-Effekte, 210
– Ausgabeformat, 6 modellbasierter Entwurf, 391
– Blockdiagonalmatrix, blkdiag, 117 Modellbildung, 95
– Built-In Variable, 6, 8 – Programm-Code, 107 f, 113 ff, 117, 122, 124
– Cell Array, 24 f Multiplikator
– Code Analyzer, Code Check, 35 – Elimination, 260
– Command Window, Fenster, siehe Desktop – Lagrange, siehe Lagrange
– Desktop, 2 MuPAD, 81
– Diagonalmatrix, 13
– – Haupt-, Neben-Diagonalelemente, 14 Nebenbedingung, 249
– Doppelpunkt-Operator, 14 Nested Function, siehe Function
– Einheitsmatrix, 12 Newton-Euler
– Einsmatrix, 12 – Formalismus, 399
– Elementansprechung, 14 – Gleichung, 116
– Elementfolgen, 12 – Methode, 95, 111, 115, 120 f, 126
– Function Handle, siehe Function Newton-Raphson-Verfahren, 123
– global Variable, siehe MATLAB-Befehl – Newton, 29, 39, 344, 394
– Inline Function, siehe Function nichtkonservatives System, 147
– komplexe Variable, 7 nichtlineare Schwingungen, 396
– mathematische Funktionen, 9, 16 Normalkraft, 264
– Matrix-Operationen, 16
– mehrdimensionale Felder, 23 O-Matrix, 1
– Nested Function, 35, 311 objektorientiert, 336
– Not a Number, NaN, 6 Octave, 1
– Nullmatrix, 12 Omniwheel, 415
– Online-Hilfe, 4, 6 Orthogonalmatrix, 99
– Operationszeichen, 6 OutputFcn, 242
– persistente Variable, siehe MATLAB-Befehl
– Profiler, 35, siehe Profiler Parameterempfindlichkeit, 375
– Punktoperation, 132, 147 Partikularlösung, 373
PD Regler, 359 Schwingung

Pendel, 256 – Arbeitspunkt, 131
Permanentmagnet, 355 – chaotisch, 407
Phasenebene, 61, 90, 235, 302 – Eigenschwingung, 131
Phasenfrequenzgang, 50 – erzwungen, 148, 312, 373
physikalische Modelle, 335 – fastperiodisch, 148
PID Regler, 359 – freie, 134, 139, 373
Pkw-Klimaanlage, 353, 386 – – komplexe Formulierung, 144
Plot-Befehle, siehe Grafik-Befehl – harmonisch, 150
Plot-Umgebung, 58 – Impulsantwort, 159
– Figure Palette, 58 – instationär, 132
– Plot Browser, 58 – – Zustand, 242
– plottools on/off, 58 – komplexe Anregung, 153
– Property Editor, 59 – konservatives System, 136
präallozieren, 28, 43 – periodisch, 310, 354
Profiler, 35 – quasiperiodisch, 148
– Report, 42 – selbsterregt, 210, 234, 302, 310
Programm – Sprungantwort, 160
– Cell divider, siehe Editor – subharmonisch, 313
– Code Analyzer, Code Check, 35 Schwingungstilger, 376
– Zellen (Cells), 34 Signalfluss
Projektionsmethode, 352 – bidirektional, 336
Punktoperation, 148 – unidirektional, 320, 336
Signalflussgrafen, 161
Randwertproblem, 303 ff SimMechanics, 335, 393
– Biegelinie, 308 – Body Actuator Block, 340
– bvp4c, bvp5c, 303 – Body Block, 336
– bvpinit, 306 – Body Spring & Damper Block, 340
– bvpset, 306 – Convex hulls, 350
– Drei-Punkt, 308 – Equivalent ellipsoids, 350
– Kettenlinie, 304 – Forward Stiction Limit, 346
– Mehrpunkt, 308 – Ground Block, 336
– periodische Schwingung, 310 ff – Inverse Dynamik, 337, 410
– Zweipunkt-, 303 – Joint Sensor Block, 336, 343
Rangabfall, 91 – Joint Spring & Damper Block, 340
Rangfolgeregel, 23 – Joint Stiction Actuator, 344
Referenzlage, 122 – Kinematics, 337
Reglerstrukturen, 358 – Kinetic Friction, 346
Reglerumschaltung, 356 – Library, 335 f
Reibmodelle, 289 – Machine Environment Block, 337
Reibung, 289, 344 – Massenmittelpunkt CG, 338 ff
– Zweimassenschwinger, 353 – Prismatic Block, 338
Relativkoordinaten, 336, 351 – Reverse Stiction Limit, 346
Resonanz, 246, 378 f – Revolute Block, 342
Richtungsfeld, 241 – Stabilisierung, 266, 351 f
Roboter, 414 – Trimming, 337, 394
rotationssymmetrisch, 414 – – Gleichgewichtslage, 394
Ruhelage, 122 – Visualisierung, 349, 395, 409
Runge-Kutta-Methode, siehe Integrationsverfahren – Vorwärtsdynamik, 337, 341, 407
SimPowerSystems, 335
Schaltfunktion, 277, 285, 325 Simscape
Schaltkoeffizient, 277, 325 – Library, Überblick, 335
Schaltpunkte, 278 Simulationsprogramm, 237
Schließbedingung, 352 Simulink
Schubgelenk, 340 – Algebraic Constraint Block, 205, 252, 258
Schwingerkette, 149 – algebraische Schleife, 162, 184, 205, 252, 327
– Annotations, 176 Stabilisierung, 259, 265

– Band-Limited White Noise, 190 – Baumgarte, 265
– Break Point, 184 – Projektion, 266
– Click Function, 176 Stabilität, 131
– Coulomb and Viscous Friction Block, 195 – asymptotisch, 124, 134, 146 f, 406
– Dead Zone Block, 381 – char. Multiplikatoren, 315
– Debugger, 184 – grenzstabil, 134, 138, 143, 146
– Divide Block, 209 – instabil, 124, 130, 134, 138, 146, 148, 406
– Floating Scope, 329 – periodische Schwingung, 314
– – Signal Selector, 330 – Stabilitätsaussagen, 137
– From Workspace Block, 190 Stabilitätsuntersuchung, 414
– Function Block starrer Körper, 97
– – Fcn, 193 State-Space-Model (ss), 158
– – Interpreted MATLAB Function Block, 193 Stateflow, 317
– – MATLAB Fcn Block, 328 – Chart, 317 f
– get_parm, 221 – Connective Junction, 318, 322
– Hit Crossing Block, 328 – Debugger, 317
– imread, 180 – Default Transition, 318, 322
– Inport (In) Block, 174 – History Junction, 318
– JPG-Format, 180 – Label, 319 f
– Library, 171 – – Bind Action, 320
– Manual Switch Block, 381 – – During Action, 320
– Maskierung, 179 ff – – Entry Action, 320
– MATLAB Function Block, 194, 210 – – Exit Action, 320
– Model Explorer, 183 – – on-Event Action, 320
– Option – – Transition Action, 321
– – simset, 175, 334 – – Transtition Condition, 321
– Outport Block, 174 – – Transtition Condition Action, 321
– Parameterbox, 179 ff – MATLAB Function, 319
– Power Spectral Density Block, 210 – Model Explorer, 318, 323, 332
– Relational Operator Block, 381 – – Datentyp, 323
– S-Function, 214 – – Initialisierung, 323
– – Builder, 221 – – Scope, 323
– – Builder Block, 221 – Model Workspace, 318
– – C Code, 317 – Parser, 317
– – Level-1 M-File, 214 f – State, 318 f
– – Level-2 M-File, 214, 217, 221 – State Machine, 317, 332
– Scope, 174, 182 – Stateflow Block, siehe Chart
– set_param, 220 – Transition, 319, 320
– Sign Block, 381 – Update method, 323
– simplot, 183 – – Continuous, 323
– Simulationsaufruf – – Discrete, 323
– – sim, 174 – – Inherited, 329
– Sine Wave Block, 220 – Weckvorgang, 333
– Startroutine, 198 – Zustand, siehe State
– State Port, 327 – Zustands-Aktion, siehe Label
– State Space Block, 174, 188, 369 – – bind, 320
– Subsystem, 177, 192, 326, 363, 365, 379 – – during, 320
– Switch Block, 194, 363 – – entry, 319
– TO Workspace Block, 174 – – exit, 320
Sollbewegung, 122 f – – on event, 320
Sparse Matrix, 15, 135 Steiner, 110, 119
Spulenmodell, 358 Steuerbarkeitsmatrix, 360
Störbewegungen, 122 Stick-Slip-Schwingungen, 300
Störgrößenbeobachter, 365 Stoß, 281, 284, 288
Störgrößenkompensation, 364 Stoßdämpfer, 412
Stoßkraft, 376, 381 Vektorisierung, 44, 131, 371

Stromregler, 358 – vektorisierte Form, 140
strukturvariables System, 327 Viertelfahrzeugmodell, 186, 300, 317, 411
Sweep-Generator, 379 Vorwärtsdynamik, 352
Sweep-Kreisfrequenz, 379
Symbolic Math Toolbox Winkelbeschleunigung, 103, 105, 108, 126
– D Ableitungsoperator, 88 Winkelgeschwindigkeit, 101, 126
– diff, 86, 89, 107, 117, 398, 401 Workspace, 3, 8, 33, 36, 174
– digits, 85 – Workspace Browser, 3
– double, single, siehe MATLAB-Befehle
– dsolve, 88 f Zeitereignis, 275
– Eigenwerte, 91 Zeittransformation, 311
– findsym, 84, 85, 91 Zentrifugalkraft, 351
– int, 86 Zustandsereignis, 275
– jacobian, 86, 108, 113 ff, 122, 124, 399, 401, 405 Zustandsmodell, 156, 371
– jordan, 91 Zustandsregler, 360 f
– limit, 86 Zweipunkt-Schaltlogik, 279
– Numerik, 93
– Objekte, 83
– Online-Hilfe, 82 ff
– – help sym/, 83
– positive, 83
– pretty, 87, 89
– rank, siehe MATLAB-Befehl
– real, siehe MATLAB-Befehl
– solve, 87 f
– subs, 85, 89, 91, 93 f, 113, 124, 399 f, 405
– sym, syms, 83, 86, 89, 107 f, 113 ff
– taylor, 86
– unreal, 83
– Variable Precision Arithmetic vpa, 85
– vectorize, siehe MATLAB-Befehl
Taylor-Reihe, 405
Tensor, 98
– Drehtensor, 98
– schiefsymmetrisch, 101
Tensortransformationsgesetz, 102
Textinterpreter
– TEX, LATEX, 49
Tildeoperator, 101 f, 112
Tilgungsfrequenz, 377
Trägheitsellipsoid, 350
Trägheitsradien, 350
Trägheitstensor, 109, 339
Transformation, 98, 100
– Drehtmatrix, 98
– Elementartransformation, 100
– inverse, 102
– Rollen, Nicken, Gieren, 100
Triggersignal, 330
Übergangsbedingung, 373
Unstetigkeiten, 275
– Beispiele, 276
Van der Pol, 205

MATLAB Und Simulink in Der Ingenieurpraxis

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

MATLAB Und Simulink in Der Ingenieurpraxis

Hochgeladen von

Copyright:

Verfügbare Formate

Wolf Dieter Pietruszka

MATLAB® und Simulink® in der Ingenieurpraxis

Elektrotechnik für Maschinenbauer

BWL für Ingenieure und Ingenieurinnen

Einführung in die DIN-Normen

Englisch für Maschinenbauer

Alle Rechte vorbehalten

Umschlaggestaltung: KünkelLopka Medienentwicklung, Heidelberg

Moers, im September 2011 Wolf Dieter Pietruszka

3 Lineare Schwingungsmodelle 131

4 Simulation unter Simulink 161

4.5.2 System mit algebraischer Schleife . . . . . . . . . . . . . . . . . . . . . . . . 205

5 Simulation unter MATLAB 225

6 Modellierung und Simulation mit dem Stateﬂow Tool 317

6.2.2 Simulink-Modell mit Chart . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325

7 Physikalische Modelle unter Simulink 335

8.5.3 Übergang zur Numerik und Integration . . . . . . . . . . . . . . . . . . . . . 402

tem, Signal Processing, Symbolic Mathematics ergänzen die Entwicklungsplattform.

1. Programmsegmente mit fett hervorgehobenen MATLAB-Befehlen,

W. D. Pietruszka, MATLAB® und Simulink® in der Ingenieurpraxis,

1.1 Desktop und Fenster

Bild 1.1: MATLAB Desktop, MATLAB 7.12

1.3 Einige Bemerkungen zur Arbeitsweise von MATLAB

1.4.1 Skalare Operationen und Variablenverwaltung

1.4.1.1 Skalare Operationen

Es wird zwischen Groß- und Kleinschreibung unterschieden, d. h. a und A sind unterschied-

>> format compact, format long e % Ausgabe ohne Leerzeilen, Format

>> a=(47+1e+02*1.5+4^2)/4; A=(1.2+78.09)^2;

Die Ausgabe wird durch ein Semikolon (;) unterdrückt.

Komplexe Variablen sind mit der komplexen Standard-Einheit i oder j zu bilden:

>> z2=2-4*i; % Achtung! falls i eigene Variable

clear, clear y z Löscht alle oder ausgewählte (y z) Variablen des Workspace

Bild 1.2: Workspace Browser, MATLAB 7.12

Menüpunkt File/Save Workspace As.. bzw. File/Import Data.. im Command

1.4.2 Mathematische Funktionen

sqrt ( x ), nthroot( x,n ) Quadratwurzel, n-te Wurzel

Beispiele zum Aufruf mathematischer Funktionen:

>> y8=atan2(0.7,pi) % y=0.7, x=pi; eingeschlossener Winkel

>> y9=angle(pi+0.7i) % wie y8; vgl. auch phase(pi+0.7i) aus

>> y10=(0.7+0.1j)’; % konjugiert komplexer Wert, wie conj

1.4.3 Vektoren und Matrizen

[ x1 x2...; y1, y2,... ] Vektor- und Matrix-Eingabe

Beispiele zur Vektorformulierung:

>> vs = [ 1; 2; 3 ] % Spaltenvektor, statt (;) auch Return

Elementfolgen, z. B. 0, 2, 4, 6, 8, bei denen die Folgeelemente mit fester Schrittweite gebildet

Beispiele zur Matrizen-Formulierung:

>> I=ones(2) % 2,2 Einsmatrix, Datentyp: double

>> Z=zeros(2,3,’single’) % 2,3 Nullmatrix, Datentyp: single

>> A=[2 4; 7 5]; B=A(:,[2 1]); % Matr. A, B; [2 1] Spaltentausch

und bildet aus einem Vektor eine Diagonal-Matrix

Optional lassen sich Neben-Diagonalelemente mit diag(d,j) (obere Neben-Diagonale j positiv

Auch Nebendiagonal-Elemente lassen sich in einen Vektor schreiben:

Die Gegendiagonale wird mit

besetzt. ﬂiplr klappt eine Matrix von links nach rechts.

>> Dd(4,2:3)=[7 0] % 4. Zeile, Element 2 bis 3 neu zuweisen

Beispiele für Sparse-Matrix: Gegeben sei die Matrix

gesucht ist die Darstellung der Sparse-Matrix S , siehe help sparse:

>> A=[0 0 0 5; 0 2 0 0; 1 3 0 0;0 0 4 0]; % Ausgangsmatrix

1.4.3.1 Vektor-, Matrizen-Operationen und Built-In Functions

Vektor- und Matrix-Operationen, Built-In Functions

Anhand der Beispiel-Matrizen und -Vektoren

>> Dy_pr=v’*b’ % Dyadisches Produkt

>> c=v+b’; c=v-b’; % Vektor-Addition, -Subtraktion

>> C=A+B; C=A-B; % Matrix-Addition, -Subtraktion

>> Binv(B) % Kontr.: B B^(-1) = E oder B/B = E

Beispiel 2: Iterative Nullstellenbestimmung von f = 0,5 − x + 0,2 sin x mittels N EWTON-