MATLAB® und Simulink® in der Ingenieurpraxis: Modellbildung, Berechnung und Simulation [3. Auflage] 978-3-8348-1764-8, 978-3-8348-8630-9

Citation preview

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 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, Schwingungsanalyse 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 Mechatronik und der Elektrotechnik heranzuführen. In Lehrveranstaltungen können praxisrelevante Beispiele 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. Signalflussgrafen, auf phänomenologische Fragestellungen und die Visualisierung. Es sollten zunächst einmal 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 programmtechnische 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 Programmen und Signalflussgrafen durch das gesamte Buch. Die vollständigen und ergänzenden gut dokumentierten 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 Balancierender 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 Computeralgebra 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 Animationsmodellen 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 aufbereitet, 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 . Vorangestellt werden Grundlagen zu den Integrationsverfahren, deren Klassifizierung und Eigenschaften. Die Einführung erfolgt schrittweise mit der Bearbeitung eines kleinen Projektes. Neben der blockorientierten Simulation spielt die skriptorientierte Modellierung mit dem Basismodul MATLAB des Kapitels fünf eine wesentliche Rolle. Die Anwendung erfolgt an kleinen Beispielen. Diese beinhalten neben den Standardformulierungen als explizite bzw. implizite Differenzialgleichungen die Beschreibung als differenzial-algebraische Gleichungen, die Formulierung von Systemen mit Ereignissen wie Stoß und Reibung sowie die Bearbeitung von Randwertproblemen 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 eingesetzt. 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 studienbegleitend 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 Programmierung 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 Studentenversion, 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 [email protected]

Wolf Dieter Pietruszka

Inhaltsverzeichnis 1

Einführung in MATLAB 1.1 Desktop und Fenster . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Online-Hilfe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.3 Einige Bemerkungen zur Arbeitsweise von MATLAB . . . . . . . . . . 1.4 Basis-Elemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.4.1 Skalare Operationen und Variablenverwaltung . . . . . . . . . . . . 1.4.2 Mathematische Funktionen . . . . . . . . . . . . . . . . . . . . . . 1.4.3 Vektoren und Matrizen . . . . . . . . . . . . . . . . . . . . . . . . 1.4.4 Lineare Gleichungssysteme . . . . . . . . . . . . . . . . . . . . . 1.4.5 Spezielle Datenstrukturen . . . . . . . . . . . . . . . . . . . . . . 1.4.6 Vergleichsoperatoren und logische Operatoren . . . . . . . . . . . 1.4.7 Verzweigungen und Schleifen . . . . . . . . . . . . . . . . . . . . 1.5 Programmerstellung, MATLAB Script und Function . . . . . . . . . . 1.5.1 MATLAB Editor und Verzeichnispriorität . . . . . . . . . . . . . . 1.5.2 Datenein- und Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . 1.5.3 MATLAB Script . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5.4 MATLAB Function . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5.5 Code-Beschleunigung, der Profiler . . . . . . . . . . . . . . . . . . 1.6 Grafik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.6.1 Grafikfenster (Figure), Erstellung und Verwaltung . . . . . . . . . 1.6.2 2D-Grafik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.6.3 3D-Grafik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.7 Animation von 2D- und 3D-Modellen . . . . . . . . . . . . . . . . . . 1.7.1 Modellerstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.7.2 Animations-Grafik . . . . . . . . . . . . . . . . . . . . . . . . . . 1.7.3 2D-Animation einfacher Linien-Modelle . . . . . . . . . . . . . . 1.7.4 Animation mit geometrischen 3D-Modellen . . . . . . . . . . . . . 1.8 Computeralgebra unter MATLAB, die Symbolic Math Toolbox . . . . . 1.8.1 Online-Hilfe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.8.2 Symbolische Objekte . . . . . . . . . . . . . . . . . . . . . . . . . 1.8.3 Vereinbarung symbolischer Variablen und Ausdrücke (Objekte) . . 1.8.4 Substitution symbolischer und numerischer Größen, der subs Befehl 1.8.5 Beispiele aus der Analysis . . . . . . . . . . . . . . . . . . . . . . 1.8.6 Algebraische Gleichungssysteme, der solve Befehl . . . . . . . . . 1.8.7 Gewöhnliche Differenzialgleichungen, der dsolve Befehl . . . . . . 1.8.8 Beispiel aus der linearen Algebra . . . . . . . . . . . . . . . . . . 1.8.9 Übergang zur Numerik . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 2 4 5 5 6 9 11 20 23 26 27 30 30 32 33 35 42 44 45 47 60 66 66 67 69 73 81 82 83 83 85 86 87 88 91 93

VIII

2

3

4

Inhaltsverzeichnis

Modellbildung 2.1 Bemerkungen zur Schreibweise . . . . 2.2 Strukturen der Bewegungsgleichungen . 2.3 Grundlagen . . . . . . . . . . . . . . . 2.3.1 Kinematik starrer Körper . . . . . . 2.3.2 Kinetik . . . . . . . . . . . . . . . 2.4 Newton-Euler-Methode . . . . . . . . . 2.4.1 Rechnerorientierte Vorgehensweise 2.5 Lagrange’sche Gleichung 2. Art . . . . 2.6 Linearisierung . . . . . . . . . . . . . . 2.7 Anwendung der Modellerstellung . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

95 96 97 97 97 108 111 116 118 122 125

Lineare Schwingungsmodelle 3.1 Bewegungsgleichungen . . . . . . . . . . . . . . . . . . . . . . . 3.2 Eigenschwingungen und freie Schwingungen . . . . . . . . . . . 3.2.1 Das Eigenwertproblem in MATLAB, allgemeine Betrachtung 3.2.2 Numerische Behandlung der Eigenwertprobleme . . . . . . . 3.3 Erzwungene Schwingungen . . . . . . . . . . . . . . . . . . . . 3.3.1 Konstante Erregung . . . . . . . . . . . . . . . . . . . . . . . 3.3.2 Harmonisch angeregte mechanische Systeme . . . . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

131 132 134 134 136 148 149 150

Simulation unter Simulink 4.1 Zur Funktionsweise . . . . . . . . . . . . . . . . . . . . . . . . 4.1.1 Block-Struktur . . . . . . . . . . . . . . . . . . . . . . . . 4.1.2 Simulationsablauf . . . . . . . . . . . . . . . . . . . . . . 4.2 Die Integrationsverfahren . . . . . . . . . . . . . . . . . . . . . 4.2.1 Methoden und Bezeichnungen . . . . . . . . . . . . . . . . 4.2.2 Steifigkeit der Differenzialgleichung . . . . . . . . . . . . . 4.2.3 Bemerkungen zur Wahl der Verfahren . . . . . . . . . . . . 4.3 Simulink-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . 4.3.1 Die Modell-Library . . . . . . . . . . . . . . . . . . . . . . 4.3.2 Einstellung des Integrators und des Datentransfers . . . . . 4.3.3 Datentransfer über den Workspace . . . . . . . . . . . . . . 4.3.4 Simulationsaufruf aus der MATLAB Umgebung . . . . . . 4.3.5 Hilfsmittel zur Modellerstellung und Datenauswertung . . . 4.4 Simulink-Modellierung eines einfachen Projekts . . . . . . . . . 4.4.1 1/4-Fahrzeugmodell und die Bewegungsgleichungen . . . . 4.4.2 Aufbereitung der Bewegungsgleichungen . . . . . . . . . . 4.4.3 Das Fahrbahnprofil . . . . . . . . . . . . . . . . . . . . . . 4.4.4 Parametrisierung des Zustandsmodells im State Space Block 4.4.5 Modellierung der Reibelemente . . . . . . . . . . . . . . . 4.4.6 Die Startroutine für die MATLAB-Umgebung . . . . . . . . 4.4.7 Simulink-Modelle und Simulationsergebnisse . . . . . . . . 4.5 Algebraische Schleifen in dynamischen Modellen . . . . . . . . 4.5.1 Algebraische Schleifen . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

161 161 161 162 163 164 169 170 171 171 173 174 174 175 186 186 188 190 194 195 198 199 205 205

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

Inhaltsverzeichnis

IX

4.5.2 System mit algebraischer Schleife . . . . . . . . . . . . . . . . . . . . . . 4.6 Vektorielle Betrachtungsweise und Modellierung . . . . . . . . . . . . . . . . 4.6.1 Simulationsergebnisse, selbsterregte Schwingungen und Mitnahme-Effekte 4.6.2 Nichtlineare Gleichungen höherer Ordnung . . . . . . . . . . . . . . . . . 4.7 Modellierung mit Hilfe einer S-Function . . . . . . . . . . . . . . . . . . . . . 4.7.1 M-File S-Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.7.2 C Mex-File S-Function . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . .

. . . . . . .

205 209 210 211 214 214 221

225 5 Simulation unter MATLAB 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 6.1 Stateflow-Elemente . . . . . . . . . . . . . . . . . . . 6.1.1 Das Chart . . . . . . . . . . . . . . . . . . . . . . 6.1.2 Zustand und Zustand-Label . . . . . . . . . . . . 6.1.3 Transitionen . . . . . . . . . . . . . . . . . . . . 6.1.4 Default Transition . . . . . . . . . . . . . . . . . 6.1.5 Verbindungspunkte . . . . . . . . . . . . . . . . . 6.1.6 Der Modell-Explorer . . . . . . . . . . . . . . . . 6.1.7 Erweiterte Strukturen . . . . . . . . . . . . . . . . 6.2 Beispiel: Schwinger mit Coulomb-Reibung . . . . . . 6.2.1 Bewegungsgleichungen und Schaltbedingungen . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

317 317 318 319 320 322 322 323 324 324 324

X

Inhaltsverzeichnis

6.2.2 Simulink-Modell mit Chart . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325 6.3 Beispiel: Springender Ball . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330 7

8

. . . . . . . .

. . . . . . . .

335 336 336 337 337 344 349 350 353

Projekte 8.1 Permanentmagnet gelagerter Rotor . . . . . . . . . . . . . . . . . . . . . . . . . 8.1.1 Systembeschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1.2 Rotor- und Magnetmodellierung . . . . . . . . . . . . . . . . . . . . . . . . 8.1.3 Die aktive Stabilisierung, Reglerstrukturen . . . . . . . . . . . . . . . . . . 8.1.4 Das kontinuierliche Modell . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1.5 Reglerentwürfe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1.6 Parametrierung und Reglerkoeffizienten . . . . . . . . . . . . . . . . . . . . 8.1.7 Simulink-Modelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1.8 Simulationsergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2 Störgrößenkompensation harmonischer und konstanter Störungen . . . . . . . . 8.2.1 Grundlagen zur Strecke und zum Beobachterentwurf . . . . . . . . . . . . . 8.2.2 Parameterfile und Simulink-Modell . . . . . . . . . . . . . . . . . . . . . . 8.2.3 Beobachter über S-Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2.4 Analytische Ermittlung der Lösungen . . . . . . . . . . . . . . . . . . . . . 8.2.5 Ergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.3 Schwingungstilger mit viskoelastischem Anschlag . . . . . . . . . . . . . . . . 8.3.1 Das stationäre System ohne Anschlag . . . . . . . . . . . . . . . . . . . . . 8.3.2 Entwurf des Simulink-Modells . . . . . . . . . . . . . . . . . . . . . . . . . 8.3.3 Schwingungsantwort mit einem Sinus-Sweep des Systems ohne/mit Anschlag 8.4 Axialkolbenverdichter einer Pkw-Klimaanlage . . . . . . . . . . . . . . . . . . . 8.4.1 Das Modell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.4.2 Der Hebelmechanismus . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.4.3 Bewegungsgleichungen nach Lagrange . . . . . . . . . . . . . . . . . . . . 8.4.4 Das M-File, erste Ergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . 8.4.5 Modellbasierter Entwurf mit SimMechanics . . . . . . . . . . . . . . . . . . 8.4.6 Vergleich der Ergebnisse bezüglich der Gelenkkräfte . . . . . . . . . . . . . 8.4.7 Stationäre Lage, die Trimming-Methode . . . . . . . . . . . . . . . . . . . . 8.4.8 Der Verdichter als SimMechanics-Modell . . . . . . . . . . . . . . . . . . . 8.5 Dreifachpendel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.5.1 Lagrange’sche Gleichung 2. Art . . . . . . . . . . . . . . . . . . . . . . . . 8.5.2 Newton-Euler-Formalismus . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

355 355 356 357 358 359 360 363 363 364 364 367 369 370 370 374 376 377 379 384 386 386 387 388 391 391 393 394 395 396 398 399

Physikalische Modelle unter Simulink 7.1 SimMechanics Tool . . . . . . . . . . . . . . . . 7.1.1 Funktionsweise . . . . . . . . . . . . . . . . 7.1.2 Untersuchungsmethoden . . . . . . . . . . . 7.1.3 Erstes SimMechanics-Modell . . . . . . . . 7.1.4 Arbeitsweise des Joint Stiction Actuators . . 7.1.5 Visualisierung und Animation der Maschine . 7.1.6 Einige mathematische Aspekte . . . . . . . . 7.2 Anwendungen und Ausblick . . . . . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

Inhaltsverzeichnis

8.5.3 Übergang zur Numerik und Integration . . . . . . . . . . . . . . . . 8.5.4 Animationsmodell . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.5.5 Schwingungsverhalten . . . . . . . . . . . . . . . . . . . . . . . . . 8.5.6 Vorwärtsdynamik mit SimMechanics . . . . . . . . . . . . . . . . . 8.5.7 Inverse Dynamik . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.6 Hubschwingungen eines Viertelfahrzeugs mit nichtlinearem Stoßdämpfer 8.7 Dynamik des Levitron-Kreisels . . . . . . . . . . . . . . . . . . . . . . . 8.8 Balancierender Roboter . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.8.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.8.2 Modellvoraussetzungen und Annahmen . . . . . . . . . . . . . . . . 8.8.3 Herleitung der Bewegungsgleichungen . . . . . . . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

XI

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

402 403 405 407 410 411 413 414 415 415 416

Literaturverzeichnis

417

Stichwortverzeichnis

421

1

Einführung in MATLAB



Ursprünglich war MATLAB 1 ein Benutzerinterface für Standardroutinen der numerischen Algebra (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 Produktfamilie 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. Benutzereigene 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 Simulink 2 u. a. mit den Tools Stateflow , SimScape, SimMechanics, SimPowerSystems, SimDriveline, SimHydraulics , Real-Time Workshop usw. Viele optionale Toolboxen, z. B. Control System, Signal Processing, Symbolic Mathematics ergänzen die Entwicklungsplattform. Alternativen3 stellen u. a. die kommerziell vertriebenen Programmpakete MATRIXx und OMatrix 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 Folgenden 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 zusammenstellen und sie anhand kleiner Beispiele erläutern. Befehle enthalten Variable, die wir in allgemeinen 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: TM

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, © Vieweg+Teubner Verlag |Springer Fachmedien Wiesbaden GmbH 2012

2

1 Einführung in MATLAB

Darüber hinaus werden Möglichkeiten zur grafischen Ausgabe von Daten sowie deren Animation 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 Differenzialgleichungen, 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 insbesondere 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] existieren 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 MATLABUmgebung. 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 allen 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 DoppelKlick 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 angezeigt, worüber eine grafische Bild 1.1, den Vektor x aus, dann wird der Button Auswertung in auszuwählender Darstellung erfolgt. Das Current Directory Fenster enthä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 DoppelKlick der linken Maustaste wieder aktivierbar, einzelne / mehrere Befehle lassen sich ausschneiden 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 Umgang mit dem Desktop, dem Command Window usw. vermitteln die Video Tutorials u. a. unter: Button Help / Demos → MATLAB.

4

1 Einführung in MATLAB

1.2

Online-Hilfe

Eine gut strukturierte und weitgehend selbsterklärende Online-Hilfe unterstützt das gesamte Angebot 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 Eingabe von help helptools ⇒ Wir wollen, aufbauend auf den Schlüsselwörtern help, helpwin, doc, sie sollten stets parallel genutzt 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 general 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 erweiterter 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 Aufruf – 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 Kommentarblock angezeigt. Dies ist auf die Kommentare eigener M-Files übertragbar, so dass sich eine eigene 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 einen schnellen Befehls-Überblick direkt in der Arbeitsumgeliefert der Function Browser 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 übernommen 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

1.3

5

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ührung 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 grafischen Funktionen machen MATLAB zu einer Plattform insbesondere für technische Berechnungen. 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 forSchleifen 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 insbesondere Schleifen und skalare Mathematik enthalten, automatisch beschleunigt werden. Der JITAccelerator 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 Vektorisierung 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 Programmcode wird durchgehend beschleunigt.

1.4

Basis-Elemente

Zunächst werden wir uns mit wesentlichen Elementen des MATLAB-Sprachumfangs vertraut machen. Diese ausgewählten Elemente stellen wir stets am Anfang eines jeden Abschnittes tabellarisch zusammen, es folgen diesbezüglich kurze Erläuterungen und einfache Beispiele. Die Beispiele 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 aufgelisteten 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

6

1 Einführung in MATLAB

mit dem sich aus dem Editor zellenweise – vgl. Abschn. 1.5.1 – die folgenden Beispiele am Rechner 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

= + − * / \ ˆ , ; ... i, j pi inf NaN eps(var) realmax, -min(class) format ausgabeformat

Variablenzuweisung Rechenoperatoren Abschluss einer Befehlskette mit (,) und ohne (;) Ausgabe Zeilenumbruch innerhalb einer Anweisung √ Imaginäre Einheit −1, Function: i.m, j.m pi.m Kreiszahl π = 3.14... Unendlich ∞ (infinity), z. B. 1.0 e309 inf.m Not a Number, z. B. 0/0, inf-inf nan.m Maß für relative Genauigkeit (Floating-Point) eps.m kleinster pos. Abstand: |var| + eps(var) > |var| größte/kleinste pos. Gleitkommazahl realmax.m 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

1.4.1.1

z. B. type i.m

Skalare Operationen

Variablen müssen nicht deklariert werden. In MATLAB sind alle Variablen Matrizen mit möglicherweise 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 unterschiedliche 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 a = 5.325000000000000e+001

% Rechtsdivision

wird das Ergebnis der Variablen a zugewiesen. Mehrere Zuweisungen können in eine Zeile geschrieben werden, wenn sie durch Komma (,) oder Semikolon (;) getrennt werden >> a=4\(47+1e+02*1.5+4^2), A=(1.2+78.09)^2 a = 5.325000000000000e+001 A = 6.286904100000001e+003

% Linksdivision

>> 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); >> bs = as+a;

% as class single, MATLAB 7 % 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 gebildet werden. Komplexe Größen benötigen doppelten Speicherplatz, Real- und Imaginärteil werden getrennt verwaltet. help datatypes, help class ⇒ Die Wertebereiche erhält man z. B. mit >> >> >> >>

realmax(’double’); realmin(’double’); intmax(’int32’); intmax(’uint32’);

realmax(’single’); realmin(’single’); intmin(’int16’); intmin(’uint16’);

Komplexe Variablen sind mit der komplexen Standard-Einheit i oder j zu bilden: >> format short e >> z1=0.5+7i z1 = 5.0000e-001 +7.0000e+000i

% Ausgabeformat geändert % 7i komplexe Einheit, berechnet in i.m % class double(complex)

8

1 Einführung in MATLAB

>> z2=2-4*i; >> z1*z2 ans = 2.9000e+001 +1.2000e+001i

1.4.1.2

% Achtung! falls i eigene Variable

Variablenverwaltung Variablenverwaltung

clear, clear y z who/whos save verz\file variablen load verz\file variablen diary(’verz\file’) diary on ... diary off

Löscht alle oder ausgewählte (y z) Variablen des Workspace Workspace: Variablen-Liste /+Dimension, Datentyp (class) speichert Workspace in file.mat, optional auch ASCII lädt Daten aus file.mat in den Workspace, optional ASCII speichert nachfolgende (ASCII-) Text/Daten einer Sitzung 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 Spaltenvektor 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

1.4 Basis-Elemente

9

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 ) exp ( x ) log ( x ), log10 ( x )

Quadratwurzel, n-te Wurzel Exponentialfunktion ex Natürlicher ln(x), Zehner-Logarithmus log(x)

sin ( x ), cos ( x ) tan ( x ) atan ( x ), atan2 ( imag, real )

Sinus, Cosinus, x in Radian Tangens, x in Radian Arcus-Tangens ±90°, ±180°

abs ( x ) sign ( x ) conj ( x ) real ( x ), imag ( x ) angle ( x )

Betrag Signum (Vorzeichen) x > 0 → 1, x < 0 → −1, x = 0 → 0 Konjugiert komplexe Zahl, x = a + ib → xˆ = a − ib Realteil, Imaginärteil, real(x)=a, imag(x)=b 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

10

1 Einführung in MATLAB

 π ⊲ 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) y5 = 6.1073e-001

% Hauptwert von atan(x)

>> y8=atan2(0.7,pi)

% y=0.7, x=pi; eingeschlossener Winkel % 4 Quadranten -pi 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 Basis-Elemente

1.4.3

11

Vektoren und Matrizen Vektor- und Matrix-Formulierung

[ x1 x2...; y1, y2,... ] start: schrittweite : ziel linspace ( start, ziel, anzahl ) logspace ( start, ziel, anzahl ) (vek/mat) .’ , (vek/mat)’

Vektor- und Matrix-Eingabe Zahlenfolge; Doppelpunkt-Operator (:), Vektor lineare Zahlenfolge, Vektor-Ausgabe logarithmische Zahlenfolge, Vektor-Ausgabe Transposition: komplexe, reelle Vektoren u. Matrizen

eye ( zeilen, spalten ,classn. ) ones ( zeilen, spalten ,classn. ) zeros ( zeilen, spalten ,..,classn. ) repmat ( mat / skalar, n, m) diag ( vek , k ) diag ( mat , k ) fliplr ( mat) rand ( zeilen, spalten)

Einheitsm. zeilen × spalten, classn. z. B. ’single’ Matrix mit Eins-Elementen, z. B. ones(3,4,’int8’) Matrix mit Null-Elementen Matrix: [ mat / skalar n mal; mat/skalar m mal ] Matrix mit k-ter Diagonalen Vektor der k-ten Diagonalen k = 0 oder leer → Haupt-, k = 0 → Nebendiagonale klappt eine Matrix von links nach rechts Matrix mit Zufalls-Elementen

a ( index ) A ( zeile, spalte ) A ( end )

Vektor-Element index von a oder einer Matrix Matrix-Element von A, azeile,spalte 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 Elemente 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] vz = 1 2

% Zeilenvektor 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

12

1 Einführung in MATLAB

vs = 1 2 3 >> vs = vz’;

% transponieren von vz und Zuweisung

Bei komplexen Vektoren liefert (..)’ den zugehörigen konjugiert komplexen Vektor. Der Vektor 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 v = 0 2 4 >> v = [ 8:-2 : 0] v = 8 6 4 >> v = 0:8 v = 0 1 2

6

% Elementfolge, Schrittweite 2 % vgl. auch: >> linspace(0,8,5) 8 % [ ] überflüssig, Schrittw. -2

2

0 % Schrittweite 1

3

4

5

6

7

8

◮ Beispiele zur Matrizen-Formulierung: >> A=[1 2 3; 3 4 5; 6 7 8] A = 1 2 3 3 4 5 6 7 8 >> C=[1:2:5 ; 7:9] C = 1 3 5 7 8 9

| | | | | | | | | |

>> B=[[1 2 3]’,[2 4 7]’] B = 1 2 2 4 3 7 >> A1 = [1 4 9; 6 4 5] A1 = 1 4 9 6 4 5

◮ Spezielle Matrizen werden über Built-In Functions erzeugt: eye, ones, zeros, diag, spdiags... >> E=eye(3) E = 1 0 0 1 0 0

% 3,3 Einheitsmatrix, Datentyp: double % auch E=eye(3,3) 0 0 1

1.4 Basis-Elemente

>> I=ones(2) I = 1 1 1 1

% 2,2 Einsmatrix, Datentyp: double % auch I=ones(2,2)

>> Z=zeros(2,3,’single’) Z = 0 0 0 0 0 0

% 2,3 Nullmatrix, Datentyp: single

13

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 = . A 7 5 5 7 −A B >> A=[2 4; 7 5]; B=A(:,[2 1]); >> Q=[zeros(2) eye(2); -A B] Q = 0 0 1 0 0 0 0 1 -2 -4 4 2 -7 -5 5 7

% Matr. A, B; [2 1] Spaltentausch % Matrix Q

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; >> A = 2*ones(n,m); % schnell >> A = zeros(n,m); A(:) = 2; % gleichwertig >> A(n,m)=2; A(:)=2; % gleichwertig >> A = repmat(2,n,m) % langsam A = 2 2 2 2 2 2

n=5000; m=6000 schnell langsamer etwas langsamer etwas langsamer

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)’ ad = 1 4 8

% Diagonalelemente von A

14

1 Einführung in MATLAB

und bildet aus einem Vektor eine Diagonal-Matrix >> Ad=diag(ad) Ad = 1 0 0 4 0 0

% Diagonalmatrix 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: >> >> >> >> Dd

d=[2 4 6 8]; d1=-3*ones(1,3); d2=-ones(1,2); Dd= diag(d) + diag(d1,1) = 2 -3 0 0 0 4 -3 0 -1 0 6 -3 0 -1 0 8

% % % +

Haupt-Diagonalelemente 1. obere Neben-Diagonale, j=1 2. untere Neben-Diagonale, j=-2 diag(d2,-2) % Matrix-Aufbau

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) ans = 3.0000e+000 -7.0000e+000i >> Dd(3,4) ans = -3 >> Dd(:,2)

% 3. Vektorelement von vzi

% Matrixelement 3. Zeile / 4. Spalte

% alle Elemente der 2. Spalte von Dd

1.4 Basis-Elemente

ans = -3 4 0 -1 >> Dd(4,2:3) ans = -1 0

15

% 4. Zeile, Spalten-Element 2 bis 3 % auslesen

⊲ Matrixelemente können mit ihren Indizes (zeile, spalte) oder mit nur einem Index angesprochen 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 DdMatrix 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 vzi = 1.0000e+000 +5.0000e+000i >> Dd(4,2:3)=[7 0] Dd = 2 -3 0 0 4 -3 -1 0 6 0 7 0

% 3. Element wird geändert 2.0000e+000 +1.0000e+000i

2.5480e+003

% 4. Zeile, Element 2 bis 3 neu zuweisen 0 0 -3 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]; >> D=[Dd;u]; E=[Dd u’];

D([1 3],:)=[];

E(:,[1 3])=[];

◮ 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:

% Vektor u % Lösung

16

1 Einführung in MATLAB

>> 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 >> spy(S) % Elemente = 0 S = % class double | (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) (2,2)

1 1

Die vollbesetzte Einheitsmatrix erhalten wir mit: >> E = full(SE) E = 1 0 0 1

Spezielle mathematische Funktionen (siehe help sparfun) existieren, einige bearbeiten vollbesetzte 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 Rechenoperationen 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 Eingangsvariablen 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 zugehö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 Beispiele. Weitere Eingangsargumente sowie Ausgaben sind möglich; siehe Online-Hilfe.

1.4 Basis-Elemente

17

Vektor- und Matrix-Operationen, Built-In Functions

.* .\ ./ .ˆ \ / transpose ( vek / mat ) oder vek / mat .’ ctranspose ( vek / mat ) oder vek / mat ’ dot ( vek, vek ), cross ( vek, vek ) inv ( mat ) det ( mat ) linsolve ( mat, vek / mat , option  )  [V, D]= eig ( mat ), eigs ( mat ) condeig ( mat ), [V,D,s]=condeig (...) rank ( mat , toleranz  )

Elementweise Rechenoperationen Links- und Rechts-Division Transposition: Vektor, Matrix Transposition, konjugiert-komplex Skalar-, Kreuz-Produkt Inverse einer quadratischen Matrix Determinante einer quadratischen Matrix lineares Gleichungs-Syst. LU-Zerlegung (ab R14) Eigenwerte, Eigenvektoren einer quadrat. Matrix Konditionszahl bez. der Eigenwerte von mat Rang einer Matrix, siehe auch rref

 [m, n]= size( vek / mat , i ) length ( vek / mat )

Matrix-, Vektordimension, i=1 Zeilen, i=2 Spalten Größter Wert aus Spalten-, Zeilenindex identisch mit max(size( vek / mat ))

sum ( vek / mat ) prod ( vek / mat ) [vmin,index]=min ( vek / mat ) [vmax,index]=max ( vek / mat ) max ( mat(:) ) sort ( vek / mat ) find ( vek / mat ,’last’ | ’first’  )

Summe der Vektorelemente bzw. Spaltenvektorel. Produkt der Vektorelemente bzw. Spaltenvektorel. Kleinstes Vektorelement bzw. Spaltenvektorelement Größtes Vektorelement bzw. Spaltenvektorelement Größtes Matrixelement Elemente in aufsteigender Folge 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=[ 2 4 6 8 10]’;

B=[1 2 3; 2 4 5;3 7 8]; v=0:2:8;

sollen einige Operationen erläutert werden: >> v*b ans = 160

% oder: dot(v,b) % Skalar-Produkt

>> Dy_pr=v’*b’ 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) ans = 5 5 >> size(Dy_pr,1); size(Dy_pr,2);

% 5,5-Matrix % Zeilen-/Spalten-Dimension

>> c=v+b’;

% Vektor-Addition, -Subtraktion

c=v-b’;

% Dyadisches Produkt

% Matrix-Dimension

18

1 Einführung in MATLAB

>> C=A+B; C=A-B; >> C=A*B; >> c=A*v(1:3)’ c = 16 34 52

% Matrix-Addition, -Subtraktion % Matrix-Multiplikation % Matrix-Vektor-Multipl.

◮ Beispiele elementweiser Operationen: >> c=v.*b’ c = 0 8

% Vektorelement-Multipl. % c(i) = v(i) * b(i) 24

>> c=v./b’ c = 0 5.0000e-001

48

80

6.6667e-001

% Vektorelement-Rechts-Div. % c(i) = v(i) / b(i) 7.5000e-001 8.0000e-001

>> c=v.\b’ Warning: Divide by zero. c = Inf 2.0000e+000 1.5000e+000

% Vektorelement-Links-Div. % c(i) = b(i) / v(i) 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 C = 1 4 8 20 21 56 >> C=A./B C = 1.0000e+000 2.0000e+000 2.3333e+000 >> C=A.\B C = 1.0000e+000 5.0000e-001 4.2857e-001

% Matrixelement-Multipl. % C(i,j) = A(i,j)*B(i,j) 9 30 72

1.0000e+000 1.2500e+000 1.1429e+000

% Matrixelement-Rechts-Div. % C(i,j) = A(i,j) / B(i,j) 1.0000e+000 1.2000e+000 1.1250e+000

1.0000e+000 8.0000e-001 8.7500e-001

% Matrixelement-Links-Div. % C(i,j) = B(i,j) / A(i,j) 1.0000e+000 8.3333e-001 8.8889e-001

>> C=A.^B C =

% Matrixelement-Potenz % C(i,j) = A(i,j)^B(i,j) 1 16 343

4 625 2097152

27 7776 43046721

1.4 Basis-Elemente

>> sqrt(A) ans = 1.0000e+000 2.0000e+000 2.6458e+000

19

% elementw. Quadratwurzel 1.4142e+000 2.2361e+000 2.8284e+000

1.7321e+000 2.4495e+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 C = 1.0000e+000 -5.0000e+000 -1.1000e+001

% Matrix-Rechts-Div.; A*B^(-1) 0 0 9.0000e+000 -3.0000e+000 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) ans = 1.0000e+000 0 0 1.0000e+000 0 -1.7764e-015

% Kontr.: B * B^(-1) = E oder B/B = E % Elemente: ~ 0; numerischer Fehler 4.4409e-016 8.8818e-016 1.0000e+000

>> eig(A) ans = 1.6117e+001 -1.1168e+000 -1.0307e-015

% Eigenwerte der Matrix A

% Hinweis auf Singularität, 0-Eigen-W.

>> [V,D]=eig(B) V = -2.8096e-001 8.1276e-001

% Eigenwerte D und Eigenvektoren V % Eigenvektoren 8.1276e-001

20

1 Einführung in MATLAB

-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) ans = 2

% Rang der Matrix A % Rangabfall, lineare Zeilen-, Spalten% Abhängigkeit, vgl. Singularität von A

◮ Beispiele zu den Befehlen: sum, max, min: >> sum(A) ans = 12 15 >> sum(A,2) ans = 6 15 24

% oder sum(A,1), Spaltensummen 18 % Zeilensummen

Die Summe aller Matrix-Elemente ergibt sich durch doppelte Summenbildung oder mit dem Speichermodell von S. 15 zu: sum(sum(A)) oder sum(A(:)). >> [vmax,I]=max(A) vmax = 7 8 9 I = 3 3 3

% vmax maximale Spaltenelemente % I zugehöriger Index von A % I Index von A der Maximalelemente % 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) gelö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 symbolischen Matrizen, Seite 88, sind zulässig. Allgemein unterscheidet man direkte und iterative Verfahren. Der G AUSS-Algorithmus ist eine direkte Methode, weil nur durch Umformen eine auflösbare Form gefunden wird. Die direkten

1.4 Basis-Elemente

21

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. optional ü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)-Koeffizientenmatrix A basiert auf der Definition für den Rang einer Matrix. Ein System kann eindeutig A) gleich dem lösbar, lösbar oder nicht lösbar sein. Das System ist lösbar, wenn der Rang r(A A, b ) ist. Eindeutig lösbar, wenn r(A A) = r(A A, b ) = n ist. Nicht der um b erweiterten Matrix r(A A) < n, dann sind n − r(A A) Unbekannte frei wählbar. Einen detailliereindeutig lösbar, wenn r(A 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 A) < n) sein. Die Matrix A kann regulär bzw. singulär (r(A ◮ 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; det_A = det(A); r_A = rank(A); r_Ab = rank(A,b); x=A\b;

% % % % %

Element geändert Determ.: det_A=6.66e-016 Rang: r_A = 2 Rang: r_Ab= 1 Warning!! + falsche Lösung

◮ Beispiel mit singulärer Matrix A und geänderten rechten Seite b , lösbar: b_neu = [15; 15; 15]; r_Ab = rank([A,b]); Ar = A(:,1:2); r_Ar = rank(Ar); r_Arb= rank([Ar,b_neu]); bx=A(:,3); x3=1;

% % % % % % %

rechte Seite geändert Rang: r_Ab=2=r_A x3 vorgegeben, z. B. x3=1 Rang: r_Ar = 2 Rang: r_Arb= 3 Spalte 3 auf rechte Seite x3 beliebig vorgegeben

22

1 Einführung in MATLAB

Das um eine Spalte reduzierte, überbestimmte Gleichungsystem kann unmittelbar gelöst werden: Überbestimmtes Gleichungssystem xr=Ar\(b_neu-bx*x3); x=[xr;x3];

% Lösung: xr=[x1; x2]=[-14; 13] % 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],:); det_Arr = det(Arr); brr = b_neu([1,3]); bxx = bx([1,3]); xrr = Arr\(brr-bxx*x3);

% % % %

Arr=[1 2; 7 8]; regulär det_Arr = -6 reduzierte rechte Seite 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)]; rank(Au); bu=sum(Au,2); rank([Au,bu]); xu=Au\bu;

% % % % %

(3,5)-Koeffizientenmatrix Rang: 3 rechte Seite, Zeilensumme Au Rang: 3 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’ % lambda=eig(As); % det_As = det(As); % opts.SYM = true; opts.POSDEF = true; % x_linsolve = linsolve(single(As),b,opts)% %

symmetrische Matrix As Eigenw. pos. -> As pos. def. det_As = 729, positiv Optionen: Symm., pos. def. 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) x_lu = U\(L\b)

% U obere Dreiecksmatrix % Lösung: x_lu=[1; 1; 1]

1.4 Basis-Elemente

23

◮ 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 Genauigkeit, 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     3.5 2 4 , b= K x = 0.5 b , K= 7.75 7 5 mit der quadratischen Matrix K und dem Vektor b passender Dimension; gesucht sei x . Ergebnis: mit Rangfolgeregel-Fehler >> x=0.5*K\b x = 1.5000e+000 1.0000e+000

1.4.5

richtig >> x=0.5*(K\b) oder: >> x=K\b*0.5 x = 3.7500e-001 2.5000e-001

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)

>> K(:,:,2)

ans = 0 0 0

ans = 0 0 0 0 0 2 0 0 0

0 0 0

0 0 3

Seite 3

Seite 2

24

1 Einführung in MATLAB

>> K(:,:,1)

1.4.5.2

ans = 1 0 0

0 0 0

0 0 0

Seite 1

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 ans = 3 3

% Ausgabe: Feld ’dimension’

>> user_struktur(2).daten=inv(A) user_struktur = 1x2 struct array with fields: daten dimension

% Erweiterung um inv(A)

>> user_struktur.daten

% Ausgabe

1.4 Basis-Elemente

ans = 1 4 7

2 5 8

25

% Matrix A, auch mit % user_struktur(1).daten

6 9 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) ans = 9

1.4.5.4

% Matrix A, Element A(2,3)

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 Variablen 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) A(1,2) A(2,1) A(2,2)

= = = =

{[1 2 3; 4 5 6; 7 8 9]}; {’ Testmatrix ’}; {3 + 7i}; {0 : pi/100 : 2*pi};

% % % %

Zuweisung Zuweisung Zuweisung Zuweisung

der der der der

Zelle Zelle Zelle Zelle

1,1 1,2 2,1 2,2

oder >> A{1,1} = [1 2 3; 4 5 6; 7 8 9]; ...

% auf Klammertyp achten!

Aufruf: >> A A = [3x3 double] [3.0000e+000 +7.0000e+000i] >> A{1,1} ans = 1 4 7

’ Testmatrix ’ [1x201 double]

| | | |

>> A(1,1) ans = [3x3 double]

% 1. Zelle, [3x3 double] % Element-Aufruf: A{1,1}(2,3) -> 6 2 5 8

3 6 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’)

26

1 Einführung in MATLAB

1.4.6

Vergleichsoperatoren und logische Operatoren Logische Operatoren

Vergleichsoperatoren ==, ∼= < , , >= exist (’x’) ⇒

gleich, ungleich kleiner, kleiner gleich größer, größer gleich Existenz von x prüfen

Negation Und; Matrix-, Skalar- Vergl. Oder; Matrix-, Skalar- Vergl. Exklusiv ODER

∼ &, && |, || xor

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 elementweise 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-Operator. Die einzelnen Verknüpfungen sind in folgender Tabelle zusammengefasst. Eingang

and

or

xor

not

∼a

a

b

a&b

a|b

xor(a,b)

0 0 1 1

0 1 0 1

0 0 0 1

0 1 1 1

0 1 1 0

1 1 0 0

Die NOT-Verknüpfung hat die höchste Priorität. Der AND-Operator hat gegenüber dem OROperator 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, logisch 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; >> ~a ans = 0 >> (7 > 11-5 & 7 > 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) bezeichnet. Ihre skalaren Operanden werden nicht weiter evaluiert als zur Ermittlung des Wahrheitswertes erforderlich. Beispiel zum Short-Circuit Operator &&, siehe Online-Hilfe: >> b=0; a=5 % a ist beliebig >> x = (b ~= 0) && (a/b > 18.5) x = 0

>> x = (b ~= 0) & (a/b > 18.5) Warning: Divide by zero. 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 switch...case... otherwise...  end for variable = bedingung, befehle end while bedingung, befehle end break continue

⇒

If-Anweisung Switch-Anweisung for-Schleife While-Schleife Vorzeitiger Schleifenabbruch in for, while 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

28

1 Einführung in MATLAB

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 Speicherplatzadressierung 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 Rechenzeitangaben – siehe auch praeall.m in [52] –, in denen einer Matrix elementweise ein Wert zugewiesen 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.

1.4 Basis-Elemente

var=5; eps_a = 1; while (var+eps_a) ~= var eps_a = eps_a/2; end eps_a = eps_a*2 Ergebnis: >> eps_a = 2.2204e-016

29

% var=5, Startwert eps_a % while-Schleife % eps_a wird fortlaufend halbiert % damit wieder: var+eps_a > var % kleinster Abstand: var+eps_a > var

⊲ Beispiel 2: Iterative Nullstellenbestimmung von f = 0,5 − x + 0,2 sin x mittels N EWTONVerfahren, vgl. Newton.pdf, newton.m, newton0.m mit Darstellung der Iterationsfolge in [52]: xi+1 = xi −

f (xi ) , i = 0, 1, . . . ; f ′ (xi )

f′=

∂f , i-ter Iterationsschritt ∂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

30

1 Einführung in MATLAB

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 ... help filename

Kommentar-Zeile, -Block, Cell-Divider (R14) Zeilenumbruch innerhalb eines Ausdrucks zeigt erste Kommentarzeilen des Progammkopfs

eval ( string) feval ( F, in_1,..., in_n)

Auswertung des Strings string Auswertung des Function Handle F ab (R14)-Version, feval rückwärtskompatibel Inline Function

F ( in_1,..., in_n) inline ( ’funktion’,’t’,.. ) function [out_1,..] = name ( in_1,.. )

@

MATLAB Function, Kopfzeile (Definitionszeile) Function Handle (class: function_handle) Übergabeparameter-Anzahl m prüfen: min ≤ m ≤ max

nargchk ( min,max,m ) isempty ( ’var’ ) nargin, nargout global var var1, clear global var persistent var return error ( ’bemerkung’ )

Existenz von var prüfen Anzahl der Ein- bzw. Ausgangsparameter abfragen Definition bzw. löschen von Global-Variablen Definition persistenter (statischer) Variablen Rücksprung aus Function bzw. Script-Abbruch Function-Abbruch mit Ausgabe von bemerkung

clear function_name

Löschen der übersetzten Function

⇒ 1.5.1

help function, help function_handle, help funfun

MATLAB Editor und Verzeichnispriorität

Wichtige Informationen zum Editieren können mit dem Help Button unter Using the M-FileEditor 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 Definitionszeile 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 Window 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-Umgebung – 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 dir auswahl pwd path addpath verzeichnis  -begin | -end  rmpath verzeichnis what which filename -all lookfor such -all

Verzeichniswechsel aus dem Command Window Liste des Verz.-Inhalts, z. B. dir *.m, alle M-Files Anzeige des aktuellen Verzeichnisses Liste des MATLAB-Path Übernahme des Pfads verzeichnis in MATLAB-Path, Position-Optionen für: Listen-Anfang oder -Ende Löscht verzeichnis aus MATLAB-Path Liste der m-, mat-, mex-Files des aktuellen Verz. Directory-Anzeige von File filename im Suchpfad M-File mit such in erster Zeile, -Block im Suchpfad

Das aktuelle Verzeichnis hat nun, bei Suchstrategien z. B. mit dem which Befehl, erste Priorität, es folgen die des MATLAB-Path, in dem sich ursprünglich MATLAB’eigene Files befinden,

32

1 Einführung in MATLAB

z. B. C:\Programme\MATLAB\R2011a\. Wird ein anderes Verzeichnis als aktuelles ausgewä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

variable= string =

fid

=

disp ( string ) disp ( variable ) num2str ( variable , format ) int2str ( variable) input ( string ) input ( string, ’s’ ) pause  ( zeit )  fprintf ( fid, format-string, variable ) sprintf ( format-string, variable ) fopen ( datei.endung, write / read ) fclose ( fid )

Textausgabe, z. B. string=’Ausgabe’ Unformatierte Datenausgabe Konvertiert Real-Variable in String Konvertiert Integer-Variable in String Einlesen der Variablen variable Einlesen des Strings string Pause bis Tastenbetätigung/Zeitablauf Datenausgabe u. a. in ASCII-Datei formatierte String-Ausgabe; ANSI C Datei öffnen 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 Formatierungshilfen \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

1.5 Programmerstellung, MATLAB Script und Function

>> sprintf(’%3.2e’,a) ans = 1.23e+001

33

% Ausgabe als Character bzw. String % class char, endgültige Ausgabe mit disp

>> disp([’a = ’,num2str(a,’%3.2f’)]) >> disp([’a = ’,num2str(a,4)]) >> disp([’a = ’,sprintf(’%3.2f’,a)]) a = 12.35

% [...] beachten; oder % oder

>> % 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 anschließ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)]; fid = fopen(’Text_File.text’,’w’); fprintf(fid,’%3.6f %10.6e\n’,x); fclose(fid);

% % % %

Datenerzeugung Datei öffnen, fid Ident. formatierte Ausgabe 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 1.570796 3.141593 4.712389 6.283185

1.5.3

0.000000e+000 1.000000e+000 1.224647e-016 -1.000000e+000 -2.449294e-016

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 ProgrammAblauf verfügbar und können somit zur Datenkontrolle abgerufen oder zur grafischen Ausgabe weiterverarbeitet werden. D. h. die Variablen sind global.

34

1 Einführung in MATLAB

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-Vereinbarung, 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 Programmausfü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 EditorMenü-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 eingeblendet 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 Command 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

1.5 Programmerstellung, MATLAB Script und Function

35

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 Ergebnisse. 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 fortlaufend 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 dafü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 zweitens 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) Functions. 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üsselwort function) zur Verfügung, es ist ebenfalls ein M-File. Bis auf die Ausgangsvariablen sind alle

36

1 Einführung in MATLAB

vorkommenden Variablen lokale Variable und stehen somit nicht im Workspace. Der FunctionKopf 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 FunctionAufruf 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 aufgebaut 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); >> [x,y]=fkreis(4); >> [~,y]=fkreis(4);

% zeichnet Kreis mit r=2, keine Ausgänge % mit Übergabe von x, y; Workspace-Daten % 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 >> [x,y]=func_h(2); % ab MATLAB 7

bis MATLAB 6.5..

Die Befehle nargin, nargout (number of function input, output arguments), können zur Kontrolle 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

1.5 Programmerstellung, MATLAB Script und Function

37

werden. Mit R als Eingang wird ein einzelner Kreis, mit R, r ein zusätzlicher Innenkreis bearbeitet. 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 tol && I < Imax 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 Datentransfer 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.

40

1 Einführung in MATLAB

Das obige Beispiel ließe sich auch mit einer traditionellen Function erzielen und bietet somit 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 while abs(ab) > tol && I < Imax ................ 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 Nested 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); >> y2 = newton_parent(1.0e-02) y2 = @newton_parent/newton_it

% Handle y1 für tol=1e-7 % Handle y2 für tol=1e-2

Wir können jetzt, wie bisher, diese individuellen Functions z. B. für die Startwerte 3 und 6 auswerten. >> y1(3) ans = 6.154681694899654e-001 >> y2(6) ans = 6.154681876614523e-001

% Rechnung mit tol=1.0e-07

% Rechnung mit tol=1.0e-02

In diesem Fall werden einige Variablen der Parent Function nur einmal zugewiesen bzw. berechnet, 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_Creation.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 ausgein der Editor-Kopfzeile gestartet werden wählte Programmabschnitte (Zellen) mit dem Button

1.5 Programmerstellung, MATLAB Script und Function

41

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 beispielorientiert 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; >> z=g(c,b) z = 4.9497e+000 9.9497e+000

% neue Variablen eingeführt % c -> a, Ausführung der Funct. 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; f = @(y) cos(om*y); t=linspace(0,2*pi/om); f(t);

% % % %

Variablenzuweisung Function-Formul. class: function_handle Zeitfolge 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; [t,y] = eulerApprox(fdgl,ta,te,y0,h);

% Function Handle der Dgl. % 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.

42

1 Einführung in MATLAB

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 verfolgt werden. Dies soll wie in [25] an dem Programm-Code zur Berechnung eines Mandelbrots nach http:/www.students.tut.fi/∼warp/MandScript/ erfolgen: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

clear xmax=2; steps=2000; % und 500 maxiter=32; for m=1:steps for n=1:steps c=-xmax+2*xmax*n/steps-.5 + i*(-xmax+2*xmax*m/steps); z=c; for r=0:maxiter z=z*z+c; if abs(z)>2 break end end Z(m,n)=sqrt(r/maxiter); end 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 Ergebnis 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 Spalten 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:

1.5 Programmerstellung, MATLAB Script und Function

43

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 % einmaliger Aufruf, Variablen-Zuweisung i=sqrt(-1); 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 MATLAB 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 Rechenzeitreduzierung von ca. 90 % bzw. ca. 60 % erreicht worden. Bemerkenswert ist der starke 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 Rechenzeit ausgereizten Code zu erzeugen. Wichtig ist dennoch einen gut strukturierten und damit leicht nachvollziehbaren Code zu schreiben, wobei übliche programmiertechnische und zeitreduzieren-

44

1 Einführung in MATLAB

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 Veranschaulichung 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äsentieren. Erweiterungen sowie Grafik-Beispiele in [41], [53], [57] und insbesondere die MATLABDemo-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 verstehen, 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 Eigenschaften 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 KindObjekte: Image, Light, ....., Text – auch als Kern-Objekte bezeichnet – zugeordnet. Die vollstänunter Handle Graphics / Object Properties einzusehen. dige Hierarchie ist im Help Browser In der Root-, Figure- und Axes-Ebene sind nach dem Start von MATLAB Standardwerte festgeschrieben, 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 spezifizierende 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. Übersichtlicher 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 Variable, 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 festgeschriebener Eigenschaften (Properties) erhält man mit get(), mögliche Eigenschaftswerte (Property Values) werden durch set() 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 ZellStruktur 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 GrafikFenster. 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’, ... ’Position’,[100 100 300 100 ], ... ’NumberTitle’,’off’, ... ’Name’,’name’, ... ’MenuBar’,’none’)

% Einheiten, z. B. auch centimeters, pixels % linke untere Bildecke, Breite, Höhe % Figure nummer nicht einblenden % name neuer Figure-Name % Menü-Leiste ausblenden

6 Handle Graphics eingetragenes Warenzeichen von The MathWorks Inc.

46

1 Einführung in MATLAB

ä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) subplot (zeile,spalte,zähler) gcf (get handle to current figure) clf (clear current figure) clf reset delete (figure(nummer)), delete (nummer) close (nummer) close all drawnow shg entspricht figure (gcf)

Erzeugen, Ansprechen einer Figure Erzeugen eines Subplots Aktuelle Figure-Handle Rücksetzen, löschen der Children wie clf + figure properties zurückgesetzt Figure, Handle mit nummer löschen Figure nummer schließen alle Figures schließen Bildschirmaufbau Figure anzeigen (show graph window)

◮ Beispiel: Nachträgliche Änderung der Fenstergröße (Figure): % aktuelle Größe p = get( gcf,’Position’ ); 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 SubplotFenster unterteilt werden. Mit der Variablen zähler wird zeilenweise von links oben durchnummeriert, z. B. für das zweite Bild subplot(2,1,2) oder subplot(212) Verträgliche Kombinationen u. a. wie in:

oder

subplot 212

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 (x, [ y; z ] , [ plotstil_y, plotstil_z ] line ( x , y , ’PropertyName’,-Value, ... ) line ( ’PropertyName’,PropertyValue, ... ) comet (  x ,  y , Komet-Länge  ) stairs (  x ,  y  , plotstil  , ...) stem ( x ,  y  , ’filled’, plotstil  , ...) spy ( matrix  , plotstil  ) semilogx ( x ,  y  , plotstil , ...  ) semilogy ( x ,  y  , plotstil , ...  ) loglog ( x ,  y  , plotstil , ...  )

Plot der Funktion y = f (xx), lineare Achsteilung z. B. » plot(x,[y; y1],[’.’,’-’]) Plot, High-Level Aufruf, vgl. S. 57 Plot, Low-Level Aufruf, vgl. S. 57 Animation einer Trajektorie treppenförmige Grafik, lineare Achsteilung Plot, diskrete Linien zu x j mit ◦-Marke, linear Visualisierung, Sparse-Matrix-Besetzung Plot, x-Achse logarithmisch Plot, y-Achse logarithmisch 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 plotBefehl 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

48

1 Einführung in MATLAB

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:

Farben k b c g

schwarz blau cyan grün

vgl.: [1 1 0]

r rot m magenta y gelb w weiß

Linien - durchgezogen - - gestrichelt : gepunktet . Punkte -. strichpunktiert

Marken ◦ Kreise * Sterne + Kreuze x x-Marke usw.

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 plotBefehl 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 (Properties) 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 EinmassenSchwingers 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

Grafik-Ausdruck

Programm-Code 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]) L = axis axis ([L(1:3), y_max]) axis ([-inf x_max y_min y_max]) axis  on | off | auto | equal | square | tight  xlim([x_min x_max]), ylim, (zlim) linkaxes(ax  option  ) grid  on | off  gca

(get handle to current axis)

xlabel (string),

ylabel (string)

title (string) text (x_position, y_position, string) legend (string_1, string_2, ...  , position ) \alpha | \omega | \Omega | _ | ˆ |.. interpreter {tex} | latex | none

Manuelle Achsen-Skalierung, axis ist Vektor Zuweisung der aktuellen Skalierung Umskalierung eines/mehrerer Achsmaße mit inf folgt automatische Skalierung Achs-Befehle: Ein- Ausblenden, Skalierung Achs-Skalierung 2D, (3D) Verknüpfung der Subplot-Skal. vgl. Beispiel Gitternetz ein-, ausblenden Aktuelle Achs-Handle x-, y- Achsen-Beschriftung Grafik-Überschrift positionierten Text einbringen Linienlegende mit Positionsvereinbarung TEX -Mode, griechische u. mathe. Zeichen Umschaltung des Textmodes, TEX, LATEX

Die Befehle der oberen Tabelle werden u. a. im unten ausgeführten Beispiel erläutert. Bemerkung 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 Search: Text Properties→Link: TeX Auswahl. In der Symbol-Tabelle unter: Button Character Sequenze Table sind die zulässigen Zeichen zu finden. Einige Beispiele werden im Demo-Programm LatexBeschr.m in [52] gezeigt.

50

1 Einführung in MATLAB

◮ Beispiel: Gesucht ist der Amplituden- und Phasenfrequenzgang eines gedämpften EinmassenSchwingers 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 Ψ C =

q 1  , 2 2 ω0 (1 − η )2 + 4D2 η 2

Ψ = arctan

2Dη , 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-Einstellung 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 Optionen ’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); x2=-4*pi:0.1:4*pi; y2=cos(x2); ax(1)=subplot(2,2,1); plot(ax(1),x1,y1); title(ax(1),’Subplot 1’) ax(2)=subplot(2,2,2); plot(ax(2),x2,y2); axis tight title(’Subplot 2’) linkaxes([ax(2), ax(1)],’xy’)

% Subplot 1 % Subplot 2 % automatische Skalierung

% an Extremwerte angepasst % 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.

52

1 Einführung in MATLAB

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 Schwingungssignals 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 (figure), 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 h = 0 1.0000 170.0134 172.0134 171.0139

% vgl. auch: all = findall(h)

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’) ans = ’root’ ’figure’ ’axes’ ’text’ ’line’

% vgl. auch: get(all,’Type’) % % % % %

Bildschirm Grafikfenster Koordinatenachsen Texteingabe Linien, inklusive der Markierungen

D. h. mit der obigen findobj-Anweisung finden wir die Handles des Root-Objekts mit allen KindObjekten, vgl. Bild 1.8. Mit dem set-Befehl kann die Liste möglicher Eigenschaften, mit dem get-Befehl die eingestellten 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öglichkeiten 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} ]

54

1 Einführung in MATLAB

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 abgefragt 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 erhalten wir wieder mit findobj und get >> H = findobj ans = H = 0 2.0000 1.0000 343.0134 170.0134 344.0139 172.0134 171.0139

>> get(H,’type’) ans = ’root’ ’figure’ ’figure’ ’axes’ ’axes’ ’line’ ’text’ ’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(, ’PropName’, PropValue’) beschränkt die Suche auf das Objekt 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 GrafikObjekt 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) plot(t,0.8*sqrt(t)); get(gca) set(gcf,’Color’,[0.6 0.6 0.6]) set(gca,’Nextplot’,’add’) plot(t,0.6*sqrt(t)); set(gco,’LineWidth’,3) set(gca,’Nextplot’,’replace’)

% % % % % % % %

Grafik-Fenster öffnen Plot-Anweisung Axes-Eigenschaften anzeigen Farbe des Grafik-Fensters ändern Folge-Plot ins gleiche Fenster 2. Plot Linienstärke ändern 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 Eigenschaften 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,. . .).

56

1 Einführung in MATLAB

D. h. gleichzeitig mit der Grafik-Anweisung werden gewählte Eigenschaften in der Parameterliste 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 LineStyle LineWidth Color Marker MarkerSize MarkerFaceColor MarkerEdgeColor FontWight FontSize

PropertyValue { - } | - - | -. | : | none { 0.5 }, 1, ... ’r’, ..., [ 0.5 0.2 0.4 ], .. + | o | * | . | < | , ... ... , 2, ... ’m’, ..., [ 0.5 0.1 0 ], ... ’b’, ..., [ 1 1 0.5 ], ... light | {normal} | demi | bold ...| 5 |, ...| {10} |, ...| 12 |, ...

Color (Grund-, Mischfarben) [110] y yellow [101] m magenta [011] c cyan [100] r red [010] g green [001] b blue [111] w white [000] k black [ 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 LineStyleOrder und ColorOrder usw. und andererseits die bekannten Eigenschaften, wie LineWidth, Color, im Zusammenhang mit Cell Arrays zu verwenden, was die folgenden Anweisungen 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 anbringen 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’;

58

1 Einführung in MATLAB

Bild 1.15: Text außerhalb der Grafik, bzw. Grafik in Grafik str(2) = {’ y = A{\ite}^{-\alpha{\itt}}’}; str(3) = {’Parameter:’}; str(3) = {’ A = 0.25’}; str(4) = {’ \alpha = .005’}; str(5) = {’ t = 0:900’}; set(gcf,’CurrentAxes’,h) text(.025,.5,str,’FontSize’,12)

1.6.2.5

% str ist Cell Array

% 1. Achssyst. aktiv % Text einbringen

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 – erzeugter 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 werden 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 FensterLayouts sind gegenüber den Vorgängerversionen neu gestaltet, neue Features sind hinzugekommen. Die meisten Eigenschaften sind aber bereits in den Vorgängerversionen enthalten. Wir wollen 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 verfeinerte Grafik angeordnet sein. Dies kann nur ein Einstieg in diese Methode sein. Eigene Experimente sollten den Umgang mit diesem Tool vertiefen. Eine mögliche Vorgehensweise: 1. Erzeugung der Plot-Daten im Command Window und öffnen des Grafikfensters: y=sin(t); y1=0.5*y; figure >> clear, t=(0:0.1:2)*pi; 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 einfärben und die Taste wieder frei geben. 4. Grafik-Erstellung: In Figure Palette/Variables die drei Vektoren t, y, y1 auswä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. Gleichzeitig werden im Property Editor die Anzeigen -Figure, -Axes, -Lineseries und das Layout angepasst. Diese Vorgänge lassen sich auch im Grafik-Fenster durch Positionieren 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ählten 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

60

1 Einführung in MATLAB

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) eingeblendet. 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 angezeigt. 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 Tube – zu entnehmen. Vorhandene Grafiken können mit den Tools unter dem Button Insert auch unmittelbar ergä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

plot3 ( x, y, z  , plotstil  ) comet3 ( x, y, z  , komet-länge  ) mesh ( x, y, z  , farbe  ) surf ( x, y, z  , farbe  ) surfc ( x, y, z  , farbe  ) patch ( x, y  , z  , farbe ) waterfall ( x, y, z ) contour3 ( x, y, z  , v  ) contour ( x, y, z  , v  )

[X,Y]=meshgrid ( x, y ) box  on | off  view ( az, el ) zlabel (string)

3D Plot-Befehle 3D-Linien-Plot z. B. Parameterdarstellung einer Funkt. 3D-Animation einer Trajektorie 3D-Gitter-Plot, Drahtmodell expl. Funkt.: z = f (x, y) 3D-Fläche-Plot, siehe auch surfl mit Ausleuchtung wie surf + Höhenlinien 2D-, 3D-Fläche-Plot, vgl. auch fill, fill3 3D-Wasserfall-Plot 3D-Plot von Höhenlinien 2D-Plot von Höhenlinien Koordinatenmatrizen für Schnittpunkte in der x, y-Ebene Box ein- bzw. ausblenden Blickwinkel: Perspektive ändern, Azimut-, Elevation-∠ z-Achsen-Beschriftung, + xlabel, ylabel

Die Darstellungsmöglichkeiten dreidimensionaler Zusammenhänge reichen von einfachen Linien- 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 Beispiele), 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 vorgegeben, 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 ˙ = −ΩC sin (Ωt −Ψ ) x(t) = C cos (Ωt −Ψ ), x(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

62

1 Einführung in MATLAB

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 beidseitig 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öglichkeiten 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 automatisiert 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 Structure >> Xp = surf2patch(X,Y,Z); >> 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 aktiviert. Für z. B. C_farbe=Z passt sich die Farbgebung an die Visualisierungsdaten an. Verformungs-, 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

64

1 Einführung in MATLAB

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’) subplot(2,2,2) % 2. Grafik surf(X,Y,Z,0.6*ones(size(Z))) % Mit Farb-Matrix caxis([0 1]); colorbar % Farblegende einblenden subplot(2,2,3) % 3. Grafik surf(X,Y,Z,’EdgeColor’,’interp’,’FaceColor’,[0.7 0.7 0.7]) subplot(2,2,4) % 4. Grafik surf(X,Y,Z,’FaceLighting’,’phong’,... ’EdgeColor’,’none’,’AmbientStrength’,0.25)

1.6 Grafik

caxis([-1 1.25]); colorbar light(’Position’,[-2,2,10]) lighting phong

65

% Lichtposition x, y, z

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:

66

1 Einführung in MATLAB camlight light

Lichtposition Lichtrichtung hier: x-Richtung

lightangle lighting material

Lichtposition in sphärische Koordinaten Ausleuchtungsart Materialreflektion

headlight, right, left light(’Position’, [1 0 0] , . . .  ’local’ ) ’Style’, ’infinite’ lightangle(az,el) flat, gouraud, phong, none 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 behandelten 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 Rechnerleistung, 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 Beispiele 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) lassen sich bequem mit der Online-Hilfe interpretieren und vervollständigen. Folgende Built-In Functions eignen sich zur Animation: 2D-Modelle (Linien, Flächen): plot | line | patch | fill

patch, fill für farbig angelegte Flächen

1.7.2

3D-Modelle (Oberflächen): patch | fill3 | surf | surfl

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 Schreibvorganges. 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 hochwertige 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-OderLogik (xor). D. h. nur Veränderungen werden neu dargestellt, dies ergibt einen sehr schnellen Bildschirmaufbau allerdings mit Qualitätsverlusten insbesondere bezüglich der Farbe. • background: Hintergrundobjekte werden überschrieben, sie verschwinden auf dem Bildschirm. 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

68

1 Einführung in MATLAB

(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(...) abgespielt 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ächenmodell einem Handle (hier: h) zuzuweisen. Mit den zwei folgenden Zeilen erhalten wir, wie

1.7 Animation von 2D- und 3D-Modellen

a:

b:

69

c:

Bild 1.21: Bilderfolge zur surf-Anweisung

gehabt, eine neue Achs-Skalierung und den Modus zur Festschreibung dieser. Es folgt die Einstellung 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ächenund Volumenmodellen mit technischem Hintergrund. Anhand einfacher Beispiele sollen Methoden 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 beispielorientiert erarbeiten. Dazu legen wir das in Bild skizzierte Fachwerk, welches um den Knoten 1 eine Schwenkbewegung [−π/4, π/4] ausführen soll, zugrunde.

70

1 Einführung in MATLAB

Zum Linienmodell gehört die Knotenfolge (Polygonzug)

3

2 → 3 → 4 → 2 → 1 → 4

✻y

und damit die zugehörigen Koordinatenvektoren x = (2.2, 2.2, 1.1, 2.2, 0.0, 1.1) y = (0.0, 4.2, 1.0, 0.0, 0.0, 1.0) der Knoten. Die Plot-Anweisung

✻

4.2 4

Φ (t) ② ✉

1

✻

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 Φ , T = . xT = 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; t=linspace(0,pi,nframes); for count=1:nframes, ........ vier Zeilen wie oben ........ F(count) = getframe;

% Anzahl Zeitschritte % Zeitvektor

% Frame-Erst. + Ausg.

1.7 Animation von 2D- und 3D-Modellen

end; pause(0.5) movie(F,8);

71

% Zeitverzögerung % 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 Kreissegment. 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.

72

1 Einführung in MATLAB

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 PlotKoordinaten einfach anzugeben waren. Ist dies nicht mehr möglich, dann liefert die Function 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 Knotenverbingungen 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 werden. 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 ⎢ 2,2 0,0 xy = ⎢ ⎣ 2,2 4,2 1,1 1,0

⎤ ⎥ ⎥ ⎦

Knoten 1 Knoten 2 Knoten 3 Knoten 4

Die Plot-Daten werden nun mit % für die Ausgangslage [x,y] = gplot(A,xy); 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 Animation von 2D- und 3D-Modellen

1.7.4

73

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 Linienelementen 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 Orientierung nach MATLAB (vgl. XDir, YDir, ZDir) zugrunde, vgl. Bild 1.24. Die xM -Richtung soll y yM , x

✻zM , y

xM , z ✸

Breite

■ ✸ ✰ ℓ2 ✒

✰ ℓ1

❖ ✯ R

x

✻

xk = R cos Θk yk = R sin Θk

✕

✛

Θ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 zugeordnet 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 beiden 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; N=20; theta=linspace(0,2*pi,N); theta=theta+pi; Rz=[R;R];

% % % % %

Zyl.-Parameter Unterteilungsgrad N-1 Winkelelemente neue Null-Lage, wegen Optik Radien-Vektor

74

1 Einführung in MATLAB

xz=Rz*cos(theta); yz=Rz*sin(theta); zz=[l1;l1+l2]*ones(1,size(xz,2));

% x-Koordinaten % y-Koordinaten % z-Koordinaten,[rechts; links]

Die grafische Darstellung erfolgt durch cz=0.5; surf(zz,xz,yz,cz*ones(size(xz)));

% Farbgebung % 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

0

10

0 −5

10 −5

5 −10

−10

0

a: Zylindermantel

5 0

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 3s

✯

2 s x

✻

✕

✛

Θk+1

y ✣

r 4 s s

✎

R

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

1.7 Animation von 2D- und 3D-Modellen

75

mit Θk+1 = Θk + ΔΘ , was wir – ergänzt um die y-Koordinaten – als dyadisches Produkt ⎡ ⎤ ⎡ ⎤ r r ⎢ ⎥ ⎢ R ⎥   ⎥ cos Θk , cos Θk+1 , y = ⎢ R ⎥ sin Θk , sin Θk+1 x =⎢ ⎣ 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 positioniert, 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 0 −5 −10 10 5 10

0 −5

5 −10

0

Bild 1.27: Komplettes Zylinderelement

76

1 Einführung in MATLAB

Animation von Drehbewegungen Mittels Animation wollen wir einerseits Verdrehungen des Starrkörpers und andererseits Verformungen des Zylinders durch gegenseitiges Verdrehen der Zylinderstirnseiten verdeutlichen. Im Hinblick auf Probleme der Schwingungstechnik führen wir für die Extremlagen der Verdrehungen Verformungsvektoren (Eigenvektoren) ein. Sind mehrere Zustände zu simulieren, dann fassen wir sie spaltenweise zu einer Matrix (Modalmatrix) zusammen. Für unser Vorhaben bedeutet dies:     ϕ11 ϕ21 0.25 0.25 z. B. = , 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 w(tk ) = a sin (k

2π ), kmax

k = 0, 1, 2 . . . , kmax ,

tk = k

2π , kmax

a Verstärkung,

dann erhalten wir die Winkelfolge   k ϕn1 Φ 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 V=[0.25 0.25 ;0.25 -0.25]; kmax=30; a=1; h=2*pi/kmax; for k=0:kmax w=a*sin(k*h); ang=V(:,1)*w; costh1=cos(theta+ang(1)); costh2=cos(theta+ang(2)); sinth1=sin(theta+ang(1)); sinth2=sin(theta+ang(2));

% % % % % % %

xz = [Rz(1)*costh1; Rz(2)*costh2]; % yz = [Rz(1)*sinth1; Rz(2)*sinth2]; % zz = [l1;l1+l2]*ones(1,size(xz,2));% %---- zeichne äußeren Zylinder surf(zz,xz,yz,cz*ones(size(zz))); if k==0, ax=axis; else axis(ax); end F=getframe; % end

bereits berechnet Max.-Verformungen, zwei Moden Schritte, Verst., Schrittw. Bewegungsschritte Anregungssignal Winkelinkrement, Mode 1 Abkürzungen

x-Koordinate y-Koordinate z-Koordinate

Bilderfolge

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-

1.7 Animation von 2D- und 3D-Modellen

77

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

Modalmatrix (Drehung) Zeitprofil Animation

✲ ✛

zyl_3D.m

✲ Zylinder-Initial. Speicher-, Grafik- ✛ Eigenschaften

Hauptprogramm

draw_zyl.m

GrafikElemente

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) surf(x,y,z)

% Gitterdarstellung % 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örper erstellt werden. Dazu wird die Kontur des Ausgangsobjekts in Form der Radien in einem Parametervektor als Eingang formuliert. Die damit erhaltenen Elemente sind äquidistant auf der Rotationsachse (z-Bereich [0,1]) aneinandergereiht. Durch Anpassung der x-,y-,z-Werte sind dann

78

1 Einführung in MATLAB

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’); axis equal, axis off subplot(3,4,2) mesh(x2,y2,2*z2,’EdgeColor’,’k’); axis equal, axis off subplot(3,4,3) mesh(x3,y3,z3,’EdgeColor’,’k’); axis equal, axis off subplot(3,4,4) mesh(x4,y4,z4,’EdgeColor’,’k’); axis equal, axis off

% Zylindermantel

% Kegel

% Kegelstumpf

% 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 meshAufruf auch beliebig zugeordnet werden. Zur Größenänderungen und/oder Verschiebungen werden die Koordinatensätze additiv und/oder multiplikativ verändert, vgl. Kegel im obigen Programm. Ä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].

1.7 Animation von 2D- und 3D-Modellen

79

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 Lageranbindung, 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 Radienvektor [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. Dementsprechend 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:

80

1 Einführung in MATLAB

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 Achsskalierungen 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: rotate. 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] erfolgt. 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 mathematischer Probleme in der MATLAB-Umgebung. Wir unterscheiden arithmetische (numerische) Algorithmen und algebraische (symbolische) Algorithmen. Der grundlegende Unterschied ist in Tabelle 1.1 angedeutet. In der linken Hälfte ist der bekannte Ablauf einer numerischen Rechnung 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 >> a = 2.5; b = 3.0; >> c = (a + b)^3 c = 166.3750

symbolisches Rechnen >> syms a b >> c = (a + b)^3; >> expand(c) ans = a^3 + 3*a^2*b + 3*a*b^2 + b^3

Basis der Toolboxen ist ab der Version 2008b7 das Computeralgebrasystem MuPAD (Multi Processing Algebra Data Tool) mit der MuPAD Engine. Ursprünglich von der MuPAD-Forschungsgruppe an der Universität Paderborn entwickelt. Heute ausschließlich Bestandteil der Symbolic Math Toolbox.

7 vor 2008b das Computeralgebra-System Maple

82

1 Einführung in MATLAB

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 Beispiels 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 mathematischen 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 Gleichungssystemen

Symbolische und numerische Lösungen linearer algebraischer Gleichungen und Differenzialgleichungen

Spezielle mathematische Funktionen

Spezielle Funktionen der klassischen angewandten 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 Command-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\symbolic. 1.8.1

Online-Hilfe

Einen Überblick bezüglich des vollständigen Function-Angebots - gegenüber Tabelle 1.2 - erhalten wir mit

1.8 Computeralgebra unter MATLAB, die Symbolic Math Toolbox

⇒ >> help symbolic oder >> helpwin symbolic

83

oder >> doc symbolic

Die Symbolic Math Toolbox overloads viele numerische Functions von MATLAB, d. h. die symbolische 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 Datenstruktur, welche ein String des Symbols darstellt. Es existieren symbolische Objekte, die symbolische Variable, Ausdrücke und Matrizen repräsentieren. Den Unterschied zum MATLABStandarddatentyp double zeigen die beiden Beispiele >> a = sqrt(sym(2)) >> a = sqrt(2) a = 2ˆ(1/2) % class(a) → sym a = 1.4142 % class(a) → double

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.

84

1 Einführung in MATLAB

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 = [ a1_1, a1_2, a1_3] [ a2_1, a2_2, a2_3]

A = [ a11, a12, a13] [ a21, a22, a23]

b = [ b_1_1, b_1_2, b_1_3]

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. Werden 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 symbolische Form. Beispiel: gegeben sei die Matrix A, gesucht ist die symbolische Form S >> A = [ 1.1000 1.2000 2.1000 2.2000 ]; >> S = sym(A) S = [ 11/10, 6/5 ] [ 21/10, 11/5 ]

% class double

% class sym

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 (floatingpoint) 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]

1.8 Computeralgebra unter MATLAB, die Symbolic Math Toolbox

85

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 Zahlenwerte 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 andere 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 >> subs(h,2)

oder

>> subs(h,x,2)

% h class sym % 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 gleiche 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 folgender 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. Vorausgesetzt 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 Standardvariablen 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

86

1 Einführung in MATLAB

ans= 2*a*xˆ2 >> diff(f,’a’,2) ans= 2*xˆ2

1.8.5

% ∂ 2 f / ∂ a2 , zweite partielle Ableitung nach a

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) int(S ,var,a,b) taylor(S ,n) taylor(S ,n,a) limit(S ,x,a, jacobian(S,v)



’left’ ’right’

n-te Ableitung nach var, ∂ n S/∂ varn Integr. von S bezüglich var in den Grenzen a, b b class(a, b) sym oder double; a S dvar M ACLAURIN-Polynom der Ordnung 5 bzw, n-1 TAYLOR-Polynom (n-1)-ter Ordnung bezüglich a  ’left’ ) limx→a S, Richtung des einseit. Grenzw. ’right’

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 =

1.8 Computeralgebra unter MATLAB, die Symbolic Math Toolbox

87

-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 >> sn = double(s) sn = -5.8761e-001

% class sym

% class double.

88

1 Einführung in MATLAB

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 0’,’xˆ2 - yˆ2 -1 = 0’) x =

-

>> [x,y] = solve(’xˆ2*yˆ2 - 2*x -1 =

y =

1/2 1/2 1/2 1/2

5^(1/2)/2 + 1/2 1/2 - 5^(1/2)/2 5^(1/2)/2 + 1/2 1/2 - 5^(1/2)/2 + (3^(1/2)*i)/2 - (3^(1/2)*i)/2 - (3^(1/2)*i)/2 + (3^(1/2)*i)/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) -(1/2 - 5^(1/2)/2)^(1/2) 3/2 - (3^(1/2)*i)/2)^(1/2) 3/2 + (3^(1/2)*i)/2)^(1/2) 3/2 + (3^(1/2)*i)/2)^(1/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] y: [8x1 sym]

--> -->

x = XY.x 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 = (exp(t)*(2*t - 1))/4 + C5/exp(t)

% y˙ → Dy, D Operator % C5 Integrationskonstante

1.8 Computeralgebra unter MATLAB, die Symbolic Math Toolbox

89

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) b)

ω0 = 15 rad/s, Ω = 16 rad/s, D = 0,005 ω0 = 10 rad/s, Ω = 10 rad/s, D = 0,0

ermittelt werden. Wir schreiben das M-File bei_dgl.m in [52]: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

clear, close all; clc syms Om om0 t d

% D ist Differenzialoperator, D -> d

%---- Beispiel a: lineares, gedämpftes System y=dsolve(’D2y+2*d*om0*Dy+om0^2*y=cos(Om*t)’,’y(0)=0,Dy(0)=0’,’t’) y=simple(y) % Vereinfachung der Ausdrücke subexpr(y) % sucht nach gleichen Ausdrücken pretty(y), latex(y) % Ausgabe y=subs(y,{Om om0 d},{16 15 0.005}); % Param.-Substitution ezplot(y,[0,8*pi],1) % Grafische Darstellung %............................................................... %---- Beispiel b: lineares ungedämpftes System, Resonanz y=dsolve(’D2y+om0^2*y=cos(om0*t)’,’y(0)=0,Dy(0)=0’,’t’) y=simple(y); % Ausdruck vereinfachen yr=subs(y,{Om om0},{10 10}); % Parameter-Substitution ezplot(yr,[0,6*pi],2) % grafische Darstellung %---- Ermittlung der Geschwindigkeit für den Resonanz-Fall %---- 1. Differenziation yp=diff(yr,t) % zeitliche Ableitung ezplot(yp,[0,6*pi],3) % grafische Darstellung ylabel(’Geschwindigkeit m/s’) %---- 2. Differenzialgleichungssystem Y12=dsolve(’Dy1=y2, Dy2=-om0^2*y1+cos(om0*t)’,... ’y1(0)=0, y2(0)=0’,’t’) om0=10; Yp=subs(Y12.y2) ezplot(Yp,[0,6*pi],4) xlabel(’Zeit t/s’) ylabel(’Geschwindigkeit m/s’)

90

1 Einführung in MATLAB

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 y(t) =

1 t sin ω0t, 2ω0

Ω = ω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 Phasenebene, 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 Differenzialgleichungen erste Ordnung y˙1 = y2 , y˙2 =

y1 = y, y2 = y˙

−ω02 y1

+ cos ω0t,

(1.2)

y1 (0) = 0, y2 (0) = 0

wie ab Zeile 25. 1 Resonanz

0.04

Auslenkung y/m

Auslenkung y/m

0.06

0.02 0 −0.02

0.5 0 −0.5

−0.04

b)

a) −0.06 0

10 Zeit t/s

20

−1 0

5

10 Zeit t/s

15

Bild 1.32: Weg-Zeit-Verläufe des gedämpften a) und ungedämpften b) Schwingers

1.8 Computeralgebra unter MATLAB, die Symbolic Math Toolbox

1.8.8

91

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 teilweise 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 A)vv3 = −vv2 , (λ2,3E −A

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 (1.4) J = V −1A V = ⎣ 0 λ2 1 ⎦ . 0 0 λ3

Um nun einmal die Unterschiede einerseits bezüglich einer numerischen und andererseits einer symbolischen Rechnung aufzuzeigen, werden wir beide Vorgehensweisen parallel behandeln. Hierzu dient der unten aufgelistete Programm-Code sym_eig1.m aus [52]

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

%---- numerische Berechnung A=[6 12 19; -9 -20 -33; 4 9 15] % Systemmatrix n=length(A); % Dimension von A %---- numerische Bearbeitung rn=rank(A) % Rang-Ermittlung DETn=det(A) % Determinante disp(’ ’), disp(’Eigenvektoren Vn, Eigenwerte Dn, Kond.-Zahl sn’) [Vn,Dn,sn]=condeig(A) % Eigenwertproblem mit Kond.-Zahl Jn=inv(Vn)*A*Vn % Einheits- oder JORDAN-Matrix? %---- symbolische Bearbeitung syms x y z A=sym(A) % symbolische Matrix A r=rank(A) % Rang-Ermittlung DET=det(A) % Determinante %---- Defekt, Rangabfall zum doppelten Eigenw. 1 d=n-rank(A-eye(n)) [V,D]=eig(A)

% Eigenwertproblem, symb.

92

21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

1 Einführung in MATLAB

%---- Reihenfolge der Eigenwerte [-1 1 1] sowie der Eigenvekt. [Dx,I]=sort(subs(diag(D))); % Reihenfolge: Eigenwerte if I(1) > 1 V=V(:,[2,1]); end % Reihenfolge: Eigenvektoren Aeq=(eye(n)-A)*[x;y;z]+V(:,2); % lin. Gleichungen für Eigenvekt. [x,y,z]=solve(Aeq(1),Aeq(2),Aeq(3)); % Lösung xyz=[x;y;z]; % Lösungsvektor sy=findsym(xyz); % symb. Variable im Ausdruck? xyz=sym(subs(xyz,sy,1)) % Substitution sy -> 1 %---- Kontroll-Rechnung Ve=[V,xyz] % vollständiger Eigenvektor Je=inv(Ve)*A*Ve % JORDAN-Matrix %---- direkte Berechnung aller Eigenvektoren [VJ,J]=jordan(A) % J JORDAN-Matrix

Erläuterungen zum obigen Programmcode und den Ergebnissen: Ein übereinstimmendes Ergebnis 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 8.127425537743154e-001 -3.386427307392985e-001 Dn = -9.999999999999840e-001 0 0

-4.082482835849408e-001 8.164965830443175e-001 -4.082482931096022e-001

4.082482973427853e-001 -8.164965788111345e-001 4.082482878181235e-001

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 = [ 7/5, [ -12/5, [ 1,

1] -2] 1]

D = [ -1, [ 0, [ 0,

0, 1, 0,

0] 0] 1]

D. h. zum doppelten Eigenwert 1 existiert nur ein Eigenvektor, der fehlende (vv3 ) muss aus (1.3) E −A mit singulärer Koeffizienten-Matrix (E A) zu λ2,3 entsprechend den Zeilen 25 - 27 berechnet werden. Das Ergebnis ist nicht eindeutig, es wird in Abhängigkeit einer der Lösungskomponenten, 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 KontrollRechnung. Dazu ist die mit eig berechnete unvollständige Modalmatrix um v 3 zu ergänzen (Zeile

1.8 Computeralgebra unter MATLAB, die Symbolic Math Toolbox

93

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. Aufgrund unterschiedlicher Skalierung unterscheiden sich beide Ergebnisse optisch. Fazit: Derartige Sonderfälle lassen sich nur mit Hilfe der Computeralgebra lösen. Praktisch, d. h. numerisch, existieren 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 dynamischer 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) vorliegen. 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); t1=pi/4; x1=3/5; e1=subs(f,{a x t},{a1 x1 t1}) e11=subs(e1) e12=eval(e1) e121=eval(char(e1)) e13=double(e1) e14=single(e1)

% % % % % % % % %

a1=5; e2=subs(f,[a x t],[a1 x1 t1])

% numerische Variable % class(e2) double

a=sym(5); t=pi/4; x=3/5; e3=subs(f) e31=eval(e3) e311=eval(char(e3)) e32=double(e3)

% % % %

a=5;

symbolische Variable numerische Variable numerische Variable class(e1) sym class(e11) double class(e12) double, oder class(e121) double class(e13) double class(e14) single

class(e3) sym class(31) double, oder class(e311) double class(e32) double

94

1 Einführung in MATLAB

e4=subs(f) e5=eval(f)

% class(e4) double % 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 numerischer 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; hvec=vectorize(h) ergebn_1=eval(hvec)’

% numerische Daten, y Vektor, a Skalar % h vektorisieren, -> Punktoper. % Größen double -> ergebn_1 double

y=sym(y); a=sym(a); ergebn_2=eval(hvec)’ %---- Übergang zur Numerik ergebn_31=subs(ergebn_2) ergebn_32=double(ergebn_2)

% % % % %

Werte ’symbolisiert’ y, a ersetzt -> ergebn_2 sym in ergebn_2 symb ’Zahlenwerte’ darum hier ergebn_31 double ergebnis_32 double

2

Modellbildung

MATLAB und Simulink basieren auf einer mathematischen Modellierung eines zu untersuchenden Systems, die Tools SimScape, SimPowerSystems, SimMechanics, SimDriveline und SimHydraulics dagegen auf einer Modellierung physikalischer Modelle, siehe Kapitel 7. Wir wollen

uns in diesem Abschnitt mit mathematischen Modellierungs-Methoden beschäftigen. Dabei beschrä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 Überblick von Modellierungsmöglichkeiten mechatronischer Systeme findet man in [47]. Darüber hinaus wird u. a. über Analogiebeziehungen von elektrischen und mechanischen Elementen gezeigt, 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 Verwendung der impliziten Bindungen. Wir erhalten differenzial-algebraische Gleichungssysteme. • Bewegungsgleichungen in den voneinander unabhängigen Minimalkoordinaten: Aufstellen unter Verwendung der expliziten Bindungen. Wir erhalten gewöhnliche Differenzialgleichungen. 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 Methode. Wir beschreiben die Unterschiede stichwortartig anhand zweier bekannter Vorgehensweisen: 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 Verbindungselementen - z. B. Feder, elektrische Leitung -

W. D. Pietruszka, MATLAB® und Simulink® in der Ingenieurpraxis, DOI 10.1007/978-3-8348-8630-9_2, © Vieweg+Teubner Verlag |Springer Fachmedien Wiesbaden GmbH 2012

96

2 Modellbildung

• Festlegung der generalisierten (verallgemeinerten) Koordinaten qk ; es sind f Minimalkoordinaten, 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 Elemente k. • Auswertung der L AGRANGEschen Gleichung (2.110). Die synthetische Methode bietet den Vorteil, dass z. B. Kennlinien, die das Verhalten von masselosen 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 schematische 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 Bewegungsgleichungen eingehen, um daran anschließend benötigte Grundlagen und Methoden zur Formulierung 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   ∈ Rn r = ⎣ y ⎦ ∈ R3 , q T = q1 q2 · · · qn (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 · · · ⎢ a2,1 a2,2 · · · a2,m ⎥ ⎢ a1,2 a2,2 · · · ⎢ ⎢ ⎥ A =⎢ . B = AT = ⎢ . .. .. .. ⎥ , .. .. ⎣ .. ⎣ .. . . . ⎦ . . an,1

an,2

· · · an,m

oder kurz: A = (ai, j ), i = 1, 2, .., n, j = 1, 2, .., m

a1,m

a2,m

an,1 an,2 .. .

· · · an,m

⎤ ⎥ ⎥ ⎥ ⎦

(2.2)

2.2 Strukturen der Bewegungsgleichungen

• JACOBI-Matrix J gebildet mit der m × 1-Vektorfunktion f (qq),   q) ∂ f (qq) ∂ f (qq) ∂ f (qq) def ∂ f (q ∈ Rm,n , J (qq) = = ··· ∂qq ∂ q1 ∂ q2 ∂ qn ∂ fi , i = 1, 2, . . . , m, k = 1, 2, . . . , n . Jik = ∂ qk

97

(2.3)

• Totale Ableitung der Vektorfunktion f (qq(t), t) zweier Veränderlicher nach dem Skalar t ∂ f d q (t) ∂ f ∂f d f (qq(t), t) = + = J q˙ (t) + . dt ∂qq(t) dt ∂t ∂t

2.2

(2.4)

Strukturen der Bewegungsgleichungen

Im Allgemeinen können wir die nichtlineare, gewöhnliche Differenzialgleichung in expliziter oder in impliziter Vektor-Form anschreiben, z. B. x˙ = g (xx, t), oder g¯ (˙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˙ . Vielfach ist x der Zustandsvektor, z. B. x = [ q T , q˙ T ]T . Gehen wir von den oben angesprochenen Methoden (z. B. N EWTON -E ULER-Formalismen), mit denen Bewegungsgleichungen dynamischer Mehrkörpersysteme mit f Freiheitsgraden aufgestellt werden, aus, dann erhalten wir im Allgemeinen nichtlineare Differenzialgleichungen zweiter Ordnung in Normalform: M (qq, t) q¨ + f (qq, q˙ , f E , t) = 0

(2.6)

mit dem f -Vektor der verallgemeinerten Koordinaten q (t), der positiv definiten und symmetrischen f × f -Massenmatrix M = M T > 0 , dem f -Vektor f (qq, q˙ , f E , t) der gyroskopischen, dissipativen, 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). Wesentlich 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¯ 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 zeitlichen Ableitungen, d. h. Geschwindigkeit und Beschleunigung, ohne Berücksichtigung der einwirkenden 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 rechtwinklige (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 raumfest; 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 Impulsund 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 kurz nicht schreiben, d. h. r 0P → r P . Die Verschiebung (Translation) des Bezugspunktes P gegenüber (I) wird durch I r P , die Orientierung von I r PS durch eine Drehung festgeschrieben. Ist die Abbildungsvorschrift 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

2.3.1.1

= T IK K r PS .

(2.9)

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

• T KI : Transformation von (I) nach (K) →

K r PS

99

T . = T KI I r PS , T KI = T IK

T IK ist eine Orthogonalmatrix, d. h. die Transponierte ist gleich der Inversen −1 T T IK = T IK T IK = E , T IK

3 × 3 − Einheitsmatrix E .

(2.10)

Für eine Rücktransformation von (I) nach (K) gilt somit −1 T = T IK . T KI = T IK

(2.11)

Die Gesamttransformation T IK setzt sich aus drei Elementardrehungen in gewählter Reihenfolge Kz

′

Kx

❖❈❈ ✻I z ❈ ❈ I r3 ′ ❈ ✻ Ky ❈ ✿ ✘ ✘✘✘ ❈ ✙❈✘✘✘✘ ✲ ✲

α

I r2

Kz

′′

▼

′′

✻K z′ ′

✻K r3 I x, K x

Iy

′

′

β

K r1 ✴ ✛ ✘✘✘ ✘ ′ ′′ ✘✘✘ ✾ ✘ Ky , Ky

✛

K

x′′

γ

′′ K r1

❂ ✛ ✛ ✘✘❈ ✘ ′′ ✘ Kz , Kz ✘✘✘ ✘ ✾ ❈ ′′ ❈ K r2 Kx ❄❈ ❈ ❈ Ky ❄ ❈❈❲ Ky

′′

Bild 2.2: Elementardrehungen

zusammen. Diese einmal gewählte Reihenfolge muss beibehalten werden; sie ist nicht vertauschbar. Die Elementardrehungen erlauben es, durch die vielfältigen Kombinationsmöglichkeiten für jede technische Aufgabe, z. B. Kreiseltheorie, Flugmechanik, eine geeignete Drehmatrix aufzubauen. 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 anschaulichen 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 Elementardrehung α um die I x-Achse liest man die zugehörige Transformation ⎡ ⎤⎡ ⎡ ′ ⎤ ⎤ 1 0 0 K r1 I 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 ⎦ ⎣ K r2′ ⎦ = ⎣ K r2′′ ⎦ , → T β K r ′ = K r ′′ 1 0 (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 . ′′ 0 0 1 K r3 K r3

(2.14)

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 ,

zusammen. Ausgeführt erhalten wir z. B. per Computeralgebra ⎡ cos β cos γ − cos β sin γ T IK = ⎣ cos α sin γ + sin α sin β cos γ cos α cos γ − sin α sin β sin γ sin α sin γ − cos α sin β cos γ sin α cos γ + cos α sin β sin γ

(2.15)

⎤ sin β − sin α cos β ⎦ . (2.16) 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 beispielsweise 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 linearisiert werden. Bei Berücksichtigung von lediglich Größen erster Ordnung spielt die Reihenfolge der einzelnen Drehungen zur Ermittlung der Transformationsmatrix keine Rolle mehr. Infinitesimal 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 gewü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) I r˙ S

= I r˙ P + T˙ IK K r PS

(∗)˙=

d (∗), dt

K r PS

= konst.

2 http://de.wikipedia.org/wiki/Roll-Nick-Gier-Winkel

(2.17)

2.3 Grundlagen

101

Wählen wir eine einheitliche Darstellung im Inertialsystem, so folgt mit (2.9) I r˙ S

= I r˙ P + T˙ IK T KI I r PS .

(2.18)

Dabei ist der Tensor T˙ IK T KI schiefsymmetrisch, d. h. es gilt TIK T˙ KI . T˙ IK T KI = −(T˙ IK T KI )T = −T

(2.19)

Dieser schiefsymmetrische Tensor wird mit ω˜ bezeichnet und mit I ω = I [ωx , ωy , ωz ]T gebildet, wobei ωx , ωy , ωz die Winkelgeschwindigkeitskomponenten des Körpers in der Basis I sind. Der Tensor (2.19) hat die Struktur ⎤ ⎡ 0 −ωz ωy 0 −ωx ⎦ , I ω˜ TKI = −I ω˜ KI (2.20) T˙ IK T KI = I ω˜ KI = ⎣ ωz ω 0 −ω y x I 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˙ S

! = I r˙ P + I ω˜ KI I r PS = I r˙ P + I ω × I r PS ,

(2.21)

womit gleichzeitig die Bedeutung des Tildeoperators angedeutet ist. Zur Formulierung der Winkelgeschwindigkeiten definieren wir, in Analogie zu den Elementar˙ Mit ihnen wird eine Basis aufgespannt, ˙ β˙ , γ. drehungen, Elementarwinkelgeschwindigkeiten α, die weder orthogonal noch mit einem der beiden Koordinatensysteme (I) oder (K) zusammenfä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   ˙ e2 )] + (γ˙ e 3 ) ˙ e1 ) } + [T Tγ Tβ (αe Tγ (βe (2.22) K ω = {T 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 Transformationsmatrix (2.15) T IK = T αTT βTT γT durchmultipliziert, so dass

Iω

= T IK

⎡ ⎤ α˙   T T T ˙ K ω = T α T β T γ T γ Tβ e 1 , Tγ e 2 , e 3 ⎣ β ⎦ γ˙ ⎡ ⎤  α˙  = e 1 , T αTe 2 , T αTT βTe 3 ⎣ β˙ ⎦ γ˙

(2.24)

102

2 Modellbildung

folgt. Bezeichnet man nun die absoluten Geschwindigkeiten mit v , so gilt für (2.21) IvS

! = I v P + I ω˜ KI I r PS = I v P + I ω × I r PS ;

IvS

= I r˙ S .

(2.25)

Eine Darstellung im körperfesten System erhalten wir, wenn wir auf (2.25) die inverse Transformation T KI anwenden und (2.9) einsetzen: T KI I r˙ S = T KI I r˙ P + T KI T˙ IK K r PS →

K r˙ S

= K r˙ P + T KI T˙ IK K r PS ,

(2.26)

hierin ist T KI T˙ IK = K ω˜ IK

(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 Tensortransformationsgesetz für die Tildeoperatoren: ˜ IK Kω

= T KI T˙ IK = T KI T˙ IK T KI T IK = T KI I ω˜ KI T IK .

(2.28)

Die Absolutgeschwindigkeit K v S von S lautet mit (2.26) im körperfesten Koordinatensystem KvS

= K v P + K ω˜ IK K r PS .

(2.29)

Beschleunigungen: Differenzieren wir (2.17) nach der Zeit, dann folgt die Absolutbeschleunigung von S I r¨ S

= I r¨ P + T¨ IK K r PS ,

K r PS

= konst.,

(2.30)

bzw. bei einheitlicher Darstellung im (I)-System I r¨ S

= I r¨ P + T¨ IK TKI I r PS .

Gleichung (2.31) formen wir noch um:    d ˙ ˙ ˙ T ¨ ¨ − T r r = + T (T T ) T T I S I P IK KI IK KI IK KI I r PS dt   = I r¨ P + I ω˙˜ + ω˜ ω˜ KI I r PS .

(2.31)

(2.32)

Schreiben wir für die absoluten Beschleunigungen 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¨ S = T KI I r¨ P + T KI T¨ K r PS ˜˙ + ω˜ ω˜ )IK K r PS , K a S = K a P + K (ω

(2.34)

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

= K v˙ P + K ω˜ IK K v P + K ω˙˜ IK K r PS + K ω˜ IK (K ω˜ IK K r PS )   = K v˙ P + K ω˙˜ IK K r PS + (K ω˜ IK (K v P + K ω˜ IK K r PS )) = K v˙ S + K ω˜ IK K v S .

(2.35)

Die Winkelbeschleunigung genügt ˙ Iω

=

d (I ω ) dt

(2.36)

und somit dem Transformationsgesetz d d TIK K ω ) (I ω ) = T KI (T dt dt TIK K ω˙ + T˙ IK K ω ) = T KI (T = K ω˙ + K ω˜ IK K ω ˙ = K ω˙ . Iω

T KI I ω˙ = T KI

T KI

(2.37)

Dabei ist K ω˜ IK K ω = 0 (Vektorprodukt mit sich selbst), so dass die absolute Winkelbeschleunigung 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 erarbeitet 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 unmittelbar 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 anzuschreiben, 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 unter Berücksichtigung idealer Lagerungen (Bindungen), siehe [54], zu einem globalen Gesamtsystem, 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 Koppelelement (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, verallgemeinerte Koordinaten) T  q = q1 , q2 , . . . , q f

(2.39)

zugeordnet. Der Satz q , q˙ erfüllt die holonomen Zwangsbedingungen, siehe [56]. Damit lassen sich dann die Ortsvektoren und deren zeitliche Ableitungen r (qq, t), r˙ (qq, q˙ , t) als Funktionen der verallgemeinerten Koordinaten anschreiben. Die totale Ableitung nach t genügt r˙ =

∂rr ∂rr , q˙ + ∂qq ∂t

r (qq, t),

r˙ (qq, q˙ , t)

(2.40)

woraus durch partielle Differenziation ∂ ∗ /∂ q˙ die wichtige Beziehung ∂ r˙ ∂rr = ∂ q˙ ∂qq

(2.41)

abgeleitet werden kann. In (2.39) sind Anteile der Translation und Rotation (z. B. K ARDAN-Winkel) enthalten. Ortsvektor r und Winkelgeschwindigkeit ω eines holonomen Mehrkörpersystems sind einerseits explizit von der Zeit t abhängig oder andererseits unabhängig. Dies bedeutet für eine Zeitabhängigkeit: • Translation: Ortsvektor, Absolut-Geschwindigkeit, -Beschleunigung Ir

= I r (qq, t)

∂I r (qq, t) ∂I r (qq, t) = J T (qq, t) q˙ + v¯ (qq, t) q˙ + ∂qq ∂t d¯v (qq, t) q, q˙ , q¨ , t) = J T (qq, t)¨q +J˙T (qq, t)˙q + = J T (qq, t)¨q + a¯ (qq, q˙ , t) I a (q dt q, q˙ , t) = I v (qq, q˙ , t) I r˙ (q

=

(2.42)

mit ∂JJ T (qq, t) ∂ (JJ T (qq, t) q˙ ) J˙T (qq, t) = , q˙ + ∂qq ∂t ∂ v¯ (qq, t) ∂ v¯ (qq, t) d¯v (qq, t) q˙ + = 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) = ∂ q1 ∂ q2 ∂qf ∂qq

(2.43) (2.44)

(2.45)

2.3 Grundlagen

105

• Rotation: Winkelbeschleunigung ˙ (qq, q˙ , q¨ , t) Iω

= J R (qq, q˙ , t) q¨ +

∂I ω (qq, q˙ , t) ∂I ω (qq, q˙ , t) q˙ + ∂qq ∂t

mit der JACOBI-Matrix der Rotation  ∂ I ω (qq, q˙ , t) ∂ ω (qq, q˙ , t) J R (qq, q˙ , t) = I = ∂ q˙1 ∂ q˙

∂ I ω (qq, q˙ , t) ∂ q˙2

(2.46)

...

∂ I ω (qq, q˙ , t) ∂qf



. (2.47)

Aus (2.46) folgt unmittelbar ∂ I ω˙ ∂ Iω = ∂ q¨ ∂ q˙

(2.48)

Sind hingegen I r = r (qq) und I ω (qq, 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˙ P in (2.21), durch (2.42), (2.46) ersetzt oder alternativ (2.42), (2.46) für den ausgewählten Bezugspunkt direkt angesetzt werden. Alle hier angegebenen Formulierungen, (2.42)-(2.47), eignen sich unmittelbar für eine symbolische 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 zylindrischen 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 Kardanwinkel α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 symbolisch mit Hilfe der Computeralgebra auszuwerten. Wesentlich dabei ist, dass symbolische 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 ⎦ (2.50) I r Q1 (q cos α1

• Absolutgeschwindigkeit, siehe auch (2.42):

∂ I r Q1 d α˙ 1 (I r Q1 ) = I r˙ Q1 = dt ∂ α1 q) ! ∂I r Q1 (q q˙ = J TQ1 (qq) q˙ = q ∂q

q, q˙ ) = I v Q1 (q

(2.51)

• Absolutbeschleunigung, siehe auch (2.42): ∂ I r Q1 ∂ 2 I r Q1 2 d α¨ 1 + α˙ (I v Q1 ) = dt ∂ α1 ∂ α12 1 ∂ (JJ TQ1 (qq) q˙ ) ! q˙ = J TQ1 (qq) q¨ + ∂qq

q, q˙ , q¨ ) = I r¨ Q1 I a Q1 (q

=

(2.52)

• Winkelgeschwindigkeit: Iω 1

= [ α˙ 1 , 0, 0 ]T

(2.53)

• Winkelbeschleunigung , siehe auch (2.46): [ α¨ 1 , 0, 0 ]T q) ! ∂I ω 1 (˙ q¨ = J R1 q¨ . = ∂ q˙

˙ 1 (¨q ) = Iω

(2.54)

Hierin sind α1 , α˙ 1 , α¨ 1 bzw. q , q˙ , q¨ im Sinne der Computeralgebra symbolische Variable; vgl. Abschn. 1.8.

2.3 Grundlagen

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 I_v_Q1 = diff(I_r_Q1,alpha_1)*alpha_p1; % Absolut-Geschw. I_a_Q1 = diff(I_r_Q1,alpha_1)*alpha_pp1 +... % diff(I_r_Q1,alpha_1,2)*alpha_p1^2; % Absolut-Beschl.

(2.50) (2.51) (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 Drehmatrix 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 ω˜ KI2 I r P2 Q2 , I r P2 Q2 = TIK K r P2 Q2 q) ∂ I r P2 (qq) ! ∂ I r P2 (q q˙ + I ω˜ KI2 I r P2 Q2 , = J TP2 = ∂qq ∂qq q) oder ∂I r Q2 (q q˙ = J TQ2 q˙ , = q ∂q

q, q˙ ) = I vP2 I v Q2 (q

wobei I vP2 =I vQ1 nach (2.51) und I ω˜ KI2 mit ⎡ ⎤  α˙ 2  T T T T ˙ I ω 2 = e 1 , T α2 e 2 , T α2 T β2 e 3 ⎣ β2 ⎦ = I [ ωx , ωy , ωz ]2 0

(2.57)

(2.58)

nach (2.24) zu ˜ KI2 Iω

⎡

0 = ⎣ 0 −ωy I

0 0 ωx

⎤ ωy −ωx ⎦ 0 KI

(2.59)

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 (ω˙˜ 2 + ω˜ 2ω˜ 2 )KI I r P2 Q2 ∂ (JJ TQ2 (qq) q˙ ) ∂ I r Q2 ! q˙ , J TQ2 = = J TQ2 (qq) q¨ + ∂qq ∂qq

q, q˙ , q¨ ) = I a P2 I a Q2 (q

(2.60)

107

108

2 Modellbildung

und für die Winkelbeschleunigung: d I ω 2 (qq, q˙ ) ∂ Iω 2 ∂ Iω 2 q¨ + q˙ = dt ∂ q˙ ∂qq ∂ Iω 2 1 q˙ = J R2 q¨ + ∂qq

˙ 2 (˙q , q¨ ) = Iω

(2.61)

mit den JACOBI-Matrizen bezüglich q und 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 Beziehungen 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örpern 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˙ = 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. ReaktionsKrä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˙ S ,

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 m KaS =

Kf

(S)

,

(2.65)

wobei die Absolutbeschleunigung des Punktes S nach (2.34) bzw. (2.35) mit den zeitlichen Ableitungen 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 IL

(S)

= 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: ˙ = I m (S) .

IL

(2.67)

Der als symmetrisch vorausgesetzte Trägheitstensor I I (S) ist in der Regel zeitabhängig im Gegensatz 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 II

(S)

= 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 Koordinaten 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) ˙ IL :   ˙ (S) = d I I (S) I ω = dt =

IL

 d  T IK K I (S) T KI I ω dt (S) ˙ (S) (S) ˙ TIK T˙ KI I ω II I ω + T IK T KI I I Iω + II

(2.70)

= I I (S) I ω˙ + I ω˜ KI I I (S) I ω , womit der Drallsatz bezüglich S angeschrieben werden kann II

(S)

˙ Iω

+ I ω˜ KI I I (S) I ω = I m (S) .

(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 KI

(S)

˙ Kω

+ K ω˜ IK K I (S) K ω = K m (S) .

(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 Kf

(P)

=

(S)

= K m (P) − m K r˜ PSIK

Km

Kf

(S)



KaP

+

K

  ω˙˜ + ω˜ ω˜ IK

K r PS



mit dem schiefsymmetrischen Tensor K r˜ PSIK des Ortsvektors K r PS = [ K rx , K ry , K rz ]T ⎤ ⎡ 0 −rz ry 0 −rx ⎦ . K r˜ PSIK =: K r˜ PS = ⎣ rz −r r 0 y x IK K

(2.73)

(2.74)

Berücksichtigen wir noch den S TEINERschen Verschiebungsanteil, so erhalten wir den auf P bezogen Trägheitstensor KI

(P)

= K I (S) + m K r˜ PS K r˜ TPS .

Setzen wir (2.73) und (2.75) in (2.72) ein

(2.75)

2.4 Newton-Euler-Methode



KI

(P)

− m K r˜ PS K r˜ TPS



˙ Kω

+ K ω˜ IK



KI

(P)

− m K r˜ PS K r˜ TPS

+ K r˜ PS m K a P + m K r˜ PS K ω˙˜ IK K r PS + m K r˜ PS

K



Kω

(ω˜ ω˜ )IK

K r PS

= K m (P)

111

(2.76)

und beachten u. a. ω˜ r = r˜ T ω , dann finden wir zunächst KI

(P)

˙ Kω

+ K ω˜ IK K I (P) K ω + m K r˜ PS K aP + m ( K r˜ PS K ω˜ IK − K ω˜ IK K r˜ PS ) K r˜ TPS K ω = K m (P) .

(2.77)

Der letzte Term auf der linken Seite verschwindet. Um dies zu erkennen, schreiben wir ihn um (vgl. Entwicklungsätze für Kreuzprodukte) ( K r˜ PS K ω˜ IK − K ω˜ IK K r˜ PS ) K r˜ TPS K ω = −K r˜ PS K ω K r˜ PS K ω = 0 ;

dies ist das Kreuzprodukt des Vektors K r˜ PS K ω mit sich selbst. Damit lautet der Drallsatz für einen beliebigen Bezugspunkt P im körperfesten (K)-System KI

2.4

(P)

˙ Kω

+ K ω˜ IK K I (P) K ω + m K r˜ PS K a P = K m (P) .

(2.78)

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, zugrunde. 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 Ausdrü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¨ + f j (qq, 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 )

+ K ω˜ 1IK K I (P1 ) K ω 1 = K m (P1 )

(2.80)

mit dem Trägheitstensor nach (2.75) bezogen auf P1   (S ) (S ) (S ) (P1 ) = diag K Ixx 1 , K Iyy 1 , K Izz 1 + m1 K r˜ P1 S1 K r˜ TP1 S1 , KI

(2.81)

KI

˙1 Kω

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)

und entsprechen somit (2.53), (2.54). Der Tildeoperator K ω˜ 1IK folgt damit nach (2.20), womit der zweite Term auf der linken Seite in (2.80) verschwindet. Es bleibt die bekannte Bewegungsgleichung eines Stabpendels mit einem festen Drehpunkt. Letztend-

2.4 Newton-Euler-Methode

lich ist noch das Moment bezüglich P1 zu bilden: ⎡ Km

(P1 )

(P1 )

= Kme

(P1 )

+ Kmr

= K r˜ P1 S1 T α1

⎤ ⎡ ⎤ 0 fx ⎣ 0 ⎦ + K r˜ P Q T α ⎣ fy ⎦ (2.84) 1 1 1 fz m1 g

mit K r P1 Q1 = 2 K r P1 S1 und der Drehmatrix T α1 nach (2.12) mit α → α1 . Die Teilergebnisse passen wir an (2.79) an. Dazu beachten wir, dass in mechanischen Systemen die Beschleunigung q¨ stets linear auftritt, so dass sich die Teil-Massenmatrix M 1 mit (2.80) zu M 1 = K I (P1 )

∂ K ω˙ 1 = K I (P1 ) J R1 , ∂ q¨

mit

∂ Kω 1 ! ∂ K ω˙ 1 = = J R1 ∂ q¨ ∂ q˙

(2.85)

und die restlichen Terme aus (2.84) zu (P1 )

f 1 (α1 ) = − K me

,

(P1 )

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 % K_om_p1=[alpha_pp1; 0; 0]; % K_r_P1S1 = [0; 0; l1/2]; % K_r_P1Q1 = [0; 0; l1]; T_a1=subs(T_a2,alpha_2,alpha_1); % K_f_r=T_a1*[fx; fy; fz]; % K_f_e=T_a1*[0; 0; m1*g]; % K_m_P1_r=tilde_op(K_r_P1Q1)*K_f_r; % K_m_P1_e=tilde_op(K_r_P1S1)*K_f_e; % %---- 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); % f_1=-K_m_P1_e; % s_1=K_m_P1_r; %

symbolische Größen Winkel-Beschl. (2.83) Ortsvektoren (2.82) Drehmatrix T_a2 Zwangskräfte eingeprägte Kr. Zwangsmoment eingepr. Mom.

bekannt aus (2.84) aus (2.84) aus (2.84) aus (2.84)

Teil-Massenmatrix (2.85) Vektorfunktion (2.86) 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¨ ) = 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

113

114

2 Modellbildung

sich zu: If

(S2 )

=

(S2 ) Ife

+

(S2 ) Ifr

⎤ ⎡ ⎤ fx 0 = ⎣ 0 ⎦ − ⎣ fy ⎦ . fz m2 g ⎡

(2.88)

Damit erhalten wir die Elemente der Teil-Bewegungsgleichung (2.79) der Translation M 2 = m2

∂ I a S2 (S ) = m2 J TS2 , f 2 (qq, q˙ ) = m2 (I a S2 − J TS2 q¨ ), s 2 ( fx , fy , fz ) =I f r 2 . ∂ q¨

MATLAB Code: (aus kin_NE.m, Kinetik-Teil), Fortsetzung syms m2 I_xx2 I_yy2 I_zz2 %---- Impulssatz I_r_S2=I_r_P2+[0; 0; l2/2]; J_T_S2=jacobian(I_r_S2,q); I_a_Se=simple(simple(J_T_S2*q_pp+... jacobian(J_T_S2*q_p,q)*q_p)); I_f_r2=-[fx; fy; fz]; I_f_e2=[0; 0; m2*g]; % Elemente der Teil-Bewegungsgl. 2 M_2=m2*jacobian(I_a_S2,q_pp); f_2=simple(simple(m2*I_a_S2-M_2*q_pp))-I_f_e2; s_2=I_f_r2

% % % % % %

Ortsvekt., Kinematik JAC.-Matr. d. Transl. Beschl. bez. S2 vgl. (2.52) Zwangskraefte (2.88) Gewichtskraefte (2.88)

% Massen-Matrix % Vektorfunkt. % rechte Seite

Drallsatz: Mit Bezugspunkt P2 gilt (2.78) in der Form KI

(P2 )

˙2 Kω

+ K ω˜ 2 IK K I (P2 ) K ω 2 + m2 K r˜ P2 S2 K a P2 = K m (P2 ) .

(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 αT2 T βT2 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 ) = K r˜ P2 S2 T KI ⎣ 0 ⎦ , = 0 → s3 = 0 . (2.90) Kmr Kme m2 g MATLAB Code: (aus kin_NE.m [52], Kinetik-Teil), Fortsetzung

T_KI=T_IK.’; K_om2=T_KI*I_om2; K_om2_p=T_KI*I_om2_p; K_a_P2=T_KI*I_a_P2; K_I_P2=diag([I_xx2, I_yy2, I_zz2]) + ...

% % % % %

Drehmatrix, Kinematik Winkelgeschw. (K) Winkelbeschl. (K) Absolutbeschl. (K) Traegheitstensor

2.4 Newton-Euler-Methode

115

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 Winkelgröß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) J R1 =

∂ I v P2 ∂ Kω 1 ∂ Kω 2 ! ; J T2 = J TP2 = ; J R2 = ∂ q˙ ∂ q˙ ∂ q˙

(2.92)

die JACOBI-Matrizen der Rotation (JJ R ) und der Translation (JJ T ) bedeuten; eine diesbezü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 + f (qq, q˙ ) = 0

(2.93)

mit M = J TR1 M 1 + J TTP M 2 + J TR2 M 3 ; 2

f = J TR1 f 1 + J TTP f 2 + J TR2 f 3 . 2

(2.94)

MATLAB Code: (aus kin_NE.m, Kinetik-Teil), Fortsetzung %---- 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 Kraftbeziehungen. 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˙ – sie erfüllen die holonomen Zwangsbedingungen – bekannt ist. Die zeitliche Ableitung des Impulses p˙ bzw. des Dralls 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˙ i = mi r¨ Pi + mi (ω˙˜ i + ω˜ iω˜ i )rr iPi Si

(2.95)

(P ) (P ) (P ) L˙ i i = mi r˜ Pi Si r¨ Pi + I i i ω˙ i + ω˜ i I i i ω i ,

wahlweise in der Basis (I) oder (K). Führen wir die schon benutzten JACOBI-Matrizen J Ti =

∂ r iPi

=

∂qq

∂ r˙ iPi ∂ q˙

,

J Ri =

ωi ∂ω ∂ ω˙ i = ∂ q¨ ∂ q˙

(2.96)

ein, dann erhalten wir die kompakte Form der N EWTON -E ULER-Gleichung: N

∑ i=1

  T  J Ti ( p˙ i − f ei ) + J TRi L˙ i − mei = 0,

(2.97)

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˙ i (S ) L˙ i i

= mi r¨ Si (Si )

= Ii

(2.98)

(S ) ω˙ i + ω˜ i I i 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        fe 0 M1 0 z¨1 T J − =0 (2.99) + z˜2 M 2 z 2 z˙2 me 0 M2 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 ; M 1 = diag (m1E 3 , m2E 3 , · · · , mN E 3 ) ;

M 1 ∈ R3N,3N , E 3 ∈ R3,3

3N,3N

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

J ∈ R3N, f ,

,

(2.100) (2.101) (2.102) (2.103) (2.104)

2.4 Newton-Euler-Methode

z˜2 = diag (ω˜ 1 , ω˜ 2 , · · · , ω˜ N ) ; z˜2 ∈ R3N,3N , T  f e = f Te1 , f Te2 , · · · , f TeN ; f e ∈ R3N , T  m e = m Te1 , m Te2 , · · · , m TeN ; m e ∈ R3N .

117

(2.105) (2.106) (2.107)

Die zeitliche Ableitung z˙1 von (2.103) lässt sich in der Form z˙1 =

∂zz1 q˙ = J T q˙ ∂qq

→

∂ z˙1 ∂zz1 = , ∂ q˙ ∂qq

schreiben, so dass z˙1 = JT q˙

und

ω = JR q˙

und

z¨1 = JT q¨ +J˙T q˙ , ω˙ = JR q¨ +J˙R q˙ .

Setzen wir dies in (2.99) ein, so folgt     fe 0 T T ⋆ T ⋆˙ T J M J q¨ + J M J q˙ + J =0 −J z˜2 (qq, q˙ ) M 2 z 2 (qq, q˙ ) me

(2.108)

(2.109)

M 1 , M 2 ) aus (2.99) und der regulären Massenmatrix mit der Blockdiagonalmatrix M ⋆ = diag(M 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ührte Vektor q der verallgemeinerten Koordinaten gilt weiterhin. Darüber hinaus können wir davon ausgehen, dass alle kinematischen Größen aus den bisherigen Betrachtungen bekannt sind. Damit sind, ausgehend von den JACOBI -Matrizen J Ti , J Ri , die angepassten 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]); % HauptK_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 (generalisierte Koordinaten) liefert die L AGRANGEsche Gleichung 2. Art mit den Definitionen (2.3) nach Abschn. 2.1       ∂T T ∂T T ∂V T d − + = Q nk (2.110) d t ∂ 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 =

  T T J f + J m e e ∑ Ti nki Ri nki

(2.111)

i=1

menk , die mit den z. B. auf den Bezugspunkt P bezogenen eingeprägten Kräften/Momenten f enki /m 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˙ . 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˙ . Dadurch erhalten wir ∂ ∂ q˙



∂T ∂ q˙

      T   ∂ ∂T T ∂V T ∂ ∂T T ∂T T q¨ + q˙ − + + = Qnk ∂qq ∂ q˙ ∂qq ∂qq ∂t ∂ q˙

(2.112)

2.5 Lagrange’sche Gleichung 2. Art

119

und mit den Abkürzungen M (qq, t) =

∂ ∂ q˙



∂T ∂ q˙

  T       ∂T T ∂ ∂V T ∂T T ∂T T ∂ q˙ − , k (qq, q˙ , t) = , p (qq, t) = + ∂qq ∂ q˙ ∂qq ∂t ∂ q˙ ∂qq

die Bewegungsgleichung in der Form M (qq, t)¨q + k (qq, q˙ , t) + p (qq, t) = Q nk (qq, q˙ , t) .

(2.113)

Legen wir wieder ein System aus N starren Körpern zugrunde, dann wird die kinetische Energie 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

T = ∑ Ti = i=1

 1 N  T T (Si ) m ω ω v v + I i . ∑ i Si Si i i 2 i=1

(2.114)

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 konstant) 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 Verschiebungsanteil im Trägheitstensor z. B. nach (2.75), so erhalten wir die kinetische Energie (2.114) für den beliebigen Bezugspunkt Pi N

∑

T =

i=1



 1 1 (P ) miv TPi v Pi + miv TPi ω˜ ir Pi Si + ω Ti I i i ω i . 2 2

(2.115)

Hierin wird deutlich, dass sich der Energieausdruck aus einem Translations-, einem Rotationsund 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 Steifigkeitsmatrix, dann können wir schreiben: VF =

1 N ∑ ΔxxTi K i Δxxi , 2 i=1

Δxxi = Δxxi (qq) .

Führen wir noch die JACOBI-Matrix JKi =

∂ Δxxi (qq) ∂qq

(2.117)

120

2 Modellbildung

ein, so gilt VF =

N

1 T q 2

 ! 1  T JKi K i JKi q = q TK q , 2 i=1

∑

KT = K .

(2.118)

Das Potential des Gesamtsystems setzt sich aus der Summe der Einzelpotentiale zusammen. Die zugehörigen Kräfte/Momente Q k bilden sich zu Qk = −



∂V ∂qq

T

=−



∂VG ∂qq

T

−



∂VF ∂qq

T

N

= − ∑ mi JTTi g − K q .

(2.119)

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 Geschwindigkeiten v = v (qq, q˙ ) sowie ω = ω (qq, 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˙ ) = JTi q˙ ,

ω i (qq, q˙ ) = JRi q˙

(2.120)

für die jeweils gewählte Basis (I) oder (K). Dementsprechend sind natürlich JTi , JRi zu bilden: (I) : JTi =

∂ I v Si ∂ I r Si = ∂ q˙ ∂qq

bzw. (K) : JTi =

∂ K v Si ∂ K r Si = ∂ q˙ ∂qq

(2.121)

ω i / ∂ q˙ i . 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 T =

1 T q˙ M q˙ 2

(2.122)

mit der System-Massenmatrix N

M =

∑ i=1



(Si )

mi JTTi JTi + JRTi I i

JRi



(2.123)

unter Berücksichtigung der gewählten Basis. Mit (2.122) können wir (2.110) unmittelbar auswerten. Wir erhalten zunächst     ∂V T 1 T ∂ d M (qq))˙q − q˙ M (qq)˙q + = Q nk (qq, q˙ , t) . (2.124) M (qq)¨q + (M dt ∂qq 2 ∂qq Die beiden mittleren Terme auf der linken Seite, die Zentrifugal- und Coriolis-Anteile, formen wir noch um ∂ 1 ∂ Mq˙ ) q˙ − Mq˙ )T q˙ (M (M ∂qq 2 ∂qq   1 T ∂ JM = J M q˙ ) . J (M = M − M q˙ , 2 ∂qq

f ⋆ (qq, q˙ ) =

(2.125)

2.5 Lagrange’sche Gleichung 2. Art

121

Die Bewegungsgleichung hat damit wieder die Struktur M (qq)¨q + f (qq, q˙ ) = Q nk (qq, q˙ , t),

f (qq, q˙ ) = f ⋆ (qq, q˙ ) +



∂V ∂qq

T

(2.126)

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 Gleichungen 2. Art für die praktische Aufstellung von Bewegungsgleichungen weniger von Bedeutung. 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 weiter 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) aufzubauen. Zur Erstellung der Vektorfunktion f ⋆ der Zentrifugal- und Coriolis-Anteile nach (2.125) können wir alternativ die JACOBI-Matrix J M direkt JM =

∂ Mq˙ ) (M ∂qq

(2.127)

oder indirekt über die JACOBI-Matrizen bezüglich der Spalten von M 3

JM =

∂

M (i, :)q˙i ) ∑ ∂qq (M

(2.128)

i=1

mit der MATLAB-Schreibweise der i-ten Spalte M (i, :) von M und der i-ten Komponente q˙i aus 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 Bewegungsgleichung ist unten wiedergegeben. Die dort nicht erklärten Beziehungen entsprechen denen der vorangegangenen Codes zur Kinematik sowie zur Erstellung der Bewegungsgleichungen 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); %---- JACOBI-Matrizen der Rotation 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 kleine 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 (t) f E (t) := F 0 (t) + ΔF

lässt sich die ursprüngliche Bewegungsgleichung (2.6) bezüglich der kleinen Größen |yy(t)| 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 x h = v eλt

T  (mechanisches Modell: v = v˜ T , λ v˜ T ).

(3.12)

Neben dem hier verwendeten geschwindigkeitsproportionalen Dämpfungsansatz gibt es Modelle, z. B. der äußeren und inneren Dämpfung oder Strukturdämpfung, die durch Differenzialgleichungen ungerader Ordnung beschrieben werden. Das einfachste Modell besteht aus einer Hintereinanderschaltung eines Federelements und eines geschwindigkeitsproportionalen Dämpferelements (M AXWELL -Modell, vgl. Beispiel 5.1 und Abschn. 8.6). Darüber hinaus sind mechanische 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 Eigenvektoren 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 Systemen, die sich durch ein System von Differenzialgleichungen 2. Ordnung beschreiben lassen, unterscheiden. Die Koordinaten x repräsentieren den Zustandsraum, die von y den Konfigurationsraum. 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 Bewegungsgleichung, ein Eigenwertproblem (genauer Eigenwert-Eigenvektorproblem). Da wir dieses numerisch 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 Bv , Av = λB

Av = λvv

(3.13)

mit dem Eigenwert λ und dem (Rechts-) Eigenvektor v unterschieden, wobei wir in dieser allgemeinen Betrachtung die in MATLAB üblichen Bezeichnungen zunächst beibehalten. Gleichungen (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 Faktor 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 symmetrischen oder unsymmetrischen quadratischen Matrix A durch Umformungen – direkte Methode – ermittelt werden, berechnet eigs alle oder wahlweise nur einige iterativ mit vorgegebenen Spezifikationen. 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 werden 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]. BT = B ) und positiv Liegt ein allgemeines Eigenwertproblem vor, dann muss B symmetrisch (B B > 0 ) sein, weil in eigs zunächst ein spezielles Eigenwertproblem mittels C HOLESKYdefinit (B Zerlegung formuliert wird. Tabelle 3.1 zeigt typische MATLAB-Aufrufe zur Eigenwert- und EiTabelle 3.1: Typische Function-Aufrufe für eig und eigs d = eig(A) [V,D] = eig(A) [V,D] = eig(A,B) d = eigs(A) d = eigs(A,B,k,sigma,opts)

[V,D ,flag  ] = eigs(A,. . .)

bestimmt den Vektor d aller Eigenwerte, direkte Methode bestimmt die Matrizen der Eigenvektoren V und der Eigenwerte D (Diagonalmatrix); spezielles Eigenwertpr. (3.13)2 allgemeines Eigenwertproblem (3.13)1 bestimmt iterativ den Vektor d der k=6 größten Eigenwerte 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. bestimmt die Matrizen der Eigenvektoren V und der Eigenwerte D (Diagonalmatrix) Konvergenzinformation: flag = 0 Konvergenz, sonst keine

136

3 Lineare Schwingungsmodelle

genvektorberechnung. Die zugehörigen Online-Hilfen geben weitere Hinweise und Möglichkeiten, 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 Eigenwertprobleme 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, diskutiert. 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 LevitronSpielzeug-Kreisels in Abschn. 8.7 wird die Problematik angewendet bzw. vertieft. Zusätzliche Informationen 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 gyroskopischer 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¨ + 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 −k12 0 0 k01 + k12 k12 + k23 −k23 ⎦ M = ⎣ 0 m2 0 ⎦ , (3.15) K = ⎣ −k12 0 −k23 k23 + k03 0 0 m3 ergibt (3.14) mit M > 0 , K > 0 ; M, K ∈ R3,3 .

Bild 3.1: Schwingerkette

3.2 Eigenschwingungen und freie Schwingungen

137

Tabelle 3.2: Systemparameter Parameter m1 m2 m3 k01 k12 k23 k03

symmetrisch 2 5 2 1000 750 750 1000

unsymmetrisch 2 7 5 1000 2000 2500 700

Einheit kg kg kg N/m N/m N/m N/m

Das Eigenwertproblem und Stabilitätsaussagen: Die Eigenschwingungen genügen (3.11), also y = v˜ eλt ; λ Eigenwert; v˜ Eigenvektor,

(3.16)

so dass das allgemeine Eigenwertproblem −λ 2M v˜ = K v˜

(3.17)

folgt. Einerseits kann v˜ nur bis auf einen beliebigen Faktor bestimmt werden, andererseits ist nur dann 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 Koeffizientenmatrix (λ 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˜ 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˜ TM v˜ + v˜ TK v˜ = 0,

(3.19)

wobei v˜ TM v˜ stets positiv reell und v˜ TK v˜ positiv oder negativ reell oder null ist. Die Eigenwerte folgen damit aus (3.19) zu λ2 = −

v˜ TK v˜ . v˜ TM v˜

(3.20)

D. h. die Struktur der Eigenwerte und damit die Stabilität von y (t) wird durch v˜ TK v˜ festgeschrieben. Wir unterscheiden:

138

3 Lineare Schwingungsmodelle

→ λ j2 < 0,

v˜ Tj K v˜ j > 0, für alle j pos. def. v˜ Tj K v˜ j = 0, v˜ Tj K v˜ j < 0,

für mindestens ein j sem. def. →

für mindestens ein j neg. def. →

λ j2 λ j2

= 0, > 0,

λ j,1,2 = ±iω j λ j,1,2 = 0

(3.21)

λ 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˜ cos ωt; ω Eigenkreisfrequenz; v˜ Eigenvektor,

(3.22)

wählen, so dass das allgemeine Eigenwertproblem ω 2M v˜ = K 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 Eigenwertproblem (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 besserer Ü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 bessere 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); [es,I] = sort(sqrt(diag(d))); v = v(:,I); vn = v/diag(max(abs(v))); ...

% Eigenwertproblem % Eigenkreisfr. in aufsteigender Folge % Eigenvektoren neu zugeordnet % 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˜ k reell: y k = v˜ k cos ωk t .

(3.24)

Hierin sind die Eigenschwingungsformen (Mode shapes) enthalten. Man skizziert von (3.24) den Anfangszustand y k (0) = v˜ k (oder von y˙ k (0)), z. B. über den Lagen von mk wie in Bild 3.2, in dem

3.2 Eigenschwingungen und freie Schwingungen

139

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 anfänglich entsprechend v˜ k 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 Eigenschwingungsformen in Bild 3.2 mit den Systemparametern nach Tabelle 3.2 erfolgt mit dem Programmsegment aus frei.m in [52]: figure(1) set(gcf,’DefaultLineLineWidth’,1) for ef=1:3 subplot(3,2,(2*ef-1)) plot(v(:,ef)) set(gca,’xtick’,[1:1:3]) axis([1,3,-1,1])

% % % % % % %

Grafik-Fenster 1 öffnen alle Linienstärken geändert Ausgabe der 3 Eigenformen Unterfenster mit 2 Spalten ef-te Eigenform v oder vn Tick-Marken, Massenposition Achsenskalierung

if ef == 1 title(’Eigenschwingungsformen’); end grid

% Bildtitel

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˜ k stellt sich als Summe aller Eigen-

140

3 Lineare Schwingungsmodelle

schwingungen dar: f

y (t) =

∑ v˜ k (sk sin ωkt + ck cos ωkt) = (V˜ s ). ∗ sin ω t + (V˜ c ). ∗ cos ω t,

(3.25)

k=1

mit   V˜ = v˜ 1 , v˜ 2 , . . . , v˜ f T  ω = ω1 , ω2 , . . . , ω f T  c = c1 , c2 , . . . , c f T  s = s1 , s2 , . . . , s f

Modalmatrix Vektor der Eigenkreisfrequenzen Vektoren der Integrationskonstanten,

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 Betrachtung. Die Lösung enthält säkulare Terme. Die Integrationskonstanten sk und ck bzw. s , c ermitteln sich mit 2 f vorgegebenen Anfangswerten y (0) = y 0 und 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˜ c ,

ω. v 0 = (V˜ s ). ∗ω

(3.26)

Die Zeitverläufe der freien Schwingungen folgen direkt aus (3.25). Für eine MATLAB-Formulierung gehen wir von dem Zeilenvektor t T der diskreten Zeitpunkte tk , k = 1,2, . . . aus und schreiben ω t T ) + diag(cc) cos (ω ω t T )) y (tt T ) = V˜ (diag(ss) sin (ω

(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); % Integrationskonstanten c = v\y0; s = es.\(v\v0); te = 4*pi/es(1); t = linspace(0,te); y= v*(diag(s)*sin(es*t)+diag(c)*cos (es*t)); figure(2) set(gcf,’DefaultLineLineWidth’,1) subplot(211) plot(t,y(1,:),t,y(2,:),’-’,... t,y(3,:),’o’,’MarkerSize’,2) L=axis; xlim([L(1) te]) title(’Freie Schwingungen ... für spezielle Anfangswerte’) xlabel(’Zeit t [s]’); ylabel (’y1, y2, y3’) legend(’y1’,’y2’,’y3’,-1) grid

% Anfangswerte % % % % % %

cos-, sin-Anteil (3.26) Zeitendpunkt, z. B. Zeitvektor, 100 Werte Schwingung nach (3.27) grafische Darstellung Linienstärke geändert

% Achsenskalierung % Bildüberschrift % Achs-Beschriftung % Linienkennung

3.2 Eigenschwingungen und freie Schwingungen

141

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˜ 2 ,

y˙ (0) = v 0 = 0 , α reell,

so dass sich aus (3.26) c = αV˜

−1

v˜ 2 = α[0 1 0]T

und s = 0

ergeben und schließlich aus (3.25) y (t) = α v˜ 2 cos ω2t. Im unteren Bild 3.3 unten sind die freien Schwingungen für allgemeinere Anfangswerte dargestellt, 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 KreiseleinG(Ω )) 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].

142

3 Lineare Schwingungsmodelle

Die Struktur der Eigenwerte: Ausgehend von der Bewegungsgleichung GT M = M T > 0, K = K T ; G = −G

M y¨ + Gy˙ + K y = 0 ;

(3.28)

folgt mit y = v˜ eλt

(3.29)

das Eigenwertproblem G + K )˜v = 0 (λ 2M + λG

(3.30)

als Matrizenpolynom 2-ter Ordnung und aus der Determinate der Koeffizientenmatrix die charakteristische Gleichung G + K| = 0 . |λ 2M + λG

(3.31)

G + K )T zwar unterschiedliche EigenvektoDa das zugehörige adjungierte Problem (λ 2M + λG ren aber gleiche Eigenwerte besitzt, muss gelten G + K | = |λ 2M − λG G + K | = 0, |λ 2M + λG

(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˜ R − i v˜ I , i = −1 der zu v˜ = v˜ R + i v˜ I konjugiert komplexe Eigenvektor, dann erhalten wir aus (3.30) durch Linksmultiplikation mit v˜ ⋆T T

T

T

λ 2v˜ ⋆ M v˜ + λ v˜ ⋆ Gv˜ + v˜ ⋆ K v˜ = 0, woraus wir den Eigenwert  T

λ=

−˜v ⋆ Gv˜ ±

(3.33)

 2   T T T v˜ ⋆ Gv˜ − 4 v˜ ⋆ M v˜ v˜ ⋆ K v˜ T

2˜v ⋆ M v˜

(3.34)

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  T T v˜ ⋆ M v˜ = v˜ R − i v˜ I M v˜ R + i v˜ I (3.35) T T positiv reell = v˜ R M v˜ R + v˜ I M v˜ I ⋆T

RT

IT

v˜ K v˜ = v˜ K v˜ R + v˜ K v˜ I

⎧ ⎨ positiv reell 0 ⎩ negativ reell

(3.36)

3.2 Eigenschwingungen und freie Schwingungen

   T  T T v˜ ⋆ Gv˜ = v˜ R − i v˜ I G v˜ R + i v˜ I   T T = i v˜ R Gv˜ I − v˜ I Gv˜ R T

rein imaginär,

143

(3.37)

T

GT die Terme v˜ R Gv˜ R = 0 und v˜ I Gv˜ I = 0 verschwinden müssen. Daraus wobei wegen G = −G T folgt, dass die Eigenwerte λ in (3.34) für positiv definites K (˜v ⋆ K v˜ > 0) stets rein imaginär sind, was mit der obigen Aussage: λk , −λk Eigenwerte von (3.30) auf √ λk,k+1 = ±iωk , i = −1 führt. T

Ist K negativ definit, d. h. v˜ ⋆k K v˜ k < 0 für mindestens ein k, und der Radikand in (3.34) positiv, 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˜ ⋆T k K v˜ k = 0 gibt es Starrkörpermoden mit λk = 0 bzw. K v˜ k = 0 nach (3.30). 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   T  0 E x˙ = x oder kurz x˙ = Ax Ax, x = y T , y˙ T (3.38) −1 −1 M K −M M G −M mit der n × n-Zustandsmatrix A . Der Ansatz (3.12) liefert direkt das spezielle Eigenwertproblem E v = Av λE Av,

( für mech. Systeme nach (3.1):

v = (˜v T , λ v˜ T )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]:

144

3 Lineare Schwingungsmodelle f = length(M); A = [zeros(f) eye(f) -M\[K G]]; [v,d] = eig(A); [es,I] = sort(imag(diag(d)*i)’); es = diag(d(I,I)); ve = v(:,I); % (...*i)’ liefert konj. kompl. % konj. kompl. Paare bleiben in

% Freiheitsgrad. des Syst. % Zustandsmatrix A (3.38) % Eigenvekt. (v), Eigenwerte (d) % nur Sortierindex I wichtig % aufsteigende Vektor-Folge (ω j ) % Zuordnung der Eigenvektoren Anteil 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 +vv⋆k e−iωk t

(3.40)

und die zugehörige Eigenschwingungsform x k (0) = v k +vv⋆k = 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˙ = Ax

(3.42)

mit den vollbesetzten Matrizen oder Sparse-Matrizen     E 0 0 E B = ; A = ; BT = B > 0 K −G G 0 M −K

(3.43)

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 Formulierung 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 , k=1

wobei die Koeffizienten ck von Anfangswerten abhängen. Mit Hilfe der Modalmatrix V = [vv1 , v 2 , . . . , v n ]

(3.44)

3.2 Eigenschwingungen und freie Schwingungen

145

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 algebraische 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 Rechteckmatrix. MATLAB Code der freien Schwingungen für gegebene Anfangswerte x0, siehe auch linear_ImDrLa.m in [52]: c = v\x0; te = 8.0*pi/imag(es(1)); t = linspace(0,te); x = real(v*diag(c)*exp(diag(d)* t)); plot(t,x(1,:),’-.r’, t,x(2,:),’b’)

% % % % %

Integrationskonstanten (3.46) Endzeit, gewählt 8π/ωmin 100 diskrete Zeitpunkte freie Schwingung x (tt T ) (3.47) 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 Dimension. 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: V −1x 0 = V eΛt V −1 x 0 = Φ (t) x 0 , x (t) = V diag(eλ j t )V

Λ = diag(eλ j t ),

(3.50)

mit der Fundamentalmatrix [9] −1 V −1 = e V ΛV t = e At , Φ (t) = V diag(eλ j t )V

MATLAB: expm(A*t).

(3.51)

146

3 Lineare Schwingungsmodelle

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); for ii=1:length(t) x(:,ii) = expm(A*t(ii))*x0; end

% Zeitvektor % ii-ter Zeitschritt % Lösung nach (3.50)

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 Schwingungsmodell aus Abschn. 2.7 bezüglich der homogenen Gleichung von (2.166) ist ein MDGKSystem. 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. Gelegentlich setzt man die Dämpfungsmatrix proportional zur Steifigkeits- oder/und Massenmatrix an: M + βK K, D = αM

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 grenzstabil 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

entscheidet K = K T unabhängig von G über die Stabilität.

(3.53)

Ist K = K T > 0 , dann ist das System unabhängig von G asymptotisch stabil. Ein statisch instabiles 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

3.2 Eigenschwingungen und freie Schwingungen

147

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 nachweisen; vgl. [9]. Die Schwingungen und Dämpfungsmaße: Die komplexe Formulierung der freien Schwingungen 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 Eigenschwingungen 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 , bzw. für |δ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 Differenzialgleichung festgeschrieben. Ist das System asymptotisch stabil, dann klingen im stationären Betrieb die anfänglich angestoßenen Eigenbewegungen ab und es bleiben die erzwungenen Schwingungen. 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¨ + Py˙ + Qy = h (t),

G, Q = K +N N, P = D +G

M , P , Q konstant.

(3.56)

Bezüglich der rechten Seite unterscheidet man z. B. Krafterregung, Fußpunkterregung und Unwuchterregung. 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 c s h (t) = h 0 + ∑k (hˆ k sin Ωk t + hˆ k 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, quasiperiodischer und periodischer Anregung stets aus Teillösungen harmonischer Erregung zusammengesetzt werden, so dass wir zur Erläuterung der Vorgehensweise nur mit dem harmonischen Erregervektor s c Φ) h (t) = h 0 + hˆ sin Ωt + hˆ cos Ωt = h 0 + hˆ . ∗ cos (eeΩt −Φ

(3.57)

zu arbeiten brauchen, wobei Φ = (Φ1 , . . . , Φ f )T der Nullphasenwinkel-Vektor (hier: Nacheilwinkel), e = (1, 1, . . . )T der Eins-Vektor sowie .∗ eine elementweise Multiplikation, eine Punktoperation ist. Die Lösungsanteile y pk von (3.56) mit (3.57), d. h. infolge konstanter h 0 und harmonischer Terme yp =

∑ k=1,2

y pk

(3.58)

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 Masse 2 Steifigkeit Steifigkeit Dämpfung Dämpfung Erdbeschleunigung ErregerAmplituden

m1 m2 k01 k12 d01 d12 g s hˆ ˆh c

= = = = = = = = =

100 kg 5 kg 105 N/m 104 N/m 10 Ns/m 1 Ns/m 9,83 m/s2 [20, 0]T N [50, 0]T N

Bild 3.4: Beispiel: Zwei-Massen-Schwingerkette

Alle vorgestellten Methoden werden auf die Zwei-Massen-Schwingerkette aus Bild 3.4 angewendet 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 g m1 0 k01 −k12 d01 −d12 0 ; h = , M = ; K = ; D = −k12 k12 −d12 d12 m2 g 0 m2 den Erregeramplituden hˆ 3.3.1

s,c

und Parametern aus der Tabelle neben Bild 3.4.

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¨ + Py˙ + 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.

150

3 Lineare Schwingungsmodelle

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¨ + Py˙ + Qy = hˆ sin Ωt + hˆ cos Ωt .

(3.62)

Der Lösungsansatz y (t) = yˆ s sin Ωt + yˆ c cos Ωt

(3.63)

kann entsprechend (3.57) auch als cos- (oder sin-) Funktion mit dem Phasenwinkel-Vektor Φ Φ ), y (t) = 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 Phasenvoreilbzw Phasennacheilwinkel steht. Aus (3.64) folgt mit dem Additionstheorem y (t) = yˆ . ∗ (cos Ωt cos Φ ∓ sin Ωt sin Φ ) . Ein Vergleich mit (3.63) ergibt dann yˆ c = yˆ . ∗ cos Φ ; yˆ s = ∓ˆy . ∗ sin Φ und schließlich folgt der Amplituden-Vektor   yˆ = yˆ s . ∗ yˆ s + yˆ c . ∗ yˆ c = yˆ s .ˆ 2 + yˆ c .ˆ 2

(3.65)

sowie der Vektor der Nullphasenwinkel ( (−) Voreil-, (+) Nacheilwinkel ) Φ = arctan(∓ yˆ s ./ˆy c ).

(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 #  P yˆ Q − Ω 2M −ΩP hˆ (3.67) = ˆc c 2 P yˆ ΩP Q −Ω M h oder kurz H (Ω )¯y = h¯ ,

 T y¯ = (ˆy s )T , (ˆy c )T ,

T  s c h¯ = (hˆ )T , (hˆ )T

(3.68)

3.3 Erzwungene Schwingungen

151

und schließlich H (Ω ))−1 h¯ = F (Ω )h¯ , 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ˆ nach (3.65) sowie den Phasenwinkel Φ nach (3.66) werten wir in Abhängigkeit von Ω aus und erhalten 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 sinyd_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 Interesse, dann ist es zweckmäßig (3.63) auszuwerten. Mit t T = (t1 , t2 , . . . , 2π/Ω ) geht (3.63) in die Matrizengleichung y (tt T ) = yˆ s sin Ωtt T + yˆ c cos Ωtt T ,

Ω = konst

(3.70)

über, was im folgenden Programmsegment ausgewertet ist. JJ=....; Omt=Om(JJ); t=linspace(0,2*pi/Omt,200) yt=yd_s(:,JJ)*sin(Omt*t)... +yd_c(:,JJ)*cos(Omt*t); plot_erzw(Om,yd,phi,t,yt,2,titel)

% % % % %

JJ-te Komp. aus Om, Ω = konst Zeitvektor, 200 Werte Zeitverläufe (3.70) über eine Periode T für Omt=Om(JJ) 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überhö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

152

3 Lineare Schwingungsmodelle

Bild 3.5: Ergebnisse zum gedämpften System mit harmonischer Anregung

mit zwei rechten Seiten; nu = 2  s c   Q − Ω 2M [ˆy s , yˆ c ] = hˆ , hˆ

(3.71)

oder kurz   s,c Q − Ω 2M yˆ s,c = hˆ ,

(3.72)

was den Rechenaufwand gegenüber (3.67) reduziert: Ordnung ist halbiert, Umformung der KoQ − Ω 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 II=length(Om); y_sc=zeros(f,nu,II); for ii=1:II H0=Q-Om(ii)ˆ2*M; y_sc(:,:,ii)=H0 \[h_s,h_c]; end

% % % % % %

vgl. erzw.m Dimension von Om, Ω 3D-Null-Array, II Seiten Lösung von Seite ii Koeffizienten-Matrix (3.72) Lösung von (3.72), 2 rechte S.

3.3 Erzwungene Schwingungen yd=sqrt(y_sc(:,1,1:II).ˆ2+... y_sc(:,2,1:II).ˆ2); phi=atan2(-y_sc(:,1,1:II),... y_sc(:,2,1:II)); t=linspace(0,2*pi/Omt,200); yt=y_sc(:,1,JJ)*sin(Omt*t)... +y_sc(:,2,JJ)*cos(Omt*t); plot_erzw(Om,yd,phi,t,yt,1,titel)

3.3.2.2

153

% Amplitude yˆ (3.65) % Phase in cos(Om*t+phi) (3.66) % % % %

Zeitv., Omt=Om(JJ), Ω = konst Zeitverl. (3.70), JJ gewählt, über eine Periode T = 2π/Ω grafische Auswertung

Komplexe Anregungsfunktion

Eine weitere Formulierung basiert auf komplexen Anregungsfunktionen. Wir ersetzen hierzu die Zeitfunktionen der Anregungsterme in (3.62) durch cos Ωt =

 1  iΩt e + e−iΩt , 2

sin Ωt =

und erhalten damit für (3.62)

 1  iΩt i e − e−iΩt , 2

i=

√ −1

⋆ M y¨ + Py˙ + Qy = hˆ eiΩt +hˆ e−iΩt

(3.73)

mit den komplexen Anregungsamplitudenvektoren  1 ˆc s hˆ = h − i hˆ ; 2

⋆ hˆ konj. kompl. zu hˆ .

(3.74)

Die Lösung von (3.73) y = ξ +ξξ ⋆ ermitteln wir mit dem ersten Term der rechten Seite aus M ξ¨ + Pξ˙ + Qξ = 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 P +Q Q hˆ = F (iΩ )hˆ , ξˆ = −Ω 2M + iΩP

(3.77)

wobei F (iΩ ) die komplexe Frequenzgang-Matrix ist. Für den zweiten Lösungsanteil gilt ⋆ ξ ⋆ = ξˆ e−iΩt

⋆ ⋆ → ξˆ = F ⋆ (−iΩ )hˆ ,

(3.78)

⋆ so dass (3.75) mit der rechten Seite hˆ e−iΩt erfüllt ist. Die Lösung von (3.73) genügt dann ⋆ y (t) = ξˆ eiΩt +ξˆ e−iΩt ;

= 2|ξˆ |. ∗ cos (Ωeet + arg (ξˆ )),

⋆ ξˆ

konj. kompl. zu ξˆ (3.79) MATLAB-orientiert

154

3 Lineare Schwingungsmodelle

oder y (t) = 2Re(ξˆ ) cos Ωt −2Im(ξˆ ) sin Ωt = yˆ c cos Ωt + yˆ s sin Ωt.       yˆ c

(3.80)

yˆ s

Geometrisch stellt (3.79) zwei Drehzeiger dar, die gegenläufig mit Ω umlaufen. Die Resultierende 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); hd=0.5*(h_c-i*h_s); for ii=1:II H=Q-Om(ii)ˆ2*M +i*Om(ii)*P; xi_d(:,ii)=H\hd; end yd=2.0*abs(xi_d); phi=angle(xi_d); JJ=......; Omt=Om(JJ); yt=xi_d(:,JJ)*exp(i*Omt*t); yt=real(yt+conj(yt)); plot_erzw(Om,yd,phi,t,yt,3,titel)

3.3.2.3

% 2D-Zero-Array, II Om-Werte % Anregungsvektor hˆ , (3.74) % H=inv(F) aus (3.77) % Amplitude ξˆ nach (3.77) % % % % %

Amplitude yˆ , (3.79) Phase cos(Om*t+Phi) (3.79) JJ-te Komponente Teillösung (3.76) Zeitv., eine Periode (3.79)

Komplexe Bewegungsgleichung

Eine Variante zur Formulierung in Abschn. 3.3.2.2: Wir fügen zu (3.62) formal eine zweite Gleichung hinzu s c hˆ sin Ωt + hˆ cos Ωt s c M x¨ + Px˙ + Qx = −hˆ cos Ωt + hˆ sin Ωt,

M y¨ + Py˙ + Qy =

(3.81)

und bilden für ζ = y + i x die komplexe Bewegungsgleichung c s M ζ¨ + Pζ˙ + Qζ = (hˆ − i hˆ ) eiΩt .

(3.82)

3.3 Erzwungene Schwingungen

155

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 P +Q Q hˆ − ihˆ ζˆ = −Ω 2M + iΩP

(3.83)

und hiermit die Lösung

y (t) = Re(ζˆ eiΩt ) = |ζˆ |. ∗ cos (Ωeet + arg (ζˆ )) = Re(ζˆ ) cos Ωt − Im(ζˆ ) sin Ωt.

3.3.2.4

(3.84)

Lösungsverhalten

Alle vorgestellten Methoden zur Bestimmung der Schwingungsamplituden führen auf ein algebraisches inhomogenes Gleichungssystem der Struktur H (Ω )ˆu = fˆ und damit auf uˆ = H −1 (Ω ) fˆ = F (Ω ) fˆ

(3.85)

mit der Frequenzgangmatrix F (Ω ) =

H (Ω )) H (Ω )) adj(H adj(H = H (Ω )) det(H N

(3.86)

aus der Adjungierten und der Determinanten von H . Demnach folgt für eine Lösungskomponente aus (3.85) uˆ j =

Zj , N

aus: uˆ =

1 1 H (Ω )) fˆ = Z , adj(H N N

womit vier Lösungstypen zu unterscheiden sind 1. 2. 3. 4.

Zj Zj Zj Zj

= =

= =

0, N = 0 0, N = 0 0, N = 0 0, N = 0

Allgemeine Lösung, Amplituden beschränkt Tilgung, einzelne Amplituden verschwinden Resonanz; uˆ j → ∞ 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. Eigenkreisfrequenz ω j und Erregerkreisfrequenz Ω stimmen überein, es liegt Resonanz vor. Dies kann nur

156

3 Lineare Schwingungsmodelle

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 Eigenschwingungen 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 entsprechend (3.73) ⋆ x˙ = Ax + b 0 + bˆ eiΩt + bˆ e−iΩt

(3.87)

zugrunde. Der Lösungsanteil infolge der konstanten Störung ergibt sich unmittelbar zu A−1b 0 . x ∞ = −A

(3.88)

Für die harmonischen Terme betrachten wir, wie in Abschn. 3.3.2.2, die verkürzte Anregung z˙ = Az + bˆ eiΩt ,

x = z + i z⋆

(3.89)

mit der komplexen Lösungsamplitude zˆ = F (iΩ ) 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 ) cos Ωt + (−2 Im(ˆz )) sin Ωt x p (t) = −A = x ∞ + xˆ c cos Ωt + xˆ s sin Ωt.

(3.91)

Die auftretenden Lösungstypen sind die aus Abschn. 3.3.2.4. Angewendet wird die Vorgehensweise 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 B eiΩt z˙ = Az +B

(3.92)

D eiΩt y = Cz +D zugrunde, mit der in der Regelungstechnik üblichen Matrizenschreibweise. Der Ansatz z = zˆ eiΩt

und damit

y = yˆ eiΩt

3.3 Erzwungene Schwingungen

157

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

(3.93)

Ausgehend von (3.82) in Zustandsform des zu bearbeitenden Problems

mit

  c s z˙ = Az + bˆ − i bˆ eiΩt , T  s s bˆ = 0 Tf ,1 , (hˆ )T ;

  T T z = ζ T , ζ˙ T  c c bˆ = 0 Tf ,1 , (hˆ )T

(3.94)

(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  c s s (3.96) oder B = bˆ , −bˆ b = bˆ − i bˆ

denkbar. Dementsprechend enthält yˆ nc ,1 und damit Dnc ,1 in (3.93) eine oder aufgrund der zwei rechten Seiten yˆ nc ,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 komplexen Eingangsmatrix lautet y = yˆ ei Ωt ,

yˆ = yˆ Re + i yˆ Im

(3.97)

bzw. mit der Schwingungsamplitude |ˆy |, dem Voreilwinkel Φ sowie der Punktoperation .∗ y = |ˆy |. ∗ ei Φ ei Ωt .

(3.98)

Die Function bode gibt |ˆy | und die Phase Φ , die Function freqresp die komplexe Amplitude yˆ aus. Die Phase berechnet sich anschließend zu Φ = arctan (ˆy Im ./ yˆ Re ) .

(3.99)

Jedem Ergebnis |ˆy |, Φ , yˆ ist in Abhängigkeit von Ω = (Ω1 , Ω2 , . . . , ΩL ) ein dreidimensionales 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 eindimensionaler 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.

158

3 Lineare Schwingungsmodelle

Zur Auswertung mit den beiden Functions werden unten die wesentlichen Programmschritte 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-SpaceModel (unten; sys) für zeitkontinuierliche Systeme zusammenzufassen, womit dann weiter gearbeitet 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 doppeltlogarithmischer Achsteilung: 20 log10 |ζˆ j (log10 (Ω ))| [dB] dargestellt. Die Grafen stimmen mit denen aus vorangegangenen Methoden überein. Diese Grafik wird nur erstellt, wenn keine Ausgabevariablen ü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 Betrachtungen sehr geeignet. Erfolgt die Erregung u. a. durch Impuls- aber auch durch Sprungfunktionen, 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: x (t) = Φ (t) x (t0 ) +

$t

t0

Φ (t − τ) b (τ) dτ,

Φ (t) = eAt .

(3.100)

3.3 Erzwungene Schwingungen

159

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 erzwungenen 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: x I (t) = Φ (t) x 0 +

$t 0

=



Φ (t − τ) b I δ (τ − tI ) dτ;

Φ (t) x0 Φ (t) (xx0 + Φ (−tI ) bI )

Φ (t) = eAt

0 ≤ t < tI , t > tI

(3.102) vgl. (3.50)

160

3 Lineare Schwingungsmodelle

• Sprungfunktion b (t) = b s s(t − ts )

(3.103)

Sprungantwort: xs (t) = Φ (t) x0 +

$t 0

=



Φ (t − τ) bs s(τ − ts ) dτ

Φ (t) x 0 E − Φ (t − ts )) A −1b s Φ (t)xx0 − (E

(3.104) 0 ≤ t < ts 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); for ii = 1:length(t) if t(ii) - tI 1 A DAMS -BASHFORTH-Verfahren xn+1 = xn +

h (55 fn − 59 fn−1 + 37 fn−2 − 9 fn−3 ) , 24

fn := f (tn , xn )

- explizites 4-Schrittverfahren 4. Ordnung A DAMS -M OULTON-Verfahren xn+1 = xn +

h (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

166

4 Simulation unter Simulink

Die Koeffizienten ai, j , bi , ci charakterisieren die s-Schrittmethode, sie werden in der so genannten 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 2 1 2

1 2

1

1 2

0 0

0

1

1 6

2 6

2 6

1 6

formulierbar. Es ist ein 4-Schrittverfahren der Ordnung 4 mit dem algorithmischen Aufbau Steigungswerte ki h h zur Schreibweise: tn + f (tn+ 1 , xn + k1 ), → tn+ 1 usw. 2 2 2 2 h f (tn+ 1 , xn + k2 ) 2 2 f (tn+1 , xn + hk3 ) h xn + (k1 + 2k2 + 2k3 + k4 ) Ergebnis, explizite Formel 6

k1 = f (tn , xn ) k2 = k3 = k4 = xn+1 =

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

4.2 Die Integrationsverfahren

167

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 RINCEMethode [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 5 3 10 4 5 8 9

1 5 3 40 44 45 19372 6561 9017 3168 35 384

9 40 − 56 15 − 25360 2187 − 355 33

0

32 9 64448 6561 46732 5247 500 1113

(5)

35 384

0

(4)

5179 57600

0

1 1 xn xn

− 212 729 49 176 125 192

5103 − 18656

− 2187 6784

11 84

500 1113

125 192

− 2187 6784

11 84

0

7571 16695

393 640

92097 − 339200

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 ergibt 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) übersichtlich in einem Tableau der Struktur c1 c2 c3 .. .

a11 a2,1 a3,1 .. .

a12 a2,2 a3,2 .. .

... ... ... .. .

a1,s−1 a2,s−1 a3,s−1 .. .

a1,s a2,s a3,s .. .

cs

as,1 b1

as,2 b2

... ...

as−1,s−1 bs−1

as,s bs

dar. Beispiel: Die Trapez-Regel 1 xn+1 = xn + h ( f (tn , xn ) + f (tn+1 , xn+1 )) 2

168

4 Simulation unter Simulink

kann als zweistufiges implizites RUNGE -K UTTA-Verfahren aufgefasst werden: zugehörige Tableau

k1 = f (tn , xn )

0 1

1 1 k2 = f (tn + h, xn + h( k1 + k2 )) 2 2 h xn+1 = xn + (k1 + k2 ). 2

1

0

1 2 1 2

1 2 1 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 Differenzialgleichungssystems 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 , ℓ = 1, 2, . . . , k21 Startwert. k2ℓ+1 = f tn + h, xn + h k1 + k2ℓ 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 + h f (tn , xn ) xn+1

Prädiktorschritt P ,

K xn+1

Korrektorschritt K (+ z. B. Fixpunkt-Iteration)

= xn + h

P f (tn+1 , xn+1 )

E ULER-Vorwärts-Schritt

Mehrschrittverfahren In ähnlicher Weise wie die oben angesprochenen Einschrittverfahren sind auch die Mehrschrittverfahren gekennzeichnet, wobei zusätzlich die Ordnung des Verfahrens anpassbar bzw. einstellbar 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 bereits ermittelten – zeitlich zurückliegenden Werte – Näherungen xn+s−1 , xn+s−2 , . . . , xn . Mehrschrittverfahren sind somit nicht selbststartend und arbeiten deshalb zu Integrationsbeginn u. a. mit Einschrittverfahren zusammen. Es werden explizite und implizite s-Schritt-Verfahren unterschieden, 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-Methoden werden dagegen mit Hilfe der numerischen Differenziation konstruiert. Beispiele implizi-

4.2 Die Integrationsverfahren

169

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; hierzu 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) Realteile der Eigenwerte S :=

max j |ℜ(λ j )| . min j |ℜ(λ j )|

Bei steifen Differenzialgleichungen erreicht S Werte von 106 und höher. Das Problem der Steifigkeit existiert ausgeprägt bei nichtlinearen Differenzialgleichungen 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 exakten 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  z (t) + O(zz2 ), x˙ n + z˙(t) = f (tn , x n ) + ∂xx n

woraus schließlich mit (4.3) die erste Näherung  ∂ f  z˙(t) = z (t) = J (tn , xn ) z (t) ∂xx n

170

4 Simulation unter Simulink

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äherungsLö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: S :=

max j |λ j | , 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. Tabelle 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-Methoden. 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 Genauigkeitsansprü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 Steifigkeits- 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 DAMSTyp 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 Seite 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 verwenden, 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 Differenzialgleichung 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 Anhaltspunkt 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 JACOBIMatrix 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 erin der Menü-Leiste des MATLAB Desktop nach Bild 1.1. Es öffnet sich folgt mit dem Button 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/Edit/View/Simulation/Format/Tools/Help bereitgestellt. Entsprechend sind gespeicherte Simulink-Programme mit der Endung mdl zu öffnen. Für die letzten beiden Vorgänge . Des Weiteren werden alle Hauptgruppen der Library angeexistieren die Standard-Button 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ängerversionen 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 schreiben. Zur Integration von x˙ wird ein Integrator Block, zur Abbildung der rechten Seite

172

4 Simulation unter Simulink

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 Konstante 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ßender Aktivierung des Folgeblocks bei gleichzeitig gedrückter Strg- bzw. Ctrl- Taste

Bild 4.6: Beispiel eines einfachen Block-Modells

4.3 Simulink-Grundlagen

173

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 Option Configuration Parameters; vgl. Bild 4.7. Hier existieren in Abhängigkeit der vorhandenen Toolboxen mehrere anwählbare Dialogseiten: Solver, Data Import/Export, Diagnostic 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

174

4 Simulation unter Simulink

Zeros crossing control ist die Nullstellen-Detektion spezieller Blöcke übergeordnet einoder ausschaltbar. Auf der Seite Data Import/Export nach Bild 4.7 unten wird u. a. der Datentransfer zwischen 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 Ausgangsvariablen yout , denen Outports-Blöcke – vgl. Bild 4.6 – aus der Ports & Subsystems-Bibliothek zugeordnet 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 werden. Darüber hinaus können die Zustandswerte (xFinal) zur Stopp-Zeit gespeichert werden; 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 Integrationsintervall [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üssen 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 der Menüleiste und andererseits aus der MATLAB-Umgebung, mittels Tasdem Start-Icon

4.3 Simulink-Grundlagen

175

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. AusgabeDaten 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 Zwischenwert 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 Teilstrukturen 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-

176

4 Simulation unter Simulink

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 Stellen 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 ergä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 Kontextmenü 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 aktivieren. 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 ausgefü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

4.3 Simulink-Grundlagen

177

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 Darstellung 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 Modellgruppen zu Subsystemen zusammengefasst werden. Darüber hinaus können mehrfach eingesetzte 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überliegende Eckpunkte des Subsystems anfahren → Elemente des Subsystems sind markiert.

178

4 Simulation unter Simulink

c. Button Edit → create subsystem → Subsystem ist erstellt, vgl. Bild 4.10 unten. 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 in [52]. 4.3.5.3

ein-/ausgeblendet. Experimentierfiles: SubModell_1.mdl, SubModell_2.mdl

Einbinden von Referenzmodellen (Model Referencing)

Im Gegensatz zu den Subsystemen nach Abschn. 4.3.5.2 müssen die in ein neues Modell einzubindenden Modelle, die Referenzmodelle, nicht in dieses kopiert werden. Das Referenzmodell existiert als unabhängiges, lauffähiges Modell mit sinnvollen Schnittstellen 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öffnetem 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örige 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 voneinander 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 komplett und lauffähig. Mit dem Model Block aus der Library Ports & Subsystems wird das vor Änderungen geschützte 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 Referenzmodells 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 Kontextmenü zum Model Block (rechte Maustaste) unter: ModelReference Parameters..., oder im Explorer später geändert werden.

4.3 Simulink-Grundlagen

179

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 Referenzmodells, 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 eingebunden, vgl. Seite 317. Die im Bild 4.19 modellierte Fahrbahn ist ein typisches Beispiel für ein Referenzmodell. Hiermit wird in der Beschreibung (Discription unter: Edit/Model Properties) zum SimulinkModell 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ü (öffnen 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 BeispielTabelle 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 direkt 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

180

4 Simulation unter Simulink

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 konvertiert 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 exportieren 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 Command-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 Subsystem der Fahrbahnunebenheit Bild 4.19 bzw. sim_v11s.mdl sowie sim_v12.mdl und F_Profil in [52].

4.3 Simulink-Grundlagen

181

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 (aktiv) Spalte Evaluate:

4.3.5.5

Marken und Speicher für den Signalfluss

In umfangreichen Modellen können die üblichen durchgezogenen Signalpfade zur Unübersichtlichkeit 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 weitergeleitet. 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 x˙ = 1,2x − x2 − y˙ = 1,5

2 (y˙ + y) 3

xy −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

182

4 Simulation unter Simulink

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 Parameter: 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 Hauptmodellebene, 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. Dabei 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 Subsystems 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 angeordnet 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 angeordneten 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 hervorgehoben. 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 manipulierbar. Es soll deshalb eine Möglichkeit zur Einblendung der Menü-Leiste entsprechend des

4.3 Simulink-Grundlagen

183

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 darstellen, 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 schnellen Ü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 Informationen 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 Maustaste 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 ein- und ausgeblendet werden. Die Dialog-Spalte kann mit dem Button Die Model Hierarchy Spalte zeigt die hierarchisch angeordnete Baumstruktur der SimulinkUmgebung mit den Haupt-Knoten Simulink Root, es folgen der Base Workspace (MATLAB Workspace) sowie Knoten der geöffneten Simulink-Modelle. Jeder Modell-Ast enthält den Model

184

4 Simulation unter Simulink

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 BlockInformationen 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 empfiehlt sich deshalb, unterstützt durch die Online-Hilfe zum Explorer, mit den Beispiel-Programmen 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 werden 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 werden mit der Eingabe help angezeigt: z. B. step für den Übergang zum nächsten Simulationspunkt. Wir betrachten hier etwas ausführlicher die grafische Oberfläche. Aus dem Simulink-ModellFenster unter Tools/Simulink Debugger wird die Oberfläche geöffnet. Die Hauptkomponenten 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 algebraischen Schleife aus Bild 4.2 durchführen. In Bild 4.14 ist dieses Modell sowie die DebuggerOberfläche nach einigen Schritten dargestellt. Es lassen sich Berechnungen von Break Point zu Break Point oder unter Einbezug von Zwischenschritten 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 eider Toolbar den Break Point zu setzen. Er wird unter nem Linksklick auf einen der Button 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

4.3 Simulink-Grundlagen

185

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 lassen sich diese eines angewählten Blocks anzeigen. sind möglich). Mit 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. können alle oder wesentliche Schritte der Integration, also auch Mit den Button zu Zwischenzeiten eines Integrationsintervalls (TM, Minor Time Step), angezeigt werden. Mit (step) werden alle Methoden sämtlicher Hierarchie-Ebenen angezeigt, mit (step over) in jedem Schritt die der aktuellen Hierarchie-Ebene. Alle tiefer liegenden Methoden werden natürlich

186

4 Simulation unter Simulink

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 (step blockmth) erfolgt der (im Allgemeinen an den Anfang der Simulationsschleife). Mit Sprung zum jeweils folgenden Block. Diese Schritte sind auch ohne Break Point ausführbar. Experimente mit weiteren Beispielprogrammen 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 spezifischen 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 Blattfederpakets 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 mR x¨R − kA (xA − xR ) − dA (x˙A − x˙R ) − FC sign(x˙A − x˙R ) − kR (xS − xR ) = 0.

(4.5)

Aufgrund des Reibansatzes berücksichtigen die Bewegungsgleichungen die Bereiche der Gleit-

188

4 Simulation unter Simulink

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. −1 für vrel < 0

(4.6)

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 y = Cx + Du

(4.7)

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 dA kA (x1 − x2 ) − (x3 − x4 ) mA mA kA dA kR (x1 − x2 ) + (x3 − x4 ) − (x2 − xS ) mR mR mR

x˙3 = − x˙4 =

3 auch eine vektorielle Betrachtung mit einem oder zwei Integrierer-Blöcken ist möglich

(4.9)

4.4 Simulink-Modellierung eines einfachen Projekts

189

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˙ = Ax + B u, y = Cx Cx.

u = xs

(4.10)

Die Systemmatrizen stellen wir zusammen: - Systemmatrix A : ⎡ 0 ⎢ 0 A=⎢ ⎣ −kA /mA kA /mR

0 0 kA /mA −(kA + kR )/mR

1 0 −dA /mA dA /mR

- Eingangsvektor B für die Eingangsgröße u = xS :

⎤ 0 ⎥ 1 ⎥ dA /mA ⎦ −dA /mR

(4.11)

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= 0 1 0 0 0

(4.13)

- 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 Reifenkraft fR interessiert, dann erreichen wir dies mit ⎤ ⎡ x1     kA kA  dA dA  ⎢ − mA mA − mA mA ⎢ x2 ⎥ x˙3 0 ⎥+ u, u = xS = ⎣ x˙1 ⎦ fR −kR 0 kR 0 0 x˙2 y

4.4.2.2

=

C

x

+

D

u.

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 Ausgangsvektor 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 Relativgeschwindigkeit 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

190

4 Simulation unter Simulink

einzusetzen sind: - Eingangsmatrix B , Eingangsvektor für das C OULOMB-Reibelement u˜ : ⎡ ⎤ 0 0   ⎢ ⎥ 0 0 xS ⎥ , u˜ = B=⎢ ⎣ 0 −FC /mA ⎦ sign (x3 − x4 ) kR /mR FC /mR

(4.16)

- 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

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 ⎦ 0 0 1 −1 0 0

(4.17)

(4.18)

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 Fahrbahnunebenheit und daran anschließend die Rampe und das ebene Plateau nach (4.4). Das vollständige Fahrbahnprofil setzt sich dann auf dem Plateau additiv aus beiden Anteilen zusammen. Natürlich können auch gemessene Fahrbahnunebenheiten verarbeitet werden. Liegen Messwerte 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 Ordnung (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 Grenzfrequenz (Eckfrequenz) ωg . Der Funktionsblock Band-Limited White Noise aus der Blocklibrary

4.4 Simulink-Modellierung eines einfachen Projekts

uF Band-Limited

191

yF Fahrbahnunebenheit

✲

✲

Tiefpassfilter

White Noise

Bild 4.18: Fahrbahnmodellierung

Sources liefert das digitale Rauschsignal uF . Mit dem Parameter ωg des Tiefpassfilters (Formfilters) 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 Parameter 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 Fahrzeuggeschwindigkeit. Der endgültige geglättete Unebenheitsgrad in Frequenzanteil und Amplitude wird über das Tiefpassfilter eingestellt. Wir betrachten eine Fahrbahnunebenheit mit dem Parametersatz: Tiefpass Rauschgenerator

ωg Noise power Sample time Seed

100 rad/sec μ3 ωg3 u, z. B.: u = 0,1333 0,02 sec [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 Differenzialgleichung 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 Programmstruktur ist weitgehend festgeschrieben, siehe Abschn. 4.7.

192

4 Simulation unter Simulink

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 Gewichtungen 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

−3

Weisses Rauschen (bandbegrenzt) 8000

6 Fahrbahnunebenheit [m]

6000

Intensität

4000 2000 0 −2000 −4000 −6000

0

0.2

0.4 0.6 Zeit [sec]

0.8

1

Strassenprofil

x 10

4 2 0 −2 −4 −6

0

0.2

0.4 0.6 Zeit [sec]

0.8

1

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.

4.4 Simulink-Modellierung eines einfachen Projekts

193

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 Filterparameter 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 Übertragungsfunktion 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 Fahrbahnunebenheit 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 if u < y = else y = end

y = rampe(u) 0.1 0.1 * u;

% rampe.m

0.01;

zu erstellen und unter rampe.m abzuspeichern. Der Eintrag ins zugehörige Blockfenster umfasst u. a: 4 MIMO Multiple Input Multiple Output System

194

4 Simulation unter Simulink

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 compilierten 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 Rampenende wird nicht detektiert. Darüber hinaus wird eine additiv hinzugefügte Fahrbahnunebenheit 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 entsprechend (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 Constant Block mit der zugewiesenen Niveauhöhe (hier: 0.01) eingestellt. Die logische Entscheidung 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 damit 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 detection 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

if control < threshold

Switch1

Clock

Gain

1 Switch

Out1

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.

4.4 Simulink-Modellierung eines einfachen Projekts

195

Hierzu tragen wir, nicht die numerische Form der Matrizen, sondern die eingeführte MatrizenBezeichnungen 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); [-kA kA -dA dA ]/ mA; [ kA -(kA+kR) dA -dA] / mR]; B=[0; 0; 0; kR/mR]; C=[eye(2) zeros(2)]; D=zeros(2,1);

% Systemmatrix

% Eingangsmatrix des reibfreien Modells % Ausgangsmatrix des reibfreien Modells % 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

196

4 Simulation unter Simulink

Fahrzeugmodells Offset = 1

und Gain = 0

im Block-Parameter-Fenster zu setzen. Der Block-Eingang ist die Relativgeschwindigkeit zwischen 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 % 1 s0 ≥ 1 −s0 v0 ≤ vrel ≤ s0 v0 , F v0 vrel (4.21) =: y = , für FC |vrel | > s0 v0 sign(vrel ) 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 Haftreibungskraft F/FC (s0 ≥ 1) setzen, wie in Bild 4.24 angegeben. Dadurch werden auch die unterschiedlichen Größen von Haft- und Gleitreibung durch μ0 = s0 , μ = 1 näherungsweise berücksichtigt. Das Block-Modell der approximierten Reibkennlinie mit dem Eingang vrel = x3 − x4

4.4 Simulink-Modellierung eines einfachen Projekts

197

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 Out1

|u|

50 Gain

1 In1

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 BlockModells – 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 wiedergegeben. 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

198

4 Simulation unter Simulink Coulomb−Reibung

approx. Reibkennlinie

3

3 Testfunktion

2

2

1

1

0

0

−1

−1

−2

−2

−3

0

0.5

1 Zeit t [s]

1.5

2

−3

Threshold 1 0

approx. Reibkennlinie 3

2

2

1

1

0

0

−1

−1

−3

0.5

1 Zeit t [s]

1.5

1.5

2

−2

Threshold 2 0

1 Zeit t [s]

approx. Reibkennlinie

3

−2

0.5

Threshold 2 2

−3

0

0.5

1 Zeit t [s]

1.5

2

Bild 4.27: Ergebnisse zur C OULOMBschen und approximierten Reibkennlinie; Steigungen im Nulldurchgang: b), d) 5, c) 500 3

3 mit Nullstellenermittlung

2 1

1

Diskontinuität

0

0 Reibkraft

−1

Reibkraft

−1

−2 −3

ohne Nullstellenermittlung

2

−2 Testfunktion 0

0.2

0.4 Zeit [s]

0.6

0.8

−3

Testfunktion 0

0.2

0.4 Zeit [s]

0.6

0.8

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. Einerseits 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 MFile 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

4.4 Simulink-Modellierung eines einfachen Projekts

199

%------------------------------Start-File sim_v12S.m sim_v12 try time = sim(’sim_v12’,3); catch sim_v13D time = sim(’sim_v12’,3); end h = findobj(0, ’Name’, ’Rampe’); if isempty(h), h=figure(’Position’,[150 194... 452 257],... ’Name’,’Rampe’,... ’NumberTitle’,’off’); end figure(h) ...................

% % % % % % % %

öffnen des Simulink-Modells Startversuch, Fehler? Start des Simulink-Modells mit Endzeitvorgabe nach Fehler neuer Start Aufruf des Daten-Moduls Daten in Workspace geschr. siehe oben

% % % % % %

existiert figure? nein, dann Konfiguration Position und Bildgröße Namensgebung Nr. ausblenden

% 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 Simulation 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 Integrationszeit 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 Startfile 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 angegebenen 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 auszuwä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

200

4 Simulation unter Simulink

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 erstellt – 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ährend 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 Gleichgewichtslage. 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ämpfung 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 Dx˙ +Kx Kx = Bu˜ M x¨ +D 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

4.4 Simulink-Modellierung eines einfachen Projekts

201

Auslenkungen [m] 0.015 xA xR 0.01

0.005 ebene Fahrbahn ohne Reibelement 0

0

0.5

1

1.5 Zeit t [s]

2

2.5

3

Auslenkungen [m] 0.015 xA xR 0.01

0.005 unebene Fahrbahn ohne Reibelement 0

0

0.5

1

1.5 Zeit t [s]

2

2.5

3

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

202

4 Simulation unter Simulink −3

15

Auslenkungen [m]

x 10

Relativgeschw. [m/s] 0.06 0.04

10

0.02

xA xR

5

0 −0.02

ebene Fahrbahn

0

−0.04

COULOMB−Reibung

−0.06 −5

0

0.2 −3

15

x 10

0.4 0.6 0.8 Zeit t [s] Auslenkungen [m]

1

0

0.2

0.4 0.6 0.8 Zeit t [s] Relativgeschw. [m/s]

1

0

0.2

0.4 0.6 0.8 Zeit t [s] Relativgeschw. [m/s]

1

0.06 0.04

10

0.02 xA xR

5

0 −0.02

ebene Fahrbahn

0

−0.04

approx. Reibkennlinie

−0.06 −5

0

0.2 −3

15

x 10

0.4 0.6 0.8 Zeit t [s] Auslenkungen [m]

1

0.06 0.04

10

0.02

xA xR

5

0 −0.02

ebene Fahrbahn

0

−0.04

approx. Reibkennlinie

−0.06 −5

0

1

2 Zeit t [s]

3

4

0

1

2 Zeit t [s]

3

4

Bild 4.33: Gegenüberstellung der Ergebnisse

vermutet, an der sprunghaften Änderung der Reibkraft in Bereichen, in denen die Relativgeschwindigkeit ihr Vorzeichen wechselt. In diesem Fall ist die rechte Seite von (4.5) eine unstetige Funktion und somit in dieser Form nicht integrierbar. Dies hat nichts mit einer steifen

4.4 Simulink-Modellierung eines einfachen Projekts −3

15

203

Auslenkungen [m]

x 10

xA xR

10

5 unebene Fahrbahn

0

−5

ohne Reibelement

0

0.5

1

−3

15

1.5 Zeit t [s]

2

2.5

3

Auslenkungen [m]

x 10

xA xR

10

5 unebene Fahrbahn 0

−5

approx. Reibkennlinie

0

0.5

1

1.5 Zeit t [s]

2

2.5

3

Bild 4.34: Einfluss der Reibung bei unebener Fahrbahn

Differenzialgleichung zu tun, wie vielfach in der Literatur dargestellt. Auf eine korrekte Vorgehensweise wird in den Kapiteln 5 –8 eingegangen. Um dennoch einen Einblick in das Systemverhalten 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 Amplitudendifferenz 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 vergleichbares Verhalten. Vorteil dieser Modellierung ist, dass hier mit variabler Schrittweite integriert werden 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 dieses 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

204

4 Simulation unter Simulink

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 dynamische Verhalten zeichnet sich wieder dadurch aus, dass das Rad (xR ) dem Fahrbahnprofil unmittelbar 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.

Reibkraft

2

2

a)

2

0

0

0

0

ode15s 0.5

−2

d)

c)

0 ode15s

−2

2

b)

0

t [s]

0.5 t [s]

−2

ode113

ode45 0

0.5 t [s]

−2

0

0.5 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 dementsprechend 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 Unstetigkeitsstellen, 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 aufgetragen. 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 Verhalten 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 bekannte Erfahrung: Mehrschrittverfahren eignen sich im Allgemeinen (konstruktionsbedingt) weniger für Systeme mit Diskontinuitäten. Auch eine Integration mit ode45 / ode113 und Ereignisermittlung zeigte dieses oszillatorische Verhalten, welches somit insbesondere auf die Steifigkeit der Differenzialgleichung zurückzuführen ist.

4.5 Algebraische Schleifen in dynamischen Modellen

4.5

Algebraische Schleifen in dynamischen Modellen

4.5.1

Algebraische Schleifen

205

Algebraische Schleifen in einem Signalfluss enthalten nur Blöcke mit direktem Durchgang (direct 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 Durchgang, 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. Modellierungen 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. Gelö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 Programme, 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 Abschn. 5.4 behandelten differenzial-algebraischen Gleichungen. Bild 5.13 zeigt ein mögliches Simulink-Modell. Wir wollen uns hier auf Formulierungen durch gewöhnliche Differenzialgleichungen (ODE) mit mehreren Freiheitsgraden beschränken. In diesem Fall ist das Auftreten algebraischer 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 f = q sin (Ωt + Φ) an. Im Drehgelenk A   Erregerkraft 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.

206

4 Simulation unter Simulink

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 Gleichgewichtsbedingungen 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 (k)

= 0 → Fx + M x¨ − q sin (Ωt + Φ) = 0

(4.22)

Pendel mit der Masse m und der Länge L

∑ FP,x,k (k)

= 0 → Fx − mx¨ − mLϕ¨ cos ϕ + mLϕ˙ 2 sin ϕ = 0

(4.23)

4.5 Algebraische Schleifen in dynamischen Modellen (A)

∑ MP,k (k)

  = 0 → −mxL ¨ cos ϕ − mL2 ϕ¨ − mgL sin ϕ + α − β ϕ 2 ϕ˙ = 0

207

(4.24)

Elimination von Fx mit (4.22) und auflösen nach x¨ bzw. ϕ¨ liefern die in ein Simulink-Modell umzusetzenden Bewegungsgleichungen:   1 mL 2 −ϕ¨ cos ϕ + ϕ˙ sin ϕ + q sin (Ωt + Φ) x¨ = M+m mL (4.25)  1 1  2 ˙ ¨ ϕ = ( −x¨ cos ϕ − g sin ϕ ) + α − βϕ ϕ 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:

208

4 Simulation unter Simulink

u1 = ue + uϕ p − u6  mL mL  ue + uϕ p − u6 u1 = u2 = M+m M+m u6 = u5 uc mit

u5 = −u4 − ug + use ;

u4 =

1 L u3 ;

(4.26)

u3 = u2 uc . Damit folgt

1 u6 = − u2 u2c − ug uc + use uc L und schließlich u2 =

mL M+m



ue + uϕ p +

1 u2 u2c + ug uc − use uc L



.

(4.27)

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 u2 =

  mL ue + uϕ p + ug uc − use uc 2 M + m − muc

bzw. mit den ursprünglichen Bezeichnungen  mL g 1 x¨ = q sin (Ωt + Φ) + ϕ˙ 2 sin ϕ + sin ϕ cos ϕ 2 M + m sin ϕ mL L   1  2 ˙ . α − β ϕ ϕ cos ϕ − mL2

(4.28)

(4.29)

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 Schleife, Bild 4.38, formulieren können, um damit die Integrationskette für ϕ¨ zu ersetzen, vgl. metro_S1.mdl in [52]. Es ergibt sich: ϕ¨ =

   −m q 2 ˙ cos ϕ ϕ + Φ) sin (Ωt ϕ + sin M + m sin 2 ϕ mL    M+m g 1  2 ˙ α − β ϕ sin ϕ − + ϕ m L mL2

(4.30)

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

4.6

209

Vektorielle Betrachtungsweise und Modellierung

Die Bewegungsgleichungen von Systemen mit mehreren Freiheitsgraden überführt man zweckmäßigerweise in eine vektorielle Schreibweise. Hiermit lässt sich in der Regel ein übersichtlicheres Simulink-Modell erstellen. Angewendet auf (4.25) bedeutet dies:          mgL sin ϕ − α − β ϕ 2 ϕ˙ ϕ¨ 0 mL2 mL cos ϕ + sin (Ωt + Φ) (4.31) = x¨ q mL cos ϕ M+m −mLϕ˙ 2 sin ϕ oder kurz ˙ = q sin (Ωt + Φ) . M (ϕ) y¨ + f (ϕ, ϕ)

(4.32)

M ) > 0) MassenDabei ist M = M T die von ϕ abhängige symmetrische und positiv definite (det(M matrix, f die nichtlineare Vektorfunktion und q der Vektor der Erregeramplituden. Zur Modellierung von (4.32) wird der Vektor y¨ vor dem ersten Integrierer abgebildet. Hierzu multiplizieren wir zunächst (4.32) mit der Inversen von M durch: ˙ + q sin (Ωt + Φ)) . y¨ = M −1 ( − f (ϕ, ϕ)

(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 durchgeführt. Abschließend kann y mit dem Demux Block (Demultiplexer) in seine Komponenten 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.

210

4 Simulation unter Simulink

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 erstellen. 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 ϕ




α β

Dämpfung

(4.34)

durch die Schwingung des Systems selbst gesteuert. Bezüglich des Schwingungsverhaltens wollen 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 Einschwingvorgang berechnet werden. Gleichzeitig wird von einer FFT-Analyse des Schwingungssignals – 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)

4.6 Vektorielle Betrachtungsweise und Modellierung

211

Darüber hinaus ist bekannt [58], dass, wenn die Erregerkreisfrequenz Ω in der Größenordnung 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 einstellende 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 Anregungen 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 Erregung 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 direkt 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...), Bremsquietschen, Flattern von Kraftwagenrädern, gleitgelagerte Turbo-Rotoren, elektrische Schwingkreise, Regelungskreise und durch Wind angeregte Hochspannungsleitungen, Lichtmasten, Fabrikschornsteine 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 andererseits 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

212

4 Simulation unter Simulink

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) erreichen, wenn wir die Pendelwinkel vektorisieren und eine Abkürzung ϕ = [ ϕ1 , ϕ2 , ...., ϕ5 ]T ,

T  ϕ˙ 2 := ϕ˙ 12 , ϕ˙ 22 , ...., ϕ˙ 52

(4.35)

einführen (MATLAB: Punkt-Operation anwenden, ϕ˙ 2 := ϕ˙ . ∗ ϕ˙ ). Schreiben wir noch für die ϕ , ϕ˙ ), dann lauten die Bewegungsgleichungen Selbsterregerfunktion m s (ϕ g 1 1 ϕ , ϕ˙ ) m s (ϕ cos ϕ x¨ = − sin ϕ + L L mL2 q M + 5m 1 1 ϕ T ) ϕ¨ + ϕ T ) ϕ˙ 2 + cos (ϕ x¨ = sin (ϕ sin (Ωt + Φ) 2 L mL L mL2  T oder kurz mit y = [ϕ1 , ϕ2 , ..., ϕ5 , x]T = ϕ T , x ϕ¨ +

(4.36)

⎤ ⎡ ⎤ 1 g ˙ ϕ , ϕ ) m (ϕ − sin ϕ + 0 s 2 ⎢ L ⎥ ⎣ mL M y¨ = ⎣ ⎦+ q ⎦ sin (Ωt + Φ) 1 T ˙2 ϕ ϕ sin (ϕ ) mL2 L ⎡

(4.37)

mit der symmetrischen Massenmatrix ⎡

⎢ ϕ) = ⎢ M (ϕ ⎣

E 5×5 1 ϕ T) cos (ϕ L

⎡ ⎤ 1 0 0 0 0 c1 1 ϕ) cos (ϕ ⎢ 0 1 0 0 0 c2 L ⎥ ⎢ ⎥ = ⎢ .................................... ⎢ ⎦ ⎣ 0 0 0 0 1 M + 5m c5 mL2 c1 c2 c3 c4 c5 (M + 5m)/(mL2 )

⎤

⎥ ⎥ ⎥ (4.38) ⎥ ⎦

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)

4.6 Vektorielle Betrachtungsweise und Modellierung

213

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 ⎪ ⎪ ⎨ ˙ ϕj ms j (ϕ j , ϕ˙ j ) = ϕ˙ j ⎪ ⎪ ⎩ ˙ ϕj

> < >
0 : ϕ j < −q j2 oder ϕ j >

ms j = +M − aϕ˙ j ms j = −M − aϕ˙ j +q j2 → ms j = −aϕ˙ j +q j1 → ms j = −aϕ˙ j

(4.40)

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) eingebunden 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 Nachbarschaft 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

214

4 Simulation unter Simulink

4.7

Modellierung mit Hilfe einer S-Function

Mit Hilfe eines S-Function-Blocks aus der Sublibrary User-Defined Functions können mit SFunctions7 z. B. eigene Programmcodes in den Programmiersprachen: • • • •

MATLAB

C, C++ FORTRAN ADA

M-File, Level-1, Level-2 Standard ab Simulink 6 (R14) compiliert als Mex-File (Aufruf: mex File_name.c) compiliert als Mex-File compiliert als Mex-File

in ein Simulink-Modell eingebunden werden. Die Arbeitsweise der S-Function ist festgeschrieben. Der S-Function-Block genügt der Blockstruktur aus Abschn. 4.1.1. Die Partitionen des Zustandsvektors 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, zeitdiskrete 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 angeschlossenen 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 SimulinkGleichungslösern geschaffen wird. In der Sublibrary User-Defined Functions im Block S-Function 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äuterungen, 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öglichkeiten 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 einerseits 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 Ausgabedaten. 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

Initialisierung Ermittlung der Ableitungen Update des zeitdiskreten Zustandes Ermittlung der Ausgabe Ermittlung des nächsten Abtastzustandes Ende des Simulations-Task

mdlInitializeSizes mdlDerivatives mdlUpdate mdlOutputs mdlGetTimeOfNextVarHit mdlTerminate

flag 0 1 2 3 4 9

Die S-Function sf_carm.m aus [52] verdeutlicht anhand des Zustandsmodells zum 1/4Fahrzeugmodell 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

216

4 Simulation unter Simulink

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-Programm sf_carm.m, enthält neben den Dimensionierungen sizes.NumcontStates sizes.Num.DiscStates sizes.NumOutputs sizes.NumInputs

Anzahl der zeitkontinuierlichen Zustandsvariablen Anzahl der zeitdiskreten Zustandsvariablen Anzahl der Ausgänge 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 Du sprungfähiger Sysist die bekannte Messgleichung aus der Regelungstechnik: y = Cx +Du 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 v0 FC sign(vrel ) 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 werden. 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 erfolgen 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 enthä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 symbolischer 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 mdlInitializeSizes, mdlDerivatives, mdlOutputs aufgerufen, die restlichen werden nicht benö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.

218

4 Simulation unter Simulink

Bild 4.45: Simulink-Modell mit S-Function-Block für die Zustandsgleichungen

function function_name(block) setup(block)

% Function-Kopf % 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 gegenü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) setup(block); %%endfunction sf_car2m

% Haupt-Function

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; block.NumOutputPorts = 1;

% ein Eingang % ein Ausgang

% Port-Eigensch. (Datentyp, Komplexität usw.) dynamisch bezogen

4.7 Modellierung mit Hilfe einer S-Function

219

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 % Setzen der Anfangswerte der Zustandsgrößen block.ContStates.Data = zeros(size(A,1),1); %%endfunction InitializeConditions

% Parameterübergabe

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

220

4 Simulation unter Simulink

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 BlockParameterwechsel infolge eines Ausgangswertes eines anderen Blocks vor. Dieses Problem ist jeweils mit einer Level-1, Level-2 M-File S-Function unter Verwendung 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(...

4.7 Modellierung mit Hilfe einer S-Function

221

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 SinusVerlauf 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 Simulink-Modell lissaj.mdl in [52] angegeben. In s_lissaj wird die obige Gleichung 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.

222

4 Simulation unter 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 Informationen zur Erstellung der S-Function einzutragen sind. Im Einzelnen sind dies: • Initialization (Initialisierung): Anzahl der (zeit-) kontinuierlichen und/oder diskreten Zustä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 numerischen 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. compilieren) 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 generieren (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

4.7 Modellierung mit Hilfe einer S-Function

223

Die Übersetzung erfolgt mit dem Build(Save)-Button. Sind anschließend Systemparameter 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   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

(4.42)

sowie der Reibkennlinie nach (4.41) kann die Erstellung der S-Function mit dem Builder nachvollzogen 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 Steuerparameters 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-Defined Function sind mit dem Block: S-Function Examples Templates und Demo-Beispiele zu öffnen. 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 flagParameter 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 compilierten 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. ADWandler), 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 Demoprogramm stspace.c; es wurde lediglich auf den Eingabe-Check verzichtet. Im Gegensatz zu

224

4 Simulation unter Simulink

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 Anfangswertprobleme 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 partielle Differenzialgleichungen (Function: pdepe). Beispiele mit Code-Anzeige aller verfügbaren Methoden können mit dem Aufruf von >> odeexamples aus dem Command Window eingesehen 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 x˙ (t0 ) = x˙ 0 , x (t0 ) = x 0 , so dass g¯ (˙x 0 , x 0 , t0 ) = 0

g¯ (˙x , x , t) = 0 ,

(5.1)

sowie einer expliziten x˙ = g (xx, t),

x (t0 ) = x 0

(5.2)

Formulierung der Differenzialgleichung mit den Anfangswerten x˙ 0 , 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¯ 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 nichtautonomen 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¨ linear auf, vgl. Kapitel 2, sie werden deshalb durch Bewegungsgleichungen mit f Freiheitsgraden M q¨ = f a (t, q , q˙ ),

q˙ (t0 ) = q˙ 0 ; q (t0 ) = q 0 ,

(5.3)

wobei in q Lage- und/oder Winkelvariablen (Minimalkoordinaten) und in f a Kräfte und/oder Momente stehen, beschrieben. Die Massenmatrix in (5.3) kann sowohl zeit- und/oder lageabhängig 1 ODE Ordinary Differential Equation

W. D. Pietruszka, MATLAB® und Simulink® in der Ingenieurpraxis, DOI 10.1007/978-3-8348-8630-9_5, © Vieweg+Teubner Verlag |Springer Fachmedien Wiesbaden GmbH 2012

226

5 Simulation unter MATLAB

M := M (t, q ) oder konstant sein. Gleichung (5.3) ist ebenfalls eine gewöhnliche nichtlineare Differenzialgleichung 2 f -ter Ordnung. Setzen wir in (5.3) q˙ = v , dann folgt zunächst E q˙ = v M v˙ = f a (t, q , v )

E = diag(1, 1, . . . , 1)

(5.4)

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˙ = f (t, x ),

E , M ); x (t0 ) = x 0 M ⋆ = diag(E

(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 fD (s) ˙ + k0 s − k(x − s) = 0 ,

(5.6)

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. ˙ T ein implizites Differenzialgleichungssystem Es liegt mit x = (x1 , x2 , x3 )T = (x, s, x) der Form (5.1) =0 x˙1 − x3 mx˙3 + k(x1 − x2 ) + mg = 0 ˙ + k0 x2 − k(x1 − x2 ) = 0 fD (s)

(5.7)

vor, wir behandeln es in Abschn. 5.5. Setzen wir speziell nach [66] ˙ = d0 s˙ + d s˙ |s| ˙ , fD (s)

|s| ˙ =

s˙ , sign (s) ˙

(5.8)

dann folgt für d = 0 unmittelbar eine lineare explizite Differenzialgleichung. Berücksichtigen 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   + d0 d0 1  s˙ = ⎣− (5.9) + (x − s) − k0 s ⎦ sign (k(x − s) − k0 s) . (−) 2d 2d d Nach Bild 5.2 gehört zum negativen Vorzeichen (−) die anfachende Kennlinie ˙ herfD (s˙− ), die durch Spiegelung an der Ordinate aus der Dämpfungsfunktion fD (s) 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 ⎤⎡ ⎤ ⎡ ⎤ ⎡ ⎤ ⎡ ⎤• ⎡ x 0 0 0 1 0 1 0 0 0 x ⎢ ⎥ ⎢ ⎥ ⎢ 0 1 0 0 ⎥⎢ s ⎥ ⎢ 0 0 0 0 1 ⎥ ⎥⎢ s ⎥=⎢ ⎥ (5.10) ⎢ ⎥⎢ ⎥ ⎢ ⎣ 0 0 m 0 ⎦ ⎣ x˙ ⎦ + ⎣ k −k 0 0 ⎦ ⎣ x˙ ⎦ ⎣ −mg ⎦ s˙ − fD (s) ˙ −k k + k0 0 0 0 0 0 0 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 werden. 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 M ⋆ )−1 durchmultiplizieren und somit eine explizite Differenzialgleichung wir mit (M von Typ (5.2) erhalten. Anhand dieses recht einfachen Beispiels wird klar, dass wir ein und dasselbe Problem mit unterschiedlichen 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-algebraisches Gleichungssystem gelöst werden. Welche Form man letztendlich wählt, hängt auch von

228

5 Simulation unter MATLAB

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 Formulierungen 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ätzlichen 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 bevorzugt 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 eingegangen werden. Haben die Bewegungsgleichungen konstante Koeffizienten, dann ist es in der Regel vorteilhafter, mit Hilfe der Methoden der linearen Algebra – Eigenwertprobleme, lineare algebraische 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 Freiheitsgraden auf folgende Struktur bringen: P y˙ +Q Q y = pp(t). M y¨ +P

(5.11)

M ) = 0 folgt Dabei dürfen M , P , Q zeitabhängig sein. Unter der Voraussetzung: M regulär, det(M mit der Inversen M −1 M −1P y˙ +M M −1Q y = M −1 p (t) y¨ +M

(5.12)

5.1 Struktur der Differenzialgleichungen

229

und für die Zustandsraumdarstellung mit den Abkürzungen , x 2 = y˙ x1 = y        x1 0 E 0 x˙ 1 = + p (t) M −1Q −M M −1 M −1P x˙ 2 x2 −M    Systemmatrix A

(5.13)

oder kurz

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 symmetrisch (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 Massenmatrizen 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 L

u(t)

uL

C

uC

Bild 5.3: Elektrisches System

uR , uL und uC , so dass u(t) = uR + uL + uC und damit die Spannungsdifferenzialgleichung u(t) = Ri + L(i)˙ +

1 C

$t

i dt;

i(0) = i0

(5.15)

gilt. Um eine explizite Form von (5.15) zu erhalten, können unterschiedliche Möglichkeiten zur Elimination des Integrals eingeschlagen werden:

230

5 Simulation unter MATLAB

• Durch zeitliche Ableitung von (5.15) folgt L(i)¨ + R(i)˙ +

1 i = u(t) ˙ C

(5.16)

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 1 1 R i+ Q = u(t) L CL L Q˙ − i = 0

(5.17)

(i)˙+

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 Zustandsraumdarstellung 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 beschreibt 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

5.1 Struktur der Differenzialgleichungen

231

Regelkreis ist bei einer Ausgangsvektorrückführung durch das mathematische Modell in Zustandsform x˙ (t) = A x (t) + B u (t) + W s (t) y M (t) = C x (t) + D u (t) K A y M (t) u (t) = −K

(5.19)

beschrieben. Hat das System mehrere Ein- und Ausgangsgrößen, dann spricht man von einer Mehrgrößenregelung (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: initial(sys,x0,te) Anfangswertantwort 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 Differenzialgleichungen, wie in Kapitel 3. Beispiel 5.3: Simulation eines Regelkreises Für den in Bild 5.5 skizzierten Schwinger mit zwei Freiheitsgraden sollen die Bewegungsgleichungen 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 Stellzylinder 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¨ + D y˙ + K y = b ⋆ u(t) + w ⋆ cos Ωt T

yM = c ⋆ y , mit dem Lagevektor y T = [y1 , y2 ]

232

5 Simulation unter MATLAB

Bild 5.5: Zweimassen-Schwinger als Regelstrecke

und seinen zeitlichen Ableitungen y˙ , y¨ , der Massenmatrix, der Dämpfungs- und Steifigkeitsmatrix     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 ;

T

c ⋆ = [1, 0].

Für die explizite Schreibweise der Strecke bilden wir zunächst die Systemmatrix   0 2×2 E 2×2 A = , M −1K −M M −1D −M 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˙ T ]T folgt dann die Bewegungsgleichung 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)

5.1 Struktur der Differenzialgleichungen

233

Fügen wir u˙I (t) = c Tx (t) zur Systemgleichung hinzu, dann folgt        A O b x (t) x˙ (t) = + u(t) 0 uI (t) u˙I (t) cT 0      1 0 0 0 0 x (t) x (t) = , y (t) = C 0 0 0 0 1 uI (t) uI (t) bzw. für den geschlossenen Kreis #  "   A − k p b c T −kI b x˙ (t) x(t) = u˙I (t) uI (t) 0 cT     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˙ = 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 )

234

5 Simulation unter MATLAB

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 = q cos Ωt .

(5.20)

In der Elektrotechnik wurden früher stabile Oszillatoren (heute Quarz) in Form diskreter 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 periodisch. Die Periodendauer T wird durch den Parameter ε festgeschrieben. Da die periodischen 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 Standardgleichung 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 x˙2 = ε(1 −

x12 )x2

− x1 +



0 q cos Ωt

.

• Mechanische Systeme mit Minimalgeschwindigkeiten: Bewegungsgleichungen holonomer Mehrkörpersysteme in Minimalkoordinaten q ∈ R f haben die allgemeine Form M (qq, t) q¨ + k (qq, q˙ , t) = Q (qq, q˙ , t),

q (t0 ) = q 0 , q˙ (t0 ) = v 0 ,

(5.21)

wobei der Geschwindigkeitszustand, wie in (5.4), stets durch die zeitlichen Ableitungen der Lagekoordinaten beschrieben wird. Die explizite Schreibweise entspricht (5.3). Definieren wir die Geschwindigkeitszustände s˙ als Linearkombinationen von q˙ mit den i. allg. lageabhängigen Linearfaktoren als Elemente der regulären Matrix H ∈ R f , f , dann gelten die kinematischen Differenzialgleichungen q˙ = H (qq)˙s .

(5.22)

5.1 Struktur der Differenzialgleichungen

Einsetzen von (5.22) und deren zeitlichen Ableitung q¨ = H (qq)¨s + h (qq, s˙)

mit h = H˙ s˙

(5.23)

in (5.21) sowie Multiplikation mit H T von links liefern die Bewegungsgleichungen in Minimalkoordinaten q und Minimalgeschwindigkeiten s˙ =: ω ω q˙ = H (qq)ω   ¯ ω˙ = M (qq, t)−1 Q¯ (qq, ω , t) − k¯ (qq, ω , t)

(5.24)

mit den Matrizen

¯ = H TMH MH, M

Mh + k ), k¯ = H T (Mh

Q¯ = H TQ .

Vorteil gegenüber (5.21): Einfacherer Aufbau der Bewegungsgleichungen, vielfach kürzere Integrationszeiten (Verläufe s˙(t) glatter); Anwendung: Kreiselsysteme. Für H = E erhalten wir die explizite Form von (5.21). Gleichung (5.23) ist die allgemeinere 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 x¨ =

dv dx = v′ v dx dt

aus der Ausgangsgleichung des VAN - DER -P OLSchwingers eine Differenzialgleichung 1. Ordnung für v(x) x dv = v′ = ε(1 − x2 ) − ; dx v

v = 0 .

Allgemein gilt für nichtlineare Systeme: dx = P(x, y), dt

dy = Q(x, y) ; dt

P = 0 , P, Q glatt,

235

236

5 Simulation unter MATLAB

so dass Q(x, y) dy = . 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 auftritt, sie also autonom ist, die Winkelgeschwindigkeit ω = φ˙ als Funktion des Drehwinkels ω = ω(φ ). 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: M(φ˙ ) g φ¨ + sin φ = ℓ mℓ2 φ (0) = φ0 , φ˙ (0) = φ˙0 .

☛

✬✩

k(Ω − φ˙ ) ℓ

✣ ①m ✫✪

φ

Beide oben angedeuteten Betrachtungsweisen wollen wir kurz erläutern: • Diskussion von φ (t), φ˙ (t): Dieses Ergebnis erhalten wir unmittelbar durch numerische Integration der oben angegebenen Bewegungsgleichung. Die zugehörigen Zeitverläufe für g = 5,0 1/s2 , ℓ

k = 5,5 1/s ; Ω = 1 rad/s mℓ2

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 ω ′ω +

M(ω) g sin φ = , ℓ mℓ2

( )′ = d /d φ

bzw. nach Division mit ω (ω = 0 vorausgesetzt) die Differenzialgleichung 1. Ordnung für ω(φ ) ω′ +

M(ω) g sin φ = . ωℓ ωmℓ2

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 Integrationszeit zu rechnen ist, zeitweilig rückläufige Bewegungen seien ausgeschlossen. 25 20

2

2

1.5

1.5

1

1

ω

φ

ω

15 10 0.5

5 0

0

20 Zeit t

40

0

0.5

0

20 Zeit t

40

0

0

10 φ

20

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 Programmcode des Integrationsverfahrens z. B. odexx und dem Unterprogramm (Function) z. B. sys der zu bearbeitenden Differenzialgleichungen zusammen. Das Hauptprogramm umfasst mindestens die Parametrisierung des zu simulierenden mathematischen Modells mit der Parameterübergabe (u. a. über die Global-Vereinbarung global...) an die Function der Differenzialgleichungen, den Integratoraufruf mit zugehörigen Optionen (z. B. Fehlertoleranz) sowie die Ergebnisauswertung. 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-

238

5 Simulation unter MATLAB

[ta te], y 0 ✲

❄

Hauptprogramm global... Parameter Parametrisierung Integratoraufruf mit Optionen Ergebnisauswertung: Signalanalyse Ausgabe: plot, File

t,y

ODExx(’syst’,[ta te],y0,...)

function[ydot] = sys(t,y,...) ✛ global ..., Parameter y˙ = f (t, y )

Integrationsverfahren ✻

tk , y k

✻

y˙ k

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 zunä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 f

tspan y0 options p1, p2... t,y

5.2.1.1

239

berechnet y˙ (tn ) der Dgl. y˙ = f (t, y ) zum Zeitpunkt tn oder M y˙ = f (t, y ), M = const. oder M (t, 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 [ t0 te ] oder [ t0 , t1 , . . . , te ], Zeitvektor: Anfang / Ende bzw. Zeitfolge Anfangswerte: [y1 (0); y2 (0); ...] zum Zeitpunkt t = 0 Integratoroptionen kreiert mit odeset; vgl. Tabelle 5.2 (vgl. simset für Simulink) Übergabe von Systemparametern, u. a. an f, nach Optionen bzw. mit [ ] ohne Opt. Lösung: Zeitv. t u. Zustandsv. y oder als Structure, z. B. loesung

Integrationsaufrufe mit Optionen

Anhand einiger Beispiele erläutern wir wesentliche Optionen aus Tabelle 5.2 und Integrations% Eingabe im Command Window aufrufe, vgl. auch: help odeset und >> odeset 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’)

240

5 Simulation unter MATLAB

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˙ = f (t, y ), M konstant options = odeset(’Mass’,M) % M=konst im Hauptprogramm definiert • System der Form M (t, 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 = 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,..) function dydt = f(t,y,p1,...)

% Schaltfunktion in % Function event definiert % 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˙ ) = 0 , siehe Abschn. 5.5 konsistente Anfangsbedingungen, f (t0 , y 0 , y˙ 0 ) = 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) res = yp(1)-y(3); ....

% Function der impliziten Dgl.

Ausgabehilfsmittel, Optionsabfragen Darüber hinaus lassen sich mit OutputFcn Ausgaben als Zeitverläufe odeplot – wie in Beispiel 5.6 –, als 2D- und 3D-Phasenebenen odephas2, odephas3 und der numerischen Zwischenwerte 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 gebracht 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 Schreibweise in y y˙ = f (t, y ), y (0) = y 0 ,

bzw.

M ⋆y˙ = g (t, y )

übergehen, insbesondere dann, wenn nicht ausnahmslos mechanische Größen vorkommen. Aufbereitung 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 Ordnung 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 Anfangswerten 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

242

5 Simulation unter MATLAB

% ---- 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) yp=2*sin(y)*cos(1.2*t);

% Function-Kopf % Ableitungsfunktion

das @-Zeichen im Integratoraufruf odexx entfällt. Darüber hinaus werden keine Daten 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 ersetzt. 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 Gleichgewichtslage. 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 Drehdä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 Klemmspannung ue erreichen. Wir verfolgen hier den Weg über den Anfahrwiderstand RAN .

5.3 Integration von Systemen in Standardform

243

Bild 5.10: Fundament mit unwuchtigem Motor und Modell des Gleichstrommotors Tabelle 5.3: Systemparameter Masse Massenträgheitsmoment Federsteifigkeit Dämpfungskonstante Unwucht Induktivität Ankerkreiswiderstand Widerstand (Maximalwert) Widerstandsänderung bezogener Widerstand Zeitfenster der Widerst.-Änd. Spannung Momentenfaktor Drehdämpfung im Lager Erdbeschleunigung

5.3.1.1

m J k d emu LA RA R⋆A rA (t) rAmax th ue km dϕ g

= = = = = = = = = = = = = = =

m0 + mu = 100 kg 0,2 kg m2 2,25 106 N/m 225 Ns/m 0,05 m kg, 0,01 m kg 0,1 H 0,5 Ω, . . . 10 Ω RA + RAN = 200 Ω RA (1 + rAmax (1 − t/th )) RAN /RA 40 s 200 V 1 Nm/A 225 10−5 Nms/rad 9,81 m/s2

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)

˙ ΔrA (t) Widerstandsänderung. LA (iA )˙+ RA (1 + ΔrA (t))iA = ue − km ϕ,

(5.27)

Dies ist ein nichtlineares Differenzialgleichungssystem 5. Ordnung für x(t), ϕ(t), iA (t).

244

5 Simulation unter MATLAB

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 Differenzialgleichungen zweiter Ordnung für x(t), ϕ(t) sowie einer linearen Differenzialgleichung erster Ordnung 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 2δ = d/m; ω02 = k/m; 2δϕ = dϕ /J; mx = 1 −

(mu e)2 cos2 ϕ mJ

ein und eliminieren in der ersten Gleichung ϕ¨ mit Hilfe der zweiten Gleichung. Danach erhalten wir für die ersten beiden Gleichungen    mu e mu e km 1 2 2 ˙ ˙ {−2δ x˙ − ω0 x + g cos ϕ − iA cos ϕ + ϕ sin ϕ } 2δϕ ϕ + x¨ = mx m J J mu e km (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 Zustandsvariablen des Zustandsvektors: ϕ¨ = −2δϕ ϕ˙ −

˙ iA )T , ˙ ϕ, y = (y1 , y2 , y3 , y4 , y5 )T = (x, ϕ, x, so folgt die für die numerische Integration erforderliche Standardform:

5.3 Integration von Systemen in Standardform

245

y˙1 = y3 y˙2 = y4 y˙3 = {−2δ y3 − ω02 y1 +    mu e km mu e g cos y2 − y5 cos y2 + y24 sin y2 }/mx 2δϕ y4 + m J J mu e km (y˙3 + g) cos y2 + y5 y˙4 = −2δϕ y4 − J J RA km 1 y˙5 = − (1 + ΔrA (t))y5 − y4 + ue LA LA LA

(5.28)

2

u e) cos 2 y2 . Für einen Anfahrvorgang über die bezogene Widermit der Abkürzung mx = 1 − (mmJ standsänderung ΔrA (t) setzen wir  für t ≤ th rAmax (1 − tt ) h ΔrA (t) = 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 p1 = p5 =

d m = 2δ mu e J ,

,

p2 = p6 =

k 2 m =ω , km J ,

p3 = p8 =

dϕ J km LA

= 2δϕ ,

p4 =

,

p9 =

mu e m 1 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 Parametrierung 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 % ---- Parameter m =100; mue=0.05; k=2.25e+06; d=225; ............ ue=200; th=40

ue LA RA rAmax th

% % % %

Masse kg Unwucht kgm Federst. N/m Dämpfung Ns/m

% Klemmspannung % Hochfahrzeit

V

246

5 Simulation unter MATLAB

% ---- 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 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 Beschleunigungsebene 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 Instabilitäten, so genannte Drift-Effekte, in Index-1-Problemen auf, bei denen die Bindungen auf Beschleunigungsebene 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 StabilisierungsMethoden [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 nochmalige 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 Bindungsgleichung (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.

260

5 Simulation unter MATLAB

Übungsvorschlag: Durch Differenziation der Bindungsgleichung in (5.52) erhält man eine Differenzialgleichung für λ˙ , so dass insgesamt ein gewöhnliches Differenzialgleichungssystem vorliegt. Erstellen Sie hierfür ein Simulink-Modell sowie ein Scriptfile und vergleichen Sie die erhaltenen 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 M p¨ = f (pp, p˙ , t) + G T (pp, t) λ ,

G (pp, t) =

∂gg(pp, t) ∂qq

(5.55)

0 = G (pp, t) p¨ +γγ (pp, p˙ , t) . Mit (5.55) und v = p˙ erhalten wir unmittelbar ein für die numerische Vorgehensweise bedingt geeignetes Gleichungssystem vom Index 1 ⎡ ⎤⎡ ⎤ ⎡ ⎤ E 0 0 p˙ v ⎣ 0 M G T ⎦ ⎣ v˙ ⎦ = ⎣ f ⎦ , v = p˙ , E Einheitsmatrix . (5.56) λ −λ −γγ 0 G 0

Falls die Massenmatrix M positiv definit ist und die Bindungen unabhängig sind, d. h. die JACOBIMatrix 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 Anfangsbedingungen 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. Momentenbezug ü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   G Tλ , Gv˙ = GM −1 f +G

5.4 Differenzial-algebraische Gleichungen

261

so dass wir mit (5.55)2 GM −1G Tλ = −γγ GM −1 f +GM finden. Dabei ist GM −1G T regulär, wenn G den vollen Rang besitzt, so dass wir nach λ auflösen können: −1    GM −1 f . γ +G (5.57) λ = − GM −1G T

Setzen wir nun λ in die Ausgangsgleichung (5.55)1 ein, dann ergibt sich das explizite gewöhnliche Differenzialgleichungssystem (Index 0) p˙ = v   Pγ }, PGM −1 f −P v˙ = M −1 { E −PGM

−1  P = G T GM −1G T

(5.58)

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 ∂φφ ∂ ∂ ... GM −1G Tλ +φφ ) p˙ + (GM GM −1G Tλ +φφ ) = 0 p¨ + (GM g = GM −1G Tλ˙ + ∂ p˙ ∂p ∂t

(5.59)

mit φ = GM −1 f +γγ und damit das gewöhnliche Differenzialgleichungssystem vom Index 0 ⎡

E ⎣ 0 0

0 M

0 0

∂φφ ∂ p˙

GM −1G T

⎤⎡

⎤ ⎤ ⎡ v p˙ T ⎦ ⎣ v˙ ⎦ = ⎣ f +G ⎦ , (5.60) G λ ∂ GM −1 T ∂ −1 T ˙ GM G λ +φφ ) − ∂ p (GM G λ +φφ )p˙ − ∂t (GM λ

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 SimMechanics verfolgt werden. Der Aufwand insbesondere in (5.60) steigt erheblich. Die zeitlichen Ableitungen 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˙ = 0 , g¨ = 0 mit der MATLAB Function decic aus Abschn. 5.5 iterativ berechnet werden. Dabei sind einige Komponenten von p(0), 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 Bemerkungen zu finden.

262

5 Simulation unter MATLAB

Beispiel 5.8: Anwendung auf ein Kurbeltrieb Die Vorgehensweise bezüglich der Elimination von λ wenden wir auf den Schubkurbeltrieb 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 Schleifensystem entspricht dem des Doppelpendels. Die Bewegungsgleichungen lassen sich mit den Methoden aus Kapitel 2 herleiten. Wir erhalten M (qq)¨q +kk (qq, q˙ ) = h (qq)

(5.61)

mit der Massenmatrix   −m2 ℓ1 ℓ2 cos (α + β ) (m1 + m2 )ℓ21 M= −m2 ℓ1 ℓ2 cos (α + β ) m2 ℓ22 und den Vektoren   m2 ℓ1 ℓ2 β˙ 2 sin (α + β ) k= ; m2 ℓ1 ℓ2 α˙ 2 sin (α + β )

h=



−(m1 + m2 )gℓ1 sin α −m2 gℓ2 sin β

(5.62)



(5.63)

sowie dem Koordinatenvektor q T = (α, β ),

Minimalkoordinaten für das Doppelpendel.

(5.64)

Da der Schubkurbeltrieb nur einen Freiheitsgrad hat, führen wir mit α, β redundante Koordinaten p T = [α, β ] ein. Dies ist mit der zusätzlichen holonomen SchleifenSchließbedingung s = 0 nach Bild 5.17 (Zwangsbedingung, Bindung), der algebraischen 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

5.4 Differenzial-algebraische Gleichungen

β , z. B. durch Elimination von β , in die Bewegungsgleichung ein. Es folgt eine 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

p = (α, β )T

(5.66)

der Schließbedingung mittels L AGRANGEschem Multiplikator λ (im Allgemeinen Vektoren), der die Reaktionskräfte im geschnittenen Gelenk berücksichtigt, (5.61) hinzu und beachtet die Index-1-Bedingung, so dass GT (pp) λ = h (pp) M (pp)p¨ +kk (pp, p˙ ) −G

(5.67) ∂ γ= p

G (pp)p¨ = −γ(pp, p˙ ),



 ∂ g(pp) p˙ p˙ ∂p

(5.68)

folgt. Die zulässigen Anfangswerte p 0 , p˙ 0 , λ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 behandeln. Dafür bieten sich die Formulierungen (5.56), (5.58) und (5.60) an, wobei ˙ = α˙ 0 , wir hier (5.58) programmieren. Die Anfangswerte α(0) = α0 , β (0) = β0 , α(0) β˙ (0) = β˙0 müssen die beiden Bindungsgleichungen 0 = g(pp0 ) = ℓ1 sin α0 − ℓ2 sin β0 0 = G T (pp0 ) p˙ 0 = [ℓ1 cos α0 , −ℓ2 cos β0 ]



α˙ 0 β˙0



erfüllen. Geben wir α0 und α˙ 0 vor, dann genügen β0 und β˙0 den Bedingungen β0 = arcsin(

ℓ1 sin α0 ), ℓ2

ℓ1 cos α0 β˙0 = α˙ 0 . ℓ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

263

264

5 Simulation unter MATLAB

Hauptprogramm:

DAE_K.m zu IST=3

t0=0; te=pi; a0=pi/4; b0=asin(l1/l2*sin(a0)); ap0=12.59995; bp0=l1/l2*ap0*cos(a0)/cos(b0); y0=[a0; b0; ap0; bp0]; ode45(@fdae_k,[t0 te],y0)

% % % % % % %

Anfangs-, Endzeitpunkt Anfangswerte: a0:=α(0) bo:= β (0) ˙ ap0:=α(0) bp0:=β˙ (0) Anfangswertvektor 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) lautet mit γ = −ℓ1 sin α α˙ 2 + ℓ2 sin β β˙ 2 : Function: fdae_k.m zu IST=3 function [yp] = fdae_k(t,y) global m1 m2 l1 l2 g cab=cos(y(1)+y(2)); sab=sin(y(1)+y(2)); M=[(m1+m2)*l1ˆ2 -m2*l1*l2*cab; -m2*l1*l2*cab m2*l2ˆ2]; k=[m2*l1*l2*y(4)ˆ2*sab; m2*l1*l2*y(3)ˆ2*sab]; h=[-(m1+m2)*g*l1*sin(y(1)); -m2*g*l2*sin(y(2))]; G=[l1*cos(y(1))-l2*cos(y(2))]; gam=l2*y(4)ˆ2*sin(y(2))... -l1*y(3)ˆ2*sin(y(1)); M_1=inv(M); P=G’*inv(G*M_1*G’); yp=[y(3:4); M_1*((eye(2)- ... P*G*M_1)*(h-k)-P*gam)];

% y:=[p’,v’]’

% Abkürzungen % Massenmatrix % k-Vektor % h-Vektor % Bindungs-JACOBI-Matrix % % % % %

gam:=γ Inverse von M Abkürzung Ableitungsfunktion (5.58)

In DAE_K.m aus [52] sind die hier vorgestellten Wege programmiert. Sie sind mit dem Steuerparameter IST auszuwählen: IST = 1: M ⋆ y˙ = f (yy), (5.56), IST = 3: (5.58), λ eliminiert,

−1

IST = 2: y˙ = M ⋆

f (yy), (5.56) IST = 4: gew. Dgl. (5.60) mit λ˙ .

In Bild 5.18 ist ein Ergebnis dargestellt. Danach läuft infolge der vorgegebenen An˙ Kurbel und fangswerte die Kurbel um, wobei im unteren Totpunkt aufgrund von α(0) ˙ β˙ und die Animation mit Kurbel_q0.m Pleuel nahezu zur Ruhe kommen, vgl. α, ˙ β˙ maximal. Hierzu gein [52]. Beim Durchgang der oberen Totpunktlage sind α, hört auch eine starke Änderung der Normalkraft (λ ) am Gleitschuh. Weitere Beispielrechnungen zeigen wieder Drift-Effekte, wenn mit ’RelTol’,10e-04 gerechnet wird. Die Bindungsgleichungen werden mit fortschreitender Zeit immer schlechter 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.

5.4 Differenzial-algebraische Gleichungen

265

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 eingehalten 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 diese zurückgeführt. Bezogen auf die Index-1-DAE (5.42) mit holonomen skleronomen Bindungen bedeutet dies:

266

5 Simulation unter MATLAB

p˙ = v GT (pp) λ M (pp)˙v = f (pp, v , t) +G 0 = G (pp)˙v + γ (t, v , p ) +2d G (pp)vv + ω 2g (pp) .       g¨

(5.69)

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: 1.

2 p k+1 − p Pk+1 = → min, g (ppk+1 ) = 0



2.

2  v k+1 −vvPk+1 = → min 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 Ordnung, verursachen aber bei der Lösung ohne zusätzliche Stabilisierung einige numerische Probleme. Man wird deshalb versuchen, durch Einführen f unabhängiger Koordinaten (Minimalkoordinaten) q und Elimination der Reaktionskräfte/momente G Tλ auf gewöhnliche Differenzialgleichungen 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 Lagekoordinaten 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:

5.4 Differenzial-algebraische Gleichungen

p = p (qq, t) ∂ p (qq, t) ∂ p (qq, t) ∂ p (qq, t) q˙ + = J (pp(qq, t)) q˙ + p˙ = ∂qq ∂t ∂t 2 p (q q ∂ ∂ 2 p (qq, t) , t) p¨ = J (pp(qq, t)) q¨ + J˙(pp(qq, t)) q˙ + q˙ + , ∂qq∂t ∂t 2

267

(5.72)

vgl. Kapitel 2 und insbesondere Abschn. 2.3.1.3. Sind die Bindungen g (pp) skleronom, dann entfallen 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) T T ˙ M J q˙ + q˙ + (5.73) J M J q¨ = J + J TG Tλ . f (qq, q˙ , t) −M ∂qq∂t ∂t 2 GJ Die Bindungskräfte/momente werden wegen (GJ GJ)T = J TG T = 0 ausgeblendet, es bleibt: Mq q¨ = f q (qq, q˙ , t)

(5.74)

mit T

Mq = J M J ,



∂ 2 p (qq, t) ∂ 2 p (qq, t) f q = J f (qq, q˙ , t) −JJ M J˙q˙ + q˙ + ∂qq∂t ∂t 2 T

T



.

Bei baumstrukturierten Systemen, wie Einfach- und Doppelpendel, lassen sich explizite Bindungen (5.72) auswerten. Bei Schleifensystemen, z. B. Kurbelsystem nach Bild 5.17, ist der Übergang 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 Balancierender 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 ϕ , (5.75) p (ϕ) = −L cos ϕ womit sich die JACOBI-Matrix (hier Spaltenvektor) zu   ∂ p (ϕ) L cos ϕ J (ϕ) = = L sin ϕ ∂ϕ

(5.76)

268

5 Simulation unter MATLAB

berechnet. Aus (5.46)2 folgt mit (5.73) unmittelbar mL2 ϕ¨ = −mgr L sin ϕ

→

ϕ¨ = −

gr sin ϕ . L

(5.77)

Ü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 Winkelgeschwindigkeit Ω rotierenden Stab (Lände L) angekoppelt. An den Pendelkörpern soll der Luftwiderstand (Ansatz nach Abschn. 5.6.4.1) berücksichtigt werden. • Für beide Systeme mit rheonomen Bindungen sind die Bewegungsgleichungen für die verallgemeinerten Koordinaten p = [x, y]T bzw. p = [x, y, φ ]T aufzustellen und numerisch auszuwerten. • Wie lauten die Minimalkoordinaten und die zugehörigen Bewegungsgleichungen? • Warum eignet sich das Pendelmodell zum drehzahladaptiven Drehschwingungstilger? Betrachte 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 zusätzliche/ausschließliche nichtholonome Bindungen, sie gehören zu den kinematischen Bindungen, auftreten. Holonome Bindungen schränken die Bewegungsfreiheit von Lagegrößen und Geschwindigkeitsgrößen, nichtholonome Bindungen nur die Geschwindigkeitsgrößen ein. Mechanische 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 Freiheitsgraden und r holonomen sowie s nichtholonomen Bindungen reduziert sich auf f = 6N − r − s.

(5.78)

5.4 Differenzial-algebraische Gleichungen

269

Die s nichtholonomen (Index nh) skleronomen und/oder rheonom Bindungen sind implizit durch die nichtintegrierbare s × 1 Vektorgleichung g˙ nh (pp, p˙ ) = 0

bzw.

g˙ nh (pp, p˙ , t)

(5.79)

mit den redundanten bzw. verallgemeinerten Koordinaten p p˙ beschrieben. Die r holonomen (Index h) Bindungen formulieren wir hier auf Geschwindigkeitsebene g˙ h (pp, p˙ ) = 0

bzw.

g˙ h (pp, p˙ , t).

Holonome und nichtholonome Bindungen werden vektoriell zu ⎡ ⎤   ∂ggh ∂ggh (pp, t) g˙ h (pp, p˙ , t) ˙ p + g˙ = =⎣ ∂p ∂t ⎦ g˙ nh (pp, p˙ , t) g˙ nh (pp, p˙ , t)

(5.80)

(5.81)

zusammengefasst und damit die JACOBI-Matrix der Bindungen ⎡ ∂gg (pp, t) ⎤ h ∂ g˙ ⎢ ⎥ = ⎣ ∂∂g˙p G = ⎦ ∂ p˙ nh ∂ p˙

(5.82)

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˙ durch die Minimalkoordinaten q , q˙ ausdrücken, dann gilt p˙ = p˙ (qq, q˙ , t) ∂ p˙ ∂ p˙ ∂ p˙ q˙ + q¨ + p¨ = ∂ q˙ ∂qq ∂t ∂ p˙ = J q p q¨ + J q q˙ + . ∂t

(5.83)

Setzen wir dies in die zugehörige Bewegungsgleichung λ + Q nk M (pp)p¨ = f (pp, p˙ , t) + G T (pp, p˙ )λ

(5.84)

ein und multiplizieren von links mit J qTp durch, dann folgt     ∂ p˙ J qTp M (qq) J q p q¨ + J q q˙ + − f (qq, q˙ , t) = J qTp G T λ + J qTp Q nk ∂t

(5.85)

wobei J qTp G T = 0 wieder verschwindet – die Zwangskräfte stehen senkrecht auf der Geschwindigkeitsebene. Der Term Q nk enthält alle nichtkonservativen Kräfte/Momente, einschließlich solcher aus einem Regeleingriff, vgl. Balancierender Roboter in Abschn. 8.8.

270

5 Simulation unter MATLAB

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 Ebene 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 Bewegung 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. Abschn. 2.3.1.1. Damit lauten die verallgemeinerten Koordinaten und deren zeitlichen Ableitungen der freien Kugel p = [I xS , I yS , I zS , α, β , γ]T ,

p˙ =



I x˙S , I y˙S , I z˙S ,

˙ β˙ , γ˙ α,

T

.

(5.86)

Die Anbindung der Kugel an die Rollebene erfolgt durch die holonomen, skleronomen Bindung !

gh = I zS − R = 0. Nach (2.24) gilt für die verallgemeinerte Geschwindigkeiten ⎤ ⎡ ⎡ ⎤ α˙  α˙  T T T ˙ ˙ Iω = e1, Tα e2, Tα Tβ e3 ⎣ β ⎦ = H R ⎣ β ⎦ . γ˙ γ˙

(5.87)

(5.88)

5.4 Differenzial-algebraische Gleichungen

Die Rollbedingung ist erfüllt, wenn die Geschwindigkeit der freien Kugel in P ⎡ ⎡ ⎡ ⎤ ⎤ ⎤ 0 0 I x˙S ! ⎣ ⎣ ⎣ ⎦ ⎦ ˙ y ˙ 0 0 ⎦ r = ω × = + I S I I 0P (5.89) z ˙ −R 0 I S ! = I v S + I ω˜ I r SP = 0

verschwindet. Dies sind zusätzliche nichtholonome Bindungen g˙ nh (pp, 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 Gleichungen 1. Art (5.35) in der symbolisch auswertbaren Form ∂ ∂ p˙



∂T ∂ p˙

      T   ∂T T ∂V T ∂ ∂T T ∂T T ∂ p¨ + p˙ − + + = G Tλ (5.91) ∂ p ∂ p˙ ∂p ∂p ∂t ∂ 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˙ α,

q = [α, β , γ]T ,

(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 f (qq, q˙ ) =

M −1 q fq

"

β˙ (γ˙ − α˙ sin β ) β˙ (α˙ − γ˙ sin β ) , α˙ γ˙ cos β , − = − cos β cos β

#T

der Bewegungsgleichung q¨ = f (qq, 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   ˙ = H R q¨ + H˙ R q˙ → q¨ = H −1 ˙ − H˙ Rq˙ , (5.94) Iω Iω R

271

272

5 Simulation unter MATLAB

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 Systemparametern 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 Iω

 T ˙ ϑ˙ , = ζ˙ , η,

(5.97)

dann gilt für die Rollbedingungen bzw. Bindungen I x˙

˙ = −Rη,

I y˙

= Rζ˙ ,

(5.98)

= Rζ

(5.99)

die nun integrierbar sind Ix

= −Rη,

Iy

und somit im Gegensatz zur vorangegangenen Betrachtung (5.95) holonome Bindungen sind. Diese speziellen Vereinfachungen der Bewegungsgleichungen eines starren Körpers 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 Gleichungen vom Index 1 f (t, y˙ , y ) = 0

(5.100)

ausgehend von konsistenten Anfangswerten y 0 , y˙ 0 zum Zeitpunkt t0 , d. h. sie erfüllen f (t0 , y˙ 0 , y 0 ) = 0 ,

y˙ 0 = y˙ (t0 ),

y 0 = y (t0 ) .

(5.101)

Die Berechnung konsistenter Anfangswerte führt in der Regel auf nichtlineare algebraische Gleichungen. Meist wird man einige Komponenten von y˙ 0 , 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˙ 0mod , y 0mod ) ≈ 0 . Die festgeschriebenen Komponenten von y˙ 0 , y0 sind mit fixed_y0(i)=1 und/oder fixed_yp0(i)=1, die übrigen mit 0 zu kennzeichnen. Mit fixed_y0=[ ] werden alle Komponenten 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 Einmassenschwingers 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, my˙3 + k(y1 − y2 ) + mg = 0 y˙2 (d |y˙2 | + d0 ) + k0 y2 − k(y1 − y2 ) = 0 .

y = [y1 , y2 , y3 ]T = [x, s, x] ˙T (5.102)

Dies ist eine implizite Differenzialgleichung 3. Ordnung. Wir gehen davon aus, dass die Anfangswerte y 0 = (y1 (0), y2 (0), y3 (0))T gegeben seien, die Ableitungen y˙ 0 müssen dann so bestimmt werden, dass sie (5.102) genügen. Ausgehend von der Function der Differenzialgleichungen (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) gewä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 -0.0981 10.0000

yp0 = 10.0000 -0.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

274

5 Simulation unter MATLAB

nicht analytisch angebbar sind. Wir berechnen sie für das Beispiel: ⎤ ⎡ ⎤ ⎡ 1 0 0 0 0 −1 ∂f ∂ f 0 m ⎦ . −k 0 ⎦, Jy = =⎣ 0 J y˙ = =⎣ k ∂yy ∂ y˙ 0 d0 + 2d|y˙2 | 0 −k k0 + k 0

(5.103)

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 Parameter 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) y10 = x0 = −mg

k0 + k ; k0 k

y20 = s0 = −

mg ; k0

y30 = 0

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 Kurbeltriebs (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 Komponenten 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 Diodenmodell in Bild 5.23 aus [45] verdeutlichen soll. Allerdings erhöht sich der Aufwand zur Parameterermittlung solch sehr genauer Modellelemente erheblich. Darüber hinaus ist mit wesentlich längeren Rechenzeiten zu rechnen, da die Integratoren zur Simulation dieser Modellkomponenten, z. B. mit sehr steilen Kennlinien und zusätzlichen Dynamikanteilen, mit sehr kleinen Schrittweiten 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 Unstetigkeiten unter MATLAB und Simulink gelöst werden können. 5.6.1

Beispiele für Unstetigkeiten in den Bewegungsgleichungen

Wir betrachten Differenzialgleichung 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.

276

5 Simulation unter MATLAB

Typische Elemente, die zu Unstetigkeiten, insbesondere in den Zustandsgrößen eines dynamischen 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. progressive 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 unproblematisch, 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 Schaltfunktionen parallel zur Integration ermittelt und ausgewertet werden. In der Praxis werden Systeme mit Unstetigkeiten vielfach ohne dessen Lokalisierung bearbeitet; 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 Zeitabschnitten 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 schrittweitengesteuerten 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. Insbesondere 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 Intervalle angepasst werden. Wir wollen hier die Formulierung der Schaltfunktion, mit der die Bewegungsgleichungen 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.

5.6 Integration gewöhnlicher Differenzialgleichungen mit Unstetigkeiten

277

−3

x 10 2

0.06

1

0.02

vrel [m/s]

vrel [m/s]

0.04

0

−0.02

−1

−0.04 −0.06 −0.08

0

−2 0

0.2

0.4 0.6 Zeit t[s]

0.8

1

0.28

0.3

0.32 Zeit t[s]

0.34

0.36

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, bekannt 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 Schaltkoeffizienten sk T   T s = s1 , s2 , . . . , snq = sign(q1 ), sign(q2 ), . . . , sign(qnq ) ,

(5.106)

y˙ (t) = f (t, y (t), s ).

(5.107)

der bei einer Zweipunkt-Schaltlogik nur die Zustände s j = ±1 annimmt, ein, dann hat die Bewegungsgleichung (5.104) die Form

Elemente der Schaltfunktion können einfache Zeitfunktionen     t − t1 q1 (t) = q (t) = t − t2 q2 (t)

(5.108)

mit den Zeitereignissen zu den Zeitpunkten t1 , t2 oder vom Zustand abhängig sein, wie in y˙ = |y|, wofür wir  y für s = sign q = 1 y˙ = −y für s = sign q = −1

(5.109)

mit q(t, y) = y, → y˙ = s y

(5.110)

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-

278

5 Simulation unter MATLAB

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 Schaltfunktion 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 Nullstellensuche. 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 Vorgehensweisen, die auf einer einfachen Nullstellensuche mit anschließender Intervallverkleinerung basieren. Die Methode muss sicherstellen, dass ein erfolgreicher Neustart nach der Unstetigkeitsstelle 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

5.6 Integration gewöhnlicher Differenzialgleichungen mit Unstetigkeiten

279

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-Schaltlogik. 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 Bewegungsgleichungen einarbeiten. Das Ereignis wird unter MATLAB der Nullstelle zum approximierten 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 Abwurfhöhe Abwurfwinkel

v0 = 25 m/sec h=1m α = 15°

Ballgeschwindigkeit Widerstandsbeiwert Stoßfaktor

 v = (x˙2 + y˙2 ) cw =0,01 ε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.

280

5 Simulation unter MATLAB

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.

5.6 Integration gewöhnlicher Differenzialgleichungen mit Unstetigkeiten

281

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 gekoppelt, 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 Nulldurchgang zum Zeitpunkt τ ⋆ gestoppt wird. Der Abprall entspricht einem Neustart in τ ⋆ mit veränderter Geschwindigkeitskomponente

y˙+ (τ ⋆ ) = −0,9 y˙− (τ ⋆ ),

εs = 0,9 Stoßfaktor.

282

5 Simulation unter MATLAB

D. h. y˙+ (τ ⋆ ) muss auf den IC Block8 , der im Anfangszustand den eingestellten, später den angelegten 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 Amplituden 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 Auftreffen. 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ückgegriffen wird. Darüber hinaus sind die Steuerparameter:  1 Abbruch bei Nullstelle isterminal = 0 kein Abbruch ⎧ Nullstellensuche bei steigender Funktion q(t) ⎨ 1 0 Nullstellensuche in jedem Fall direction = ⎩ −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 ersten Nullstelle q(τ ⋆ ) ≈ 0 ab. Ergänzend zur bisherigen Betrachtung, der Detektierung des Auftreffpunkts 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 iE = 2 3 1

Zeit t tE = 5.0347e-001 1.0839e+000 1.2680e+000

x yE = 9.4602e+000 1.6649e+001 1.8455e+001

y 2.4671e+000 1.0000e+000 -1.1102e-016

x˙

y˙

1.4941e+001 1.0321e+001 9.3081e+000

-1.0880e-014 -4.7998e+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

5.6 Integration gewöhnlicher Differenzialgleichungen mit Unstetigkeiten

283

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 (direction) 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 Ereignisse ü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);

284

5 Simulation unter MATLAB

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 Tabelle 5.6: Systemparameter Masse Steifigkeit Steifigkeit Steifigk.-Koeff.

m k1 k2 = αk1 α

5,0 kg 981 N/m 300 . . . 3000

Dämpfung Erregeramplitude Erregerkreisfr. Schaltpunkt

d Q Ω xs

k1 /100 = 9,81 N s/m 400 N 20 rad/s 0,04 m

Für den Einmassenschwinger mit stückweise linearer Federkennlinie soll das Aufsetzen der Masse auf die zweite Feder (k2 = αk1 ) am Ort |x| = xs über eine Schaltfunktion formuliert und die

5.6 Integration gewöhnlicher Differenzialgleichungen mit Unstetigkeiten

285

Simulation mit Nullstellensuche durchführt werden. Die zugehörige Bewegungsgleichung lautet (5.116)

mx¨ + d x˙ + f (x) = m g + Q cos Ωt mit der stückweise linearen Federkraft  k1 x für f (x) = k1 x + k1 α(x − xs sign(x)) für

− xs ≤ x ≤ xs − xs > x > xs ,

(5.117)

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ätzlichen 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

0.05

0.1

0.15

0.2

0.25

−0.05

0

q = x − xs sign(x)

0.05

0.1

0.15

0.2

0.25

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 = k1 x + 0,5(1 + s)k1 α sign(x)(|x| − xs ) ;

(5.118)

es liegt ein Zwei-Punkt-Schaltproblem vor. Numerische Vorgehensweise und Programmcodes Die Bewegungsgleichungen sind stückweise linear, so dass wir diese mit analytischen Methoden 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,

286

5 Simulation unter MATLAB

ist gewährleistet, dass selbst kurz aufeinanderfolgende Nullstellen gefunden werden. Die Umschaltung organisieren wir einfachheitshalber im Hauptprogramm schaltp.m über den Schaltkoeffizienten 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 vereinbart 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: k1: alpha: d: xs: Q: OM:

5 981 3000 9.8100e+000 4.0000e-002 0 20

Im Folgenden ist das verkürzte Hauptprogramm schaltp.m sowie die Function der Differenzialgleichung fschaltp.m und die der Schaltfunktion q eschaltp.m mit dem Zustandsvektor 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,:)];

5.6 Integration gewöhnlicher Differenzialgleichungen mit Unstetigkeiten

287

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] q =abs(y(1))-p.xs; isterminal= 1; direction= -s;

= % % %

eschaltp(t,y,p,s) Schaltfunktion Stopp nach Nullstelle 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änderungen x(t) ˙ sowie die kurz aufeinanderfolgenden Nullstellen von q zum Ausdruck. Bild 5.32 a T = (0, 2)T , ˙ zeigt die freien Schwingungen zu α = 3000 und den Anfangswerten (x(0), x(0)) 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

288

5 Simulation unter MATLAB

Ü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 d1 = d2 = 0,981 Ns/m

k1 = k2 = 981 N/m  Ω = 0,7,... 2,0 k1 /m1

kk1 = kk2 = 500 k1 ∆ − 2ℓ0 = 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 Intervallrand der Nullstellensuche τ ⋆ −Δτ (Δτ μ |vrel | = 0 μ0 − μ b>0 II: μ(|vrel |) = + μ, (5.120) 1 + b |vrel | μ0 − μ + μ + a|vrel |2 , b > 0, a > 0 . III: μ(|vrel |) = 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 diesen 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 + k2 tanh( rel ) k4 |vrel |2 + k3 Reibkraftverlauf mit: k1 = 0,56, k2 = 0,3, k3 = 0,001, k4 = 0,5 fR = k1

5.6.5.2

Bild 5.34: Stetiger Reibkraftverlauf

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 Umgebung gekoppelt. Die Masse m2 bewegt sich reibungsfrei auf der Unterlage. Zwischen den Massen 9 Untersuchung mit Fünfpunkt-Schaltlogik vgl. [23]

5.6 Integration gewöhnlicher Differenzialgleichungen mit Unstetigkeiten

rauh (µ , µ0 )

x1 ✲

x2 ✲

m1

k1 s

m2

k2

f1 (t)

Reibmodell (C OULOMB) fR ✻

✲

s

291

✲

✲ f2 (t)

vrel

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 m2 x¨2 + k2 x2 = f2 (t) + fR .

(5.121)

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 );

(5.122)

f N = m1 g

und somit die Bewegungsgleichungen m1 x¨1 + k1 x1 = f1 (t) − μ fN sign(q) m2 x¨2 + k2 x2 = f2 (t) + μ fN sign(q)

(5.123)

mit der Schaltfunktion q, die der Relativgeschwindigkeit in den Kontaktpunkten der beiden Massen 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 ⎡ ⎤ 1 k1 ⎤ ⎡ μ f s) x + ( f (t) − − N x¨1 ⎢ m1 1 m1 1 ⎥ ⎥ ⎦=⎢ ⎣ (5.125) ⎢ ⎥ ; s = sign(q) ⎣ ⎦ k2 1 x¨2 − x2 + ( f2 (t) + μ fN s) m2 m2 oder kurz

x¨ = f (t, x˙ , x, s) =



f + (t, x˙ , x ) f − (t, x˙ , x )

für s = 1 , für s = −1

mit x = (x1 , x2 )T

(5.126)

292

5 Simulation unter MATLAB

zu schreiben. Verschwindet die Relativgeschwindigkeit zwischen den Massen, dann liegt Haftung vor und es gilt das Reibgesetz (5.127)

| f R0 | < μ 0 f N .

Beide Massen bewegen sich mit x¨1 = x¨2 und x˙1 = x˙2 , so dass aus (5.121) die Bewegungsgleichungen (m1 + m2 )x¨1 + k1 x1 + k2 x2 = f1 (t) + f2 (t) x¨2 = x¨1 ; x˙2 = x˙1

(5.128)

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 Bewegungsphasen: • Übergang von einer Bewegung mit positiver Relativgeschwindigkeit (s = 1) in eine Bewegung mit negativer Relativgeschwindigkeit (s = −1) und in umgekehrter Reihenfolge; Annahme: Durchschwingen ohne Haftung. • Übergang von einer Bewegung mit positiver Relativgeschwindigkeit (s = 1) in den Haftreibungsbereich und umgekehrt. • Übergang von einer Bewegung mit negativer Relativgeschwindigkeit (s = −1) in den Haftreibungsbereich und umgekehrt. D. h. es muss zwischen diesen drei Zuständen hin und her geschaltet werden. Um diese einzelnen Phasen gezielt anzusteuern, führen wir, wie in [15], Hilfs-Schaltfunktionen ein, die auf der zeitlichen Ableitung von q, also dq = qx˙ x¨ + qt = qx˙ f + qt dt

für q = q(t, x˙ ), hier: qt = 0

(5.129)

aufbauen. (5.129) ist hier die Relativbeschleunigung. Mit den hieraus abzuleitenden Hilfs-Schaltfunktionen 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˙ f + 0 + qt S− = qx˙ f − 0 + qt

(5.130)

5.6 Integration gewöhnlicher Differenzialgleichungen mit Unstetigkeiten

293

einführen, wobei sich f ± 0 aus der rechten Seite von (5.125) ergibt, wenn wir für μ den Haftreibungskoeffizienten μ0 setzen ⎤ ⎡ k1 1 − x1 + ( f1 (t) ∓ μ0 fN ) ⎥ ⎢ m1 m1 ⎥ ⎢ f± (5.131) 0 = ⎣ ⎦ 1 k2 ( f2 (t) ± μ0 fN ) − x2 + 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

✻

q

S+

❙ ❅ ◗ ❳ ③ ❘ ◗ s ❳ ✇ ❙ ❅ ✼ ✣ ✓ ✼ ✒ ✡ ✓ ✓ ✡ ✓

✲

t

S− Bild 5.36: Richtungsfeld

wir an, für t = t ⋆ gilt q(t ⋆ , 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 Haftreibung 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 Interpretation findet man bereits in [33]. Damit können wir die Schaltbedingungen mittels der HilfsSchaltfunktionen 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 andere 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)

294

5 Simulation unter MATLAB

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 ( f1 (t) − μ fN s − k1 x1 ) m1 1 ( f2 (t) + μ fN s − k2 x2 ) x¨2 = m2 1 ( f1 (t) + f2 (t) − k1 x1 − k2 x2 ) x¨1 = x¨2 = m1 + m2 x¨1 =

für s = ±1

(5.135)

für s = 0

für das einfache Reibschwingungsproblem zugrunde, es ist ein strukturvariables System. Die Hilfs-Schaltfunktionen S± ergeben sich mit (5.130) zu S± =

1 1 ( f1 (t) ∓ m1 gμ0 − k1 x1 ) − ( f2 (t) ± m1 gμ0 − k2 x2 ) , m1 m2

(5.136)

sie sind für q = 0 auszuwerten. Die zugehörige Dreipunkt-Schaltlogik ist in Bild 5.37 zusammengefasst. ★✥

q = 0 ∧ S− ≤ 0

s=1 ✛ + ✧✦ ■ q=0 ∧ S ≥0

q=0∧ S+ < 0 ∧ S − > 0

S+ = 0 S− = 0

★✥ ✠ ❘

✲

★✥ s = −1

✒✧✦

q=0∧ S+ < 0 ∧ S − > 0

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 anschaulich 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

5.6 Integration gewöhnlicher Differenzialgleichungen mit Unstetigkeiten

295

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 x¨1 − x¨2 =

1 m1 + m2 1 ! ( f1 (t) − k1 x1 ) − ( f2 (t) − k2 x2 ) − fR0 = 0. m1 m2 m1 m2

(5.138)

Da nach (5.137) die Beschleunigungsdifferenz verschwindet, können wir nach der Haftkraft auflösen fR0 =

1 [m2 ( f1 (t) − k1 x1 ) − m1 ( f2 (t) − k2 x2 )] =: F(t), m1 + m2

(5.139)

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 Federkräften zusammen und ist unabhängig von den Beschleunigungen. Mit F(t) und der betragsmäßig größten Haftreibungskraft | fR0 | = μ0 fN lässt sich eine Kraftdifferenz, wie in Bild 5.38 dargestellt, bilden, die Aufschluss bezüglich der Fortsetzung der Bewegungszustände liefert. Nach f

✻

µ0 fN µ0 fN > F(t) ✻ F(t)

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äutern. 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¯−

s = 0 → s = −1,

296

5 Simulation unter MATLAB

wobei wir die Kraftdifferenzen entsprechend der in (5.136) eingeführten Hilfs-Schaltfunktionen 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änken 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 (Hauptprogramm), 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 Programmsammlung [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; y0=[0.; 0.;

0.; 0.];

% Startzeitpunkt % Anfangswerte

5.6 Integration gewöhnlicher Differenzialgleichungen mit Unstetigkeiten

297

Bild 5.39: Struktur des Programmpakets reib_12.m q=y0(3)-y0(4);

% Schaltfunktion (Relativgeschw.)

[sp,sm]=spm_12(t0,y0.’); if q == 0 ; if sm < 0 s=-1; elseif sp > 0 s=1; else s=0; end else if q < 0 s=-1; else s =1; end end

% Hilfs-Schaltfunktion für Start % Initialisierung zum Start

% sp < 0 & sm > 0

wobei Nullstellen von S± ausgeschlossen sind. Zur Integration benutzen wir das RUNGE -K UTTAVerfahren 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 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 Besonderheiten, so dass wir hier nur die Function der Ereignisermittlung angeben wollen. function [q,isterminal,direction] = ereib_12(t,y) if s==0 [sp,sm]=spm_12(t,y.’); q=[sp; sm]; isterminal= [1; 1]; direction= [0; 0]; else q=[y(3)-y(4)]; isterminal= 1; direction= -s; end

% % % % %

Schaltparameter Schaltfunktionen S+, SNullstelle von S+, SStopp nach Nullstelle Flanke

% Nullstelle der Relativgeschw. % Stopp nach Nullstelle % Flanke

Erläuterung: Liegt Haftung (s = 0) vor, dann ermitteln wir zunächst zu den aktuellen Werten 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 Schaltfunktion die Relativgeschwindigkeit an dem Reibkontakt. Da mit dieser Nullstelle das Durchschwingen (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 harmonischen 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 Einschwingvorgang zum Parametersatz des 1. Beispiels. In Bild 5.40 sind die Zeitverläufe der Aus-

5.6 Integration gewöhnlicher Differenzialgleichungen mit Unstetigkeiten

299

Tabelle 5.7: Beispiel-Parameter des Zwei-Massen-Reibschwingers mit einem Reibkontakt Beispiel Masse Masse Steifigkeit Steifigkeit Gleitreibkoeffizient Haftreibkoeffizient Erdbeschleunigung Erregerkraft Erregerkraft

m1 m2 k1 k2 μ μ0 g f1 f2

1

2

Einheit

1,0 1,5 10 10 0,040 0,080 9,81 5 sin t 0

1,0 1,5 10 10 0,04 0,06 9,81 sin t 2 cos (t + π4 )

kg kg N/m N/m – – m/s2 N N

lenkungen x1 (t) , x2 (t), der Geschwindigkeiten xp1 := x˙1 (t) , xp2 := x˙2 (t), der Relativgeschwindigkeit zwischen den Massen vrel = x˙1 − x˙2 und der Hilfs-Schaltfunktionen S+ , S− zusammengestellt. Man erkennt, dass die Haftreibungszeitabschnitte nur dann verlassen werden, wenn Nullstellen 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 Durchschwingen (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 Zeitabschnitte 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 vrel=xp1−xp2 [m/sec]

x1, x2 [m]

0.6

x1 x2

0.5

0

0.4 0.2 0

−0.2

−0.5

−0.4 −0.6

−1

0

2

4

6

8

10

−0.8

0

2

4

t [sec] Geschwindigkeiten

8

10

Hilfs−Schaltfunktionen

1

4 xp1 xp2

0.5

S+ S−

3 2 S+, S−

xp1, xp2 [m/sec]

6 t [sec]

0

1 0 −1

−0.5

−2 −1

0

2

4

6 t [sec]

8

10

−3

0

2

4

6

8

10

t [sec]

Bild 5.40: Beispiel 1: Zeitverläufe des Zwei-Massen-Reibschwingers mit einem Reibkontakt

300

5 Simulation unter MATLAB

einem Schaltprotokoll ausgehend von den Startwerten alle Ereignisfälle in Form des Schaltkoeffizienten 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 Anfangswerten 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 Anfangswerten, 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 Mehrfachumlauf (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 Phasenkurven x¨ j (x˙ j ), j = 1, 2 von Bild 5.422 . Zustandsübergänge zum Haften sowie Wechsel in der Gleitrichtung 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 Geschwindigkeiten 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 Tangentialkraft 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-Schwingungen. Das in Abschn. 4.4 behandelte 1/4-Fahrzeug mit Reibelement kann mit den hier besprochenen Methoden auch unter MATLAB gelöst werden. Hierzu dient das Programm reib_F.m der

5.6 Integration gewöhnlicher Differenzialgleichungen mit Unstetigkeiten Auslenkungen

Relativgeschwindigkeit 0.6

0.2

0.4

x1, x2 [m]

0.1 0

−0.1

vrel=xp1−xp2 [m/sec]

0.3

0.2 0

−0.2

−0.2

−0.4

x1 x2

−0.3 −0.4

0

2

4 t [sec]

6

8

−0.6 −0.8

0

2

Geschwindigkeiten

4 t [sec]

6

8

Hilfs−Schaltfunktionen

0.4

3 xp1 xp2

0.2

S+ S−

2 1 S+, S−

xp1, xp2 [m/sec]

301

0

0 −1

−0.2 −2 −0.4

0

2

4 t [sec]

6

−3

8

0

2

4 t [sec]

6

8

Bild 5.41: Beispiel 2: Periodische Schwingungen des Zwei-Massen-Schwingers mit einem Reibkontakt 0.4

1

m2 xpp1, xpp2

xp1, xp2

0.2

1.5

0

m1

0.5 m2

0

−0.5

−0.2 −1

m1 −0.4

−0.2

−0.1

0 x1, x2

0.1

0.2

0.3

−1.5 −0.4

−0.2

0 xp1, xp2

0.2

0.4

Bild 5.42: Beispiel 2: Phasendiagramme der periodischen Schwingungen des Zwei-MassenReibschwingers mit einem Reibkontakt

Programmsammlung [52], in das das Zeitereignis – Auffahrt über die Rampe – und das Zustandsereignis – 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 k = 2 N/m

D = 0,... 0,01 v0 = 1,0 m/s

μ = 0,08 μ0 = 1,5 μ

g= 9,81 m/s2

302

5 Simulation unter MATLAB

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 Integration. 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 erheblich. Das Auffinden der richtigen Kontaktzustände resultiert in einem kombinatorischen Problem. Tabelle 5.9: Beispiel-Parameter des Zwei-Massen-Reibschwingers mit zwei Reibkontakten Beispiel Masse Masse Steifigkeit Steifigkeit Gleitreibkoeffizient Haftreibkoeffizient Gleitreibkoeffizient Haftreibkoeffizient Erdbeschleunigung Erregerkraft Erregerkraft

m1 m2 k1 k2 μ1 μ10 μ2 μ20 g f1 f2

3

4

Einheit

1,0 1,5 10 10 0,040 0,060 0,002 0,004 9,81 sin t 0

1,0 1,0 0 150 1 1 1 1 10 15 cos (2πt + π) 60 cos (2πt)

kg kg N/m N/m – – – – m/s2 N 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 zwischen 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 Vorgehensweise 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 Modellierung anhand der Beispiele 3 und 4.

5.7

Randwertprobleme gewöhnlicher Differenzialgleichungen

Bei den bisher betrachteten Simulationen waren Anfangswertprobleme bzw. Anfangswertaufgaben zu lösen, d. h. neben der Differenzialgleichung müssen Anfangswerte, Zeit t0 und entsprechend der Ordnung der Differenzialgleichung Anfangszustände y (t0 ) = y 0 , gegeben sein. Im Gegensatz 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ängige 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 = f (x, y ) dx g (yy(a), y (b)) = 0 y ′ (x) =

auch

y ′ (x) = f (x, y , p )

auch

g (yy(a), y (b), p ) = 0 ,

(5.141)

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 Vektor p zulässig. Gesucht ist eine Funktion y (x) bzw. y (x, p ), die zum einen die Differentialgleichung 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 Subintervallen [xi , xi+1 ] mit a = x1 < x2 < .... < xN−1 < xN = b

(5.142)

304

5 Simulation unter MATLAB

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 Anfang, 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 Gleichungssystem, 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. i=1,..,N

(5.143)

Zur Lösung des Randwertproblems muss danach eine Ortsdiskretisierung (ggf. von MATLAB 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 Stetigkeitsbedingung 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 xWert. 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 (a1 ) y2 (a2 ) .. yn (b) y1 (a) y2 (a1 ) .. yn (an−1 ) Y links = . (5.145) , Y = rechts y′1 (a1 ) y′2 (a2 ) .. y′n (b) y′1 (a) y′2 (a1 ) .. y′n (an−1 ) Die Vorgehensweise derartiger Probleme wird zunächst an einfachen Beispielen erläutert. Darauf 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

5.7 Randwertprobleme gewöhnlicher Differenzialgleichungen

305

Differenzialgleichung 2. Ordnung 10 lautet y′′ (x) = d und mit

! 1 + y′ (x)2 ,

(.)′ =

d(.) dx

(5.146)

diff

y1 = y −→ y′1 = y2

y2 = y′

diff

−→ y′2 = y′′ = d

 1 + y2 (x)2

in vektorieller Form   y2 ′ = f (yy) , y = d 1 + y2 (x)2

d ist ein Systemparameter. Hinzu kommen die Randbedingungen   linker Rand y(a) = yL y(a) − yL = 0, =⇒ g (y(a), y(b)) = rechter Rand y(b) = yR y(b) − yR

(5.147)

(5.148)

(5.149)

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 :   T    ya − yL (5.150) , ya = ya , y′a , yb = yb , y′b . r es = yb − y R

Damit ist das MATLAB Script zu schreiben. Da (5.148) und (5.150) sehr übersichtliche Ausdrücke sind, legen wir hierfür Anonymous Functions Kette_dgl, Kette_res an. 1 2 3 4 5 6 7 8 9 10

yL=0.2; yR=0.1; % Randwert links / rechts w0=4.0; % Randpunkt-Abstand d=1/15; % Systemparameter % ---- Function Handle, Anonymous Function Kette_dgl=@(x,y) ([y(2); d*sqrt(1.0+y(2)^2)]);% Differenzialgl. Kette_res=@(ya,yb) ([ya(1)-yL; yb(1)-yR]); % Residuum % ---- Function Aufruf options = bvpset(’stats’,’on’); % Option solinit=bvpinit(linspace(0,w0,10),[1;1]); % Initialisierung 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/

306

5 Simulation unter MATLAB

Die obigen Function-Namen sol, solinit sind beliebig, die Feldnamen x, y dagegen festgeschrieben. Erläuterungen und Ergänzungen: In den Zeilen 1-4 werden Randwerte und Parameter vereinbart, 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 Komponenten 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 Initialisierungsdaten: 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] entsprechend 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 Randwerten yL , yR , dann gilt für die Schätzfunktion ⎡ ⎤ yR − yL   Geradengleichung x + y y ⎢ L ⎥ ≈ ⎣ yR − yL w0 (5.151) y = ⎦ ′ 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 9

Kette_init=@(x) ([yL+(yR-yL)/w0*x;(yR-yL)/w0]);% Initial. solinit=bvpinit(linspace(0,w0,10),Kette_init); % Initial.

Die Felder solinit.x, solinit.y der Structure solinit können natürlich auch unmittelbar besetzt werden. Eine Möglichkeit zeigen die folgenden Zeilen: 6a 9 9a

Kette_init=@(x) ([yL+(yR-yL)/w0*x;(yR-yL)/w0*ones(size(x))]); solinit.x = linspace(0,w0,10); % Gitterpunkt 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 Gitterpunkte x ausgewertet wird,

5.7 Randwertprobleme gewöhnlicher Differenzialgleichungen

307

• die analytische Erstellung der JACOBI-Matrix der rechten Seite f (yy) von (5.148) ⎡ ⎤ 0 1 ∂f y ⎢ ⎥ = ⎣ 0 d! 2 (5.152) J = ⎦, ∂yy 2 1 + y2

• die analytische Ermittlung der JACOBI-Matrizen der Residuen (5.150)     ∂rr es ∂rr es 1 0 0 0 Ja = = , Jb = = . 0 0 1 0 ∂yya ∂yyb

(5.153)

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 maximum residual is 6.797e-004. There were 117 calls to the ODE function. There were 12 calls to the BC function.

The solution ... of 10 points. The maximum residual is 2.532e-005. There were 9 calls to the ODE 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: RelTol: SingularTerm: FJacobian: BCJacobian: Stats: Nmax: Vectorized:

[ [ [ [ [ [ [ [

positive scalar or vector {1e-6} ] positive scalar {1e-3} ] matrix ] function_handle ] function_handle ] on | {off} ] nonnegative integer {floor(10000/n)} ] on | {off} ]

(1) (2) (3) (4) (5) (6) (7) (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.

308

5 Simulation unter MATLAB

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-PunktRandwertproblem mit bvp4c bzw. bvp5c zu lösen ist. Die Differenzialgleichungen müssen bereichsweise formuliert werden. Beispiel: Beidseitig gestützter Balken mit einem Gelenk zwischen den Lagern. Rechts und links am Gelenk sind zwar die Durchbiegungen gleich, die Neigungen 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 (konstruierte) 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 k = 1, 2. (5.154) y ′k = = f (yyk ) , 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ätzlichen 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].

5.7 Randwertprobleme gewöhnlicher Differenzialgleichungen

309

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öglichkeit ist eine feinere Anfangs-Diskretisierung, z. B mit xinit=[linspace(0,w0/2,20),linspace(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] enthalten. Ü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 Randwertproblem. 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 Differenzialgleichungen erfolgen. Gegeben: q1 x2 v′′′′ Differenzialgleichungen: v′′′′ 1 (x1 ) = 0, 2 (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

310

5 Simulation unter MATLAB

Rand- und Übergangsbedingungen für v1 (x1 ) und v2 (x2 ): A: C: B: 5.7.4

M = −EI1 v′′1 (0) v1 (ℓ1 ) = v2 (0) v′′2 (0) = 0 v2 (ℓ2 ) = 0

c1 v1 (0) = −EI1 v′′′ 1 (0) v′′1 (ℓ1 ) = 0 ′′′ −EI1 v′′′ 1 (ℓ1 ) + c2 v2 (0) + EI2 v2 (0) − F = 0 ′ ′′ cT v2 (ℓ2 ) = −EI2 v2 (ℓ2 )

Periodische Schwingungen nichtlinearer Systeme

In Anlehnung u. a. an die Beispiele aus Abschn. 4.6 unterscheiden wir Differenzialgleichungen der Form M (xx) x¨ + g (xx, x˙ ) = 0 ,

M (xx) x¨ + g (xx, 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 Gleichungstypen 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 ermitteln. Im Gegensatz zum Anfangswertproblem, mit dem nur stabile Schwingungen ermittelbar sind, enthalten die Lösungen des Randwertproblems keine Information bezüglich derer Stabilitä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 Randwertproblemen ist jetzt die unabhängige Variable die Zeit t (statt die Ortskoordinate x). 5.7.4.1

Autonome Schwingungssysteme T  Mit dem Zustandsvektor y = x T , x˙ T erhalten wir (5.155)1 in expliziter Form 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-Verfahren, 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 y (t + T ) = y (t),

T =

2π ωs

(5.158)

existieren. Die Kreisfrequenz ωs ist unbekannt, sie ist abhängig von den Systemparametern. D. h.

5.7 Randwertprobleme gewöhnlicher Differenzialgleichungen

311

zur Formulierung des Randwertproblems muss ωs explizit auftretender Parameter der Differenzialgleichung sein. Dies erreichen wir durch die Zeittransformation τ = ωst

→

d dτ d d = = ωs , dt dτ dt dτ

d = ()′ dτ

(5.159)

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 explizit 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 erweiterten Randbedingungen sind somit y (τ + 2π) − y (τ) = 0 yk (τ0 ) = 0,

k ∈ 1,2, . . . , n;

meist τ0 = 0 .

(5.161)

˙ Dies ist Bemerkung: Der Zustandsvektor y (τ) enthält z. B. die Komponenten y1 = y und y2 = y. 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 Abschn. 4.5 Gleichung (4.30). Danach folgt mit y1 = ϕ, y2 = ϕ˙ und den Parametern nach Bild 4.36 # " y2      . (5.162) y˙ = g 1 2 − M+mmsin 2 y 21 y22 sin (2y1 ) + M+m m L sin y1 − mL2 α − β y1 y2 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 Function 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 Initialisierung und den Löser-Aufruf: 1 2 3 4 5 6

Om=20; % Selbsterregerfreq. omega_s t=linspace(0,2*pi,50); % Initialisieren der Zeitachse fmetro_ini=@(t) ([0.6*sin(t(1,:)); 10*cos(t(1,:))]); solinit=bvpinit(t,fmetro_ini,Om); % mit Parameterübergabe sol = bvploeser(@fmetro_dglS,@fmetro_res,solinit,options); Om=sol.parameters; % Ergebnis von omega_s

312

5 Simulation unter MATLAB

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 Parameters 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 JACOBIMatrizen ä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 periodische Lösung hier direkt ermittelt, die Stabilität ist offen. Die Lösung liegt nur zu diskreten Zeitpunkten 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 Stabilitä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˙ (t) = f (yy(t)) + q˜ (yy(t)) sin (Ωt + Φ) =: f (yy(t), t)

(5.163)

mit q˜ (yy) =

"

0 1×3

cos (y1 ) −q L(M+m sin2 (y

1 ))

#

.

(5.164)

5.7 Randwertprobleme gewöhnlicher Differenzialgleichungen

313

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 Grundharmonischen 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 Ausdrü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 vorangegangenen Lösung auf. Die so erhaltene Response-Kurve ist in Bild 5.46 dargestellt. Da die Erregerfrequenz Ω in der Nachbarschaft der Selbsterregungsfrequenz ωs liegt, kommt es zu resonanzartigen Ü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 Schwingungen 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

314

5 Simulation unter MATLAB

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 gestö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 systematische Stabilitätsuntersuchung aussagekräftiger. Wir können eine derartige numerische Vorgehensweise 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 (τ).  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π) .  y (τ) y 0 (τ)

(5.167)

(5.168)

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˜ k (τ), die die Fundamentalmatrix V (τ) = (˜v 1 (τ), v˜ 2 (τ), · · · , v˜ n (τ))

(5.169)

bilden. Sie genügt wegen der Periodizität von Q (τ) der Matrix-Differenzialgleichung V (τ) V ′ (τ) = Q (τ)V

→

V (τ + 2π), V ′ (τ + 2π) = Q (τ)V

(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˜ k (τ) schreiben lassen V (τ + 2π) = V (τ) K ,

(5.171)

K ist eine konstante reguläre Matrix. Die Lösungen v˜ k (τ) bestimmen wir uns numerisch aus

5.7 Randwertprobleme gewöhnlicher Differenzialgleichungen

315

(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˜ (τ), 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 − ρ E) a = 0 (K

(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 |ρk | > 1 |ρk | = 1

asymptotisch stabil instabil kritisch.

(5.178)

Im kritischen Fall entscheiden die Terme höherer Ordnung von (5.167), ob Stabilität oder Instabilitä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 ρℓ = e2πλℓ

oder

λℓ =

1 ln ρℓ , 2π

(5.180)

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

316

5 Simulation unter MATLAB

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 Differenzialgleichungssystems ist die Bestimmung der Fundamentalmatrix V (τ) zu den speziellen Anfangsbedingungen V (0) = E und der Eigenwerte von K := V (2π), der charakteristischen Multiplikatoren ρ, erforderlich. Hierzu muss die Variationsgleichung (5.168) entsprechend der Ordnung (hier zwei) zu wechselnden Anfangswerten, jeweils dem ℓ-ten Einheitsvektor (ℓ=1, 2,..), numerisch 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 Kurvenparameter. 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. Aufgrund der willkürlich vorgegebenen Komponente yk (τ0 ) in (5.161), d. h. der Phase der Schwingung 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 Systeme 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 Modellierung und Animation der Steuerlogik derartiger Systeme in der Simulink-Umgebung. Es ist somit für die Modellierung eventgetriebener Systeme ein interessantes Werkzeug. Insbesondere wird anhand der Dreipunkt-Schaltlogik aus Abschn. 5.6.5 zur Modellierung des C OULOMBElementes in Verbindung mit dem 1/4-Fahrzeug aus Abschn. 4.4 die unmittelbare Umsetzung derartiger Logiken in der Simulink-Umgebung verdeutlicht. Weitere Stateflow-Elemente diskutieren wir anhand des Ballwurfes aus Abschn. 5.6.4.1. Wir können hier nur Anregungen zur Modellierung mit dem Stateflow Tool vermitteln. Hierfür geben wir zunächst einen kurzen Einblick bezüglich der Arbeitsweise von Stateflow (Version 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 sichtbar; 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 StateflowDiagramme für logische und ereignisgetriebene Abläufe, so genannte endliche Zustandsautomaten (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 (einmaliger 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

W. D. Pietruszka, MATLAB® und Simulink® in der Ingenieurpraxis, DOI 10.1007/978-3-8348-8630-9_6, © Vieweg+Teubner Verlag |Springer Fachmedien Wiesbaden GmbH 2012

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 eindeutiges 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 vertikalen 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), Connective 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ührungsreihenfolge 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 erzeugt. Für alle Bedingungen der Zustand-Übergänge an den Transitionen sowie die der ZustandAktionen, 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 es können mehrere Zustände gleichzeitig aktiv sein, 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 zwingend mit einem gewählten Zustand-Namen (erlaubt: Buchstaben, Unterstriche). Der Name ist, sofern 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önnen optionale Zustand-Aktionen folgen, die sich aus dem Schlüsselwort entry (Kurzform: en), Parallel-Zustände: (Und-Zustände)

320

6 Modellierung und Simulation mit dem Stateflow Tool

during (du), exit (ex), bind und on event, für den Typ der Aktion mit einem abschließenden 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 Aktionsanweisungen, 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 ausgeführt. Die Häufigkeit der Ausführung der During Action ist von der Einstellung der UpdateMethode 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 Grafikobjekte 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 Verbindung 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

6.1 Stateflow-Elemente

321

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 Bedingungsaktion (Condition Action) und einer Übergangsaktion (Transition Action) zusammen. Jedes 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 StateflowDiagramm numerierte Transitionen 1, 2,... entsprechend ihrer Überprüfungsreihenfolge auf Gültigkeit 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 festgelegte oder explizite Ausführung. In diesem Mode setzt der Benutzer die Folge, in der die Transitionen 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 Transitionen. 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 Vorgängerversionen werden in diesen Mode konvertiert. Aus diesem Grund folgen noch einige Bemerkungen zur impliziten Festlegung der Priorität. Grundsätzlich liegen für mehrfach wegführende Transitionen von einem Quellobjekt (Zustand, Verbindungspunkt) drei Vorgehensweisen zugrunde. Sie sind im Bild 6.4 in einer ParallelAnordnung 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 Aktivierungsbedingung 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 :

322

6 Modellierung und Simulation mit dem Stateflow Tool

• • • •

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 solcher 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 Elemente des Connective Junction Tools, vgl. Bild 6.2. Sie können Verzweigungspunkte, von denen dann mehrere Transitionen wegführen, bilden. Unterschiedlichste Konstruktionen bezüglich hinund 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 forSchleifen, do-while-Schleifen und if-then Abfragen, zustandsfreie Flussdiagramme usw. realisierbar, verfolge: Help Navigator/ search/ Connective Junction und aus der Programmsammlung [52] ExpStateflow_1,2,3.mdl.

6.1 Stateflow-Elemente

6.1.6

323

Der Modell-Explorer

Aufbauend auf Abschn. 4.3.5.7 setzen wir die Betrachtung zum Modell-Explorer im Zusammenhang mit dem Stateflow Tool fort. Alle Events, Variablen, Eingänge und Ausgänge (interne, externe 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) angegeben. 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 Object/.../Stateflow, angezeigt. Auf der rechten Seite, Dialog Spalte, des Modell-Explorers kann die den Elementen zugein der Explorer-Menüleiste – sie sind ordnete Dialogbox der Eigenschaften mit dem Button: 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 insbesondere die Update method für die Aktivierung nach jedem Abtastschritt (Discrete, Continuous) des Simulink-Modells, beim Auftreten eines externen Triggersignals oder bei jeder Neuberechnung 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 Explorer 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 Datentransfer 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 – des Explores hinzugefügt werden. Diese Daten sind mit einem Ctrl+E – oder die Knöpfe: Namen, dem Datentyp double, single, int32, boolean usw. zu versehen. Für die Variablenspezifikation 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 Eingangsport angezeigt. Zusätzlich sind Datentyp und evtl. Portnummer zuzuweisen. Ausgangsvariable nach Simulink erhalten die Spezifikation: Output, der Ausgangsport wird angezeigt. Der Datentyp 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.

324

6 Modellierung und Simulation mit dem Stateflow Tool

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 Übersichtlichkeit, 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 Zustä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 weitere 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 StateflowElementen 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 x¨A = −ω12 (xA − xR ) − δ1 (x˙A − x˙R ) − x¨R = ω22 (xA − xR ) + δ2 (x˙A − x˙R ) +

FC s, mA

s = sign (x˙A − x˙R )

FC kR s+ (xs − xR ), mR mR

(6.1)

wobei ω12 =

kA kA dA dA , ω22 = , δ1 = , δ2 = . mA mR mA mR

Die Variablen und Parameter sind in Abschn. 4.4 erklärt. Haftung tritt auf, wenn die Beschleunigungen beider Massen (mA , mR ) gleich sind, d. h. x¨A = x¨R . Damit folgt aus (6.1) x¨A =

kR (xs − xR ) . mA + mR

Der zugehörige Schaltkoeffizient ist per Definition s = 0.

(6.2)

6.2 Beispiel: Schwinger mit Coulomb-Reibung

325

Die Gleichungen (6.1) und (6.2) beschreiben somit die Bewegungsphasen Gleiten und Haften. Ü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 Relativgeschwindigkeit von Aufbau und Rad, und den Schaltkoeffizient s q =x˙A − x˙R  sign q, s= 0,

(6.3)

Gleiten: s ± 1 Haften

ein. Die Hilfs-Schaltfunktionen S± folgen nach (5.129) aus q˙ = x¨A − x¨R zu   1 1 kR + (xs − xR ). (6.4) S± = −(ω12 + ω22 )(xA − xR ) − (δ1 + δ2 )(x˙A − x˙R ) ∓ FC − 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 Anfangszustä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; mR=1.0e+02; kA=40.0e+03; kR=40.0e+04; dA=12.0e+03; FC=400.0; d=0.01;

% % % % % % %

Aufbauten-Masse Rad-Masse Federsteifigkeit der Radaufhängung Reifensteifigkeit Dämpfung der Radaufhängung Reibkraft Rampenhöhe

[kg] [kg] [N/m] [N/m] [Ns/m] [N] [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))...

326

6 Modellierung und Simulation mit dem Stateflow Tool

-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

6.2 Beispiel: Schwinger mit Coulomb-Reibung

327

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 geschaltet 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 Bewegungsgleichungen 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 werden 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 Nullstellbestimmung 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 ebenen Fahrbahnprofil (xs ) insbesondere die Formulierung der Schalt- und Hilfs-Schaltfunktionen (q, S± ), deren Nullstellenermittlung sowie das Chart (State Machine) mit der Dreipunkt-Schaltlogik 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

328

6 Modellierung und Simulation mit dem Stateflow Tool

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 verwendet. 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

6.2 Beispiel: Schwinger mit Coulomb-Reibung

329

Die bekannte Dreipunkt-Schaltlogik nach Bild 5.37 können wir, aufbauend auf den Eingangsgröß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 Anfangsbedingungen 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 unterschiedliche 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 unterschiedlichen 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 umgekehrt 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

330

6 Modellierung und Simulation mit dem Stateflow Tool

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 anderen 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 externes Triggersignal aktiviert und andererseits ein lokales Event des Charts zur Steuerung von

6.3 Beispiel: Springender Ball

a: Geschwindigkeiten

331

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,

332

6 Modellierung und Simulation mit dem Stateflow Tool

 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+c ¨ w v x˙ = 0

Horizontalbewegung;

y¨ = 0, mit y(t ˙ u ) = 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 SimulinkModell in Bild 6.15 dargestellt und in [52] unter ball_stateflow.mdl abgelegt. StateflowElemente übernehmen die Berechnung der Stoßgeschwindigkeiten (v+ = −εs v− ) und die Integrierersteuerung. Zur Integration der Bewegungsgleichung benötigen wir für jede Bewegungsrichtung zwei Integrierer. Neben den Signaleingängen werden beim ersten Integrierer der Vertikalbewegung 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 ChartEingangssignal ausgegeben werden. Die Zeitpunkte der Nullstellen der Ballposition y (Schaltfunktion) 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 unmittelbar 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. Dazu 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 eingestellt, dann erfolgt der Weckvorgang durch die schnellste angelegte Simulink-Signalleitung. Unabhä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 SimulinkModells 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 Bewegung 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 nachdem 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 folgenden 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 Aktionen 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 Aktivierung 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.

334

6 Modellierung und Simulation mit dem Stateflow Tool

Beide Realisierungen sind, wie in Bild 6.15 gezeigt, mit dem Manual Switch Block auszuwählen. Die Animation der Abläufe im Chart sind im offenen Grafik-Editor zu beobachten. Detaillierter 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 Optionen MaxStep und/oder Refine beeinflussen die Simulation im Übergangsbereich zum Rollen 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) 0

346

7 Physikalische Modelle unter Simulink

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 Einmassenschwinger nach Bild 7.3, wobei in den Kontaktpunkten F/B eine Reibkraft mit dem Gleitreibungskoeffizienten μ =0,8 und dem Haftreibungskoeffizienten μ0 =1,5 wirken soll. Die Einstellungen 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 SimulinkModellierung 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 formulieren. 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 festgeschriebenen 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 Bewegungsgleichung   Fs für v = 0 mx¨ + d x˙ + kx − f (t) − (7.1) =0 für v = 0 Fk mit der Gleitreibungskraft (kinetic friction) Fk = −μmg sign(v) und der Haftreibungskraft (static

7.1 SimMechanics Tool

347

friction) Fs ermitteln. Aus (7.1) folgt für v = 0, x¨ = a = 0 unmittelbar (7.2)

Fs = kx − f (t) .

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 Reaction force/torque

FC (eigene Bezeichnung) 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    für v = 0 Fs kx − f (t) , (7.3) = FC = FR = für v = 0 Fk −μmg sign(v) 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 ! , (7.4) = FC + d x˙ + kx − f (t) = FC − Fext FR = für v = 0 Fk 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

348

7 Physikalische Modelle unter Simulink

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-Schalterstellungen 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) zeitweilig in der gleichen Position. Ähnliche Ergebnisse haben wir schon in Abschn. 5.6.5, 5.6.5.3 diskutiert.

7.1 SimMechanics Tool

349

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önnen auf der Basis der in der Body Dialog-Box festgeschriebenen Körperpunkte sowie der Masse-

350

7 Physikalische Modelle unter Simulink

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 unterschieden. Die Visualisierungsart wird im Rahmen der Maschinen-Konfiguration in der Machine Environment 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 SimMechanics Visualisierungs-Fenster dargestellt, siehe Bild 7.16. D. h. Parameteränderungen oder hinzufü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 u. a. nach Bild 7.16 zu öffnen und nach Menüleiste des Modell- bzw. Visualisierungsfensters 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. Entscheidet man sich nur für die Animation, dann wird das Visualisierungsfenster bei Simulationsstart 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 Abbildungsart der Körper. Hier wird zwischen • Equivalent ellipsoids basierend auf der Masseeigenschaft und der Schwerpunktslage (Trägheitsellipsoid) • Convex hulls basierend auf den Körperkoordinaten (CSs) – vgl. Body Dialog-Box unterschieden. Die Darstellung des Trägheitsellipsoids mit dem Hauptträgheitsmoment des Körpers sowie den Trägheitsradien als Hauptachsen ist nur bei angenähert gleichen Größenordnungen der Trägheitsmomente aller Körper der Maschine übersichtlich. Unter Convex hulls Abbildungen werden die vorgegebenen körperfesten Punkte (CS1, CS2,...) als 2D- bzw. 3DAbbildungen – 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 Robotermodell aus Bild 7.6 in der Ellipsoid-Abbildungen dargestellt. Zusätzlich lassen sich u. a. Schwerpunkte 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-

7.1 SimMechanics Tool

351

stellenden Parameter eingehen. Einen vollständigeren Überblick mit den umgesetzten mathematischen 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 ergaben sich für ein mechanisches Mehrkörpermodell differenzial-algebraische Gleichungen vom Index 3, die Bindungsgleichungen bzw. Nebenbedingungen beruhen dabei auf Lageebene. Weiterhin 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örpermodelle 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 Bewegungsgleichung in Deskriptorform q˙ = H˜ v T

GT (t, q )λ λ M (qq)˙v = f (t, q , v ) + H˜ (qq)G 0 = g (t, q )

(7.6)

formuliert werden, siehe auch Abschn. 5.4. Dabei ist der kinematische Zusammenhang zwischen der zeitlichen Ableitung der Struktur- bzw. Konfigurationsvariablen q˙ und der Geschwindigkeitsvariablen v durch (7.6)1 hergestellt. In vielen Anwendungen ist H˜ die Einheitsmatrix, so dass (7.6)1 eine Identität darstellt. Dies kennen wir von der Erzeugung der Standardform zur Integration gewöhnlicher Differenzialgleichungen. Die Differenzialgleichung (7.6)2 beschreibt die Dynamik des Systems. M ist die positiv-definite Massenmatrix, f der Vektor der Zentrifugalund 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. λ reprä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 Formulierung in Absolutkoordinaten. D. h. jeder Körper des Systems hat zunächst sechs Freiheitsgrade. 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 berü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-

352

7 Physikalische Modelle unter Simulink

durch werden weit weniger Konfigurationsvariablen und Bindungsgleichungen benötigt. Nachteilig ist die dicht besetzte Massenmatrix und die komplexer aufgebauten Bindungsgleichungen. Wie schon erwähnt, werden in SimMechanics geschlossene Schleifenstrukturen durch Aufschneiden geeigneter Gelenke in solche mit offener Schleifenstruktur überführt, was zusätzliche Schließbedingungen erfordert, so dass sich mathematisch wieder das Verhalten des Ausgangsystems 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 Abschn. 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 mechanischen 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 HOLESKYZerlegung, die alternativ auszuwählende auf der QR-Zerlegung. Die erste Methode ist im Allgemeinen 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 Unterdrü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 ausgewä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 allerdings 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 Simscape, 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 (GelenkKrä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 SimMechanics 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

7.2

353

Anwendungen und Ausblick

In Abschn. 8.4 sind Modellierungen zum Hebelmechanismus einer Pkw-Klimaanlage und in Abschn. 8.5 zum Dreifachpendel nachzulesen. Darüber hinaus wird mit Dreh_SimMech.mdl in [52] ein Drehschwinger modelliert. Die Ergebnisse sind denen einer konventionellen Methode auf der Basis von Bewegungsgleichungen gegenübergestellt. Mit dem SimMechanicsModell 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 Alternativen 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 skriptorientierte 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 Modellierung 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 vielfä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

354

7 Physikalische Modelle unter Simulink

Bild 7.18: Beispiel 3: Einschwingvorgang des Zwei-Massen-Reibschwingers mit zwei Reibkontakten 4

40 m2

0

m1

−2

−4

m2

20 xpp1, xpp2

xp1, xp2

2

−0.4

−0.2

0 x1, x2

0.2

m1 0

−20

0.4

0.6

−40 −4

−2

0 xp1, xp2

2

4

Bild 7.19: Beispiel 4: Phasendiagramme der periodische Schwingungen des Zwei-MassenReibschwingers mit zwei Reibkontakten

x˙1 (0) = 1,671443845733659, x˙2 (0) = 1,671443845733659 , die einer periodischen Schwingung genügen, zugrunde. Die Schwingungen mit der Periodendauer 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 modellspezifische Aufbereitungen folgen. Darauf aufbauend wird es möglich, einzelne/alle Projektpunkte 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 Interesse 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 abgedruckt werden, die vollständigen Programme stehen an gleicher Stelle wie oben zur Verfügung. Damit können alle Berechnungen nachempfunden werden. Eigenständige Parameterstudien ohne/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 Kopfzeilen zum jeweiligen Projekt angegeben. Damit kann gezielt speziellem Interesse nachgegangen werden.

8.1

Permanentmagnet gelagerter Rotor

Schlagworte: Simulink-Modelle, Modellbeschreibung, instabile Strecke, Spulenmodell, aktive Stabilisierung, 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

W. D. Pietruszka, MATLAB® und Simulink® in der Ingenieurpraxis, DOI 10.1007/978-3-8348-8630-9_8, © Vieweg+Teubner Verlag |Springer Fachmedien Wiesbaden GmbH 2012

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 Schwingungsverhalten 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 Systembeschreibung 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 vorzunehmen. 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 Reglers 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 Eigenwerte 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 Reglerumschaltung, 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. Tabelle 8.1: Systemparameter Masse O HMscher Widerstand Induktivität Strom-Kraftkoeffizient Proportionalverstärkung der Leistungsstufe Permanentmagnetsteifigkeit Lagerkontaktsteifigkeit Lagerspiel

8.1.1

m R L kM kI k pm kw ymax

4,6 kg 3,4 Ohm 26,875 mH 32,23 N/A 6,255 1,25 106 N/m 43,77 106 N/m 124 10−6 m

Systembeschreibung

Zunächst stellen wir das Lagerprinzip eines radial permanentmagnetisch (passiv) und axial elektromagnetisch (aktiv) gelagerten Rotors nach Bild 8.1 stichwortartig vor. Wählen wir für die gegenüberliegenden Permanentmagnetringe des oberen und unteren Lagers 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 Stabilisierung 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 elektrischen Spulensystems überlagert wird, so dass die in Flussrichtung wirkende Kraft mit zunehmender 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 Flussdichte 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 Lagerbegrenzung 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) Kontakt −k pm y + kw (y − ymax sign y) für − ymax ≥ y ≥ ymax 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 symmetrischen 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 Spulenmodells

358

8 Projekte

Bild 8.3: Destabilisierende Lagerkräfte und Kontaktkräfte

my¨ + f (y) = −kM i − mg L(i)˙+ Ri = uM .

(8.2)

Die stromdurchflossenen Spulen erzeugen die auf den Rotor wirkende Kraft kM i, die Permanentmagnete 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, Spulenkapazität, Nichtlinearität der Permanentmagnete, Dynamik der Sensorkreise, Filter zur Signalglä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 zusammengesetzten 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 Sensordynamik bleibt aber unberücksichtigt; die Verstärkungen setzen wir zu eins. Der Kaskadenregler, 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 Rotorstabilisierung erforderlichen Strom iy . Die innere Regelschleife regelt diesen Strom und steuert die Leistungselektronik, um die erforderliche Spannung für die Magnete zu erzeugen; kurz Stromregler. Man spricht auch von einem stromgesteuerten System, wobei der Stromregler wesentlich schneller als der Lageregler ausgelegt werden muss. Dieser Reglertyp ist in der Industrie insbesondere wegen seiner geringen Störempfindlichkeit und der guten Einstellmöglichkeit (Tuning) sehr verbreitet.

8.1 Permanentmagnet gelagerter Rotor

359

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 Zustandsreglers 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 Leistungsstufe 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 Gleichgewichtszustä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

i(∞) → 0 :

ui = −k p y − kd y˙ − kii

3.

8.1.5

Reglerentwürfe

8.1.5.1

Zustandsregler

$

$

y dt − k pi i

(8.4)

i dt − k pi i.

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) ⎤ ⎡ ⎤ ⎡ ⎡ ⎤ ⎤⎡ ⎤ ⎡ 0 1 0 0 0 y˙ y ⎥ ⎢ ⎥ ⎢ k ⎢ ⎥ ⎥⎢ ⎥ ⎢ (8.5) ⎣ y¨ ⎦ = ⎣ mpm 0 − kmM ⎦ ⎣ y˙ ⎦ + ⎣ 0 ⎦ u + ⎣ m1 ⎦ ( fw − mg) kI R (i)˙ i 0 0 0 −L L ⎤ ⎡ k sy ys ⎣ y˙s ⎦ = ⎣ 0 is 0 ⎡

0 ksy 0

⎤⎡ ⎤ 0 y 0 ⎦ ⎣ y˙ ⎦ i ksi

(8.6)

mit der Lagerkontaktkraft nach (8.1) fw (y) = kw (y − ymax sign(y))

für − ymax ≥ y ≥ ymax .

oder kurz B u +V Vv z˙ = A z +B y = C z.

(8.7)

Einfachheitshalber setzen wir weiterhin in (8.6) die Sensorverstärkungen ksy , ksi zu 1. Das Stellgesetz lautet: K zz, u = −K

(8.8)

wobei der Reglerentwurf sich auf die ungestörte (v = 0) Bewegungsgleichung (8.7) bezieht. Vollständige Steuer- und Beobachtbarkeit folgt aus der Anschauung. Einen numerischen Nachweis erhalten wir über den Rang der Steuerbarkeitsmatrix Co bzw. Beobachtbarkeitsmatrix Ob Ob=rank(obsv(A,C)); MATLAB-Aufruf. Co=rank(ctrb(A,B)); Aus der Vielzahl der Regler-Entwurfsmethoden wollen wir drei aus der Control System Toolbox heranziehen, die auf zwei unterschiedlichen Bewertungen basieren. Auf die Algorithmen

8.1 Permanentmagnet gelagerter Rotor

361

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 − BK (A 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, performance 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 MATLABAufruf 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 Eigenwerte E des geschlossenen Kreises. Der auf (8.7) basierenden Programm-Code – Ausschnitt des Datenfiles Mag_RotD.m – geben 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]; [Kp,prec,message] = place(A,B,p) Ka=acker(A,B,E)

% Pollagen % Algorithm. nach KAUTSKY % 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 Einschwingungsverhalten 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 !

uy (0) = −k p y(0) − ki Q(0) = 0

→ Q(0) = −

kp y(0). ki

Damit liegt für die erweiterte Reglerauslegung ein Differenzialgleichungssystem 4. Ordnung my¨ + f (y) = −kM i − mg,

y(0) =

i(0) = 0

L(i)˙+ Ri = kI uy , Q˙

= y,

1 (kw ymax sign(y0 ) − mg) , y(0) ˙ =0 kw − k pm

(8.9)

kp 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 By uy +V Vy v z˙y = A y z y +B K y zy uy = −K

y(∞) → 0

(8.11)

mit Ay =



A 0 1 0 0 0



, By =



B 0



, Vy =



V 0



,

A , B , V nach (8.7)

  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

8.1 Permanentmagnet gelagerter Rotor

363

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 vorgegebenen Pole p (der rechten Seite) bleiben Teil des geschlossenen Kreises.  Entsprechendes gilt für den stromlosen Betrieb mit Qi = i dt Bi ui +V Vi v z˙i = A i z i +B K i zi, ui = −K

i(∞) → 0 ui (0) = 0

mit Ai =



A 0 0 0 1 0



, Bi =



B 0



, Vi =



V 0



,

A , B , V nach (8.7)

  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 Anfangswerte 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 Simulationsvorgang 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 zweiten Modell wird mit schaltbaren Subsystemen gearbeitet, vgl. [52]. Ist die Geschwindigkeit y˙ nicht messbar, dann kann versucht werden, diese durch numerisches Differenzieren zu berücksichtigen. 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 Lagerbegrenzung. 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 unmittelbarer 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öhere 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 zunä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 Abhebestrom 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 Situation 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-, Reglerentwurf, 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-Schwingungen kompensiert werden. Die Fundamentbewegungen x und x˙ werden gemessen. Für die aktive 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 aufgeschaltet werden. 5. Formulieren Sie die Beobachtergleichung einschließlich der Schaltbedingungen in einer MFile 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

8.2 Störgrößenkompensation harmonischer und konstanter Störungen

Parameter: m := m + mu k d emu ku kT = m Ω q0

367

= 100 kg = 36 106 N/m =10−4 k N s /m = 0,5 m kg = 20 1/kg = 300 rad/s 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 angepassten 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 SimulinkSimulation. 7. Diskutieren Sie den Kompensationsvorgang in Verbindung mit den rekonstruierten Signalen. Beurteilen Sie die Beobachterdynamik und den Einfluss der Systemparameter k, d. Überprüfen Sie die Parameterempfindlichkeit des Beobachterentwurfs, indem Sie die Fundamentfedersteifigkeit 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 2δ =

d ; m

ω02 =

k ; m

kT =

ku ; m

q=

mu 2 eΩ . m

Für den Beobachterentwurf muss die Störung w = q cos (Ωt + Φ) durch eine gewöhnliche Differenzialgleichung 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 Qy +D Du(t) w˙ = Pw +Q E u(t), y˙ = Rw +SSy +E

˙T, y = [y1 , y2 ]T = [x, x]

368

8 Projekte

wobei auf der linken Seite der ersten Gleichung die Ableitung des Störmodells w˙ und in der zweiten Gleichung die der Messgröße y steht. Bezogen auf unser Beispiel bedeutet dies ausführlich: Störmodell    0 w˙ 1 = w˙ 2 −Ω 2

1 0



w1 w2



,



mit

mechanisches Modell       0 0 0 w1 y˙1 + = 1 0 w2 y˙2 −ω02

1 −2δ

w1 w2





=



w w˙

y1 y2



+

 

Q = 0, D = 0,

,

0 kT



u(t)

oder kurz w˙ = Pw ,

w = [w1 , w2 ]T = [w, w] ˙T

E u(t), y˙ = Rw +SSy +E

y = [y1 , y2 ]T = [x, x] ˙T.

(8.13)

Der Beobachter für die zu rekonstruierende Größe wˆ wird in der Form: My +N N u(t) v˙ˆ = Lvˆ +My Hy rekonstruierte Störung: wˆ 1 (t) → q cos (Ωt + Φ) für t → ∞ wˆ = vˆ +Hy

(8.14)

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 der tatsächlichen w und rekonstruierten wˆ Störgröße: e = w − wˆ gebildet wird. Die rekonstruierte Störgröße wˆ strebt gegen die tatsächliche w , wenn e → 0 möglichst schnell abklingt. Um die Dynamik von e zu beurteilen, formulieren wir die Fehlerdifferenzialgleichung und setzen w˙ , w˙ˆ aus (8.13), (8.14) ein: e˙ = w˙ − wˆ˙ P −L L −HR HR w + (LH LH −M M −HS HS N +HE HE = Le + (P HR)w HS)yy − (N HE)u(t). Forderung nach asymptotischer Stabilität des Fehlers e führt auf die beiden Bedingungen: L)) < 0 gilt 1. e˙ = Le Le, e ist asymptotisch stabil, wenn für die Realteile der Eigenwerte ℜ(λk (L L −HR HR = 0 2. P −L M −H HS = 0 LH −M HE = 0 N +H

→ → →

HR L = P −H HS M = LH −H HE . N = −H

Hierin sind P , R , S , E aus (8.13) bekannt, H , L , M , N unbekannt. Sie müssen die obigen Bedingungen erfüllen. Zunächst betrachten wir die Dynamik der Fehlergleichung, womit H und L ermittelbar sind: HR - Koeffizientenmatrix L = P −HR     0 1 0 h11 h12 L= − 1 h21 h22 −Ω 2 0

0 0



=



−h12 −h22 − Ω 2

1 0



8.2 Störgrößenkompensation harmonischer und konstanter Störungen

369

- charakteristische Gleichung zu 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˙ = Le adjungierte Problem H Te ) e˙ = L Te = P Te + R T (−H = Ae + Bu Bu,

!

Ke = − H Te u = −Ke

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 Polvorgabe, 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 Systeme 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 ausgelegt. Die Störgrößenaufschaltung erfolgt schließlich mit u(t) = − 8.2.2

1 wˆ 1 (t) . kT

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 Bv u v (t) v˙ˆ = Lvˆ +B Dv u v (t) y v = C v vˆ +D

State Space

Block



x˙ = A x + B u y=Cx+Du

mit B v = C v = I 2 × 2 als Einheitsmatrix sowie der 2 × 2-Durchgangsmatrix D v = 0 und dem Eingangsvektor N u(t) u v (t) = My +N

370

8 Projekte

aus. Damit liegt am Ausgang des State Space Blocks der vollständige Beobachtervektor y v = vˆ an. Die rekonstruierte Größe wˆ 1 folgt aus H yy], wˆ 1 = [1, 0] [ˆv +H

→

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. Natü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) x¨ + 2δ x˙ + ω02 x = kT u(t) + q cos (Ωt + Φ),

u(t) = −

1 wˆ 1 (t) kT

(8.17)

- Beobachter nach (8.14) My +N N u(t) v˙ˆ = Lvˆ +My Hy Hy], wˆ 1 = [1, 0][ˆv +Hy

wˆ 1 (t) rekonstruierte Störung.

(8.18)

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 gestartet 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 dargestellt. 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 weiterhin über das Parameterfile St_Beob_sD.m erzeugt, so dass die Beobachtergrößen an den SFunction-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

8.2 Störgrößenkompensation harmonischer und konstanter Störungen

371

Bild 8.12: Simulink-Modell mit Subsystem des Beobachters

beiden Zeitabschnitten sind die freien und erzwungenen Schwingungen zu ermitteln und zu überlagern. Sie enthalten Integrationskonstanten, die einerseits mit vorgegebenen Anfangswerten und andererseits mit Übergangsbedingungen in ts , d. h. der Endzustand zum Schaltzeitpunkt ts ist Anfangszustand 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 Literatur bekannten Anstückelmethoden [17]. Insbesondere wird gezeigt, wie man durch systematische 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 Gesamtmodell. Das Zustandsmodell der Strecke (8.17) bilden wir mit dem Zustandsvektor y : y˙ = A m y + b u u(t) + b m cos (Ωt + Φ),

y = [x, x] ˙ T,

372

8 Projekte

mit Am =



0 −ω02



1 −2δ

;

bu =



0 kT



;

bm =



0 q



.

Für das Gesamtsystem ist die Beochtergleichung (8.18)1 noch hinzuzufügen:          y˙ bm bu y Am 0 cos (Ωt + Φ). u(t) + + = 0 N M L vˆ vˆ˙ Darin gilt mit (8.18)2 wieder die Stellgröße u(t) = −

1 1 Hy wˆ 1 = − c Tw [ˆv +Hy Hy], kT kT

c Tw = [1, 0].

Setzen wir dies noch ein, dann folgt für den geschlossenen Kreis: ⎞ ⎛          y˙ Am 0 bm bu ⎜ 1 T y ⎟ Hy = cos (Ωt + Φ) . Hy)⎠ + + ⎝− c w (ˆv +Hy N 0 vˆ M L v˙ˆ kT    wˆ 1



  aufzuschaltender Anteil   T A (y T , vˆ T ) = Ax



T  Die beiden ersten Terme auf der rechten Seite können wir noch zu A y T , vˆ T zusammenfassen. Für den Cos-Term der Anregung führen wir die komplexe Relation 1 cos (Ωt + Φ) = (ei(Ωt+Φ) + e−i(Ωt+Φ) ), 2

i=

√

−1

ein, siehe Abschn. 3.3.2.2, so dass das Gesamtsystem folgende Form erhält: 1 x˙ = Ax + b (eiΦ eiΩt + e−iΦ e−iΩt ), 2

T T   x = y T , vˆ T , b = b Tm , 0 T

oder in der für die weitere Betrachtung zweckmäßigen Form ⋆

x˙ = Ax + hˆ eiΩt + hˆ e−iΩt ,

hˆ =



1 T iΦ T b e ,0 2 m

T

,

(8.19)

⋆ hˆ ist der zu 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 erzwungenen Bewegung zusammen, und passen sie später an die beiden Zeitabschnitte an.

Den freien Bewegungen liegt die homogene Gleichung x˙ h = Ax h

8.2 Störgrößenkompensation harmonischer und konstanter Störungen

373

zugrunde. Der Ansatz x h = v eλt führt auf das Eigenwertproblem (λII − A )vv = 0 mit den Eigenwerten 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ˆ eiΩt und hˆ e−iΩt zusammen: x p = ξ +ξξ ⋆ = 2ℜ(ξξ ) . Zur Ermittlung von ξ betrachten wir das reduzierte System ξ˙ = Aξ + hˆ eiΩt . Der Lösungsansatz vom Typ der rechten Seite ξ = ξˆ eiΩt führt auf das algebraische Gleichungssystem (iΩII − A )ξˆ = hˆ → ξˆ = (iΩII − A )−1 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 andererseits 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: V \(xx0 − 2ℜ(ξˆ eiΩt0 ))) c = eλ t0 .\ (V

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 T T x (tt T ) = V diag(cc) eλt + 2ℜ(ξˆ eiΩtt ) .

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 Unwuchtschwingungen 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 abgeklungen. • t = ts s: Beobachter wird zugeschaltet. • ts < t < ts + T s: Unwuchtschwingungen sind nach ca. einer Periode T kompensiert, Eigenschwingungen sind durch den Schaltvorgang angeregt, vgl. Schwingungsdauer T0 .

8.2 Störgrößenkompensation harmonischer und konstanter Störungen

375

• 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 Beobachterentwurf um 10 %, also auf kB = 39,6 106 N/m, dann erhalten wir einen deutlich schlechteren 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 Zusammenhang 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, frequenzmodulierte 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 parallelgeschaltetem Feder-Dämpfer-Element (k1 , d1 ) gegenüber der Umgebung abgestützt. Die Tilgermasse (m2 , Sekundärsystem) ist durch ein weiteres viskoelastisches Element (k2 , d2 ) an das Primä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 viskoelastischen Anschlag (k, d, masselos) begrenzt; das Spiel gegenüber der Gleichgewichtslage sei Δ.

Parameter: m1 =1 m2 = 0,1 k1 = 25 103 k2 = 4300 d1 = 0,8 d2 = 0,1 f (t) = q sin (Ω (t)t) q = 10 Ω (t) = 2πsweep t Δ =3 k = 250 103 d = 200 sweep = 0,1

kg kg N/m N/m Ns/m Ns/m N N rad/s mm N/m Ns/m 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) 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 0 , wenn x2 ≥ Δ und fN < 0 fN (x˙2 , x2 ) = ⎩ 0 , wenn x2 < Δ .

(8.20)

(8.21)

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. Darauf 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 quadratischen 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. Grafische Darstellung des Amplitudenfrequenzganges. Überprüfen Sie die Resonanzlagen. Für die einzelnen Berechnungsschritte und Grafiken ist ein M-File zu schreiben. Es ist gleichzeitig 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 erarbeiteten Auswerteteil der Schwingungssignale einerseits bezüglich des vollständigen Frequenzspektrums, andererseits bezüglich der Basiskreisfrequenz Ω . 3. Für das System ohne Anschlag sei die Schwingungsantwort bei einer zeitlich veränderlichen 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 ;

x˙1 (0) = −5,823441920555026 10−5 ;

x2 (0) = 4,690345372471773 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 homogene Bewegungsgleichung nach (8.20)   k1 + k2 −k2 . (8.22) M y¨ + K y = 0 , M = diag(m1 , m2 ), K = −k2 k2 Der reelle Ansatz y = v˜ cos ω0t,

Eigenvektor v˜ , Eigenkreisfrequenz ω0

(8.23)

378

8 Projekte

nach Abschn. 3.2.2.1 führt auf das Eigenwertproblem ω02M v˜ = K 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 ≈ 144 rad/s, ω02 ≈ 226 rad/s,

ω01 ≈ 23 Hz 2π ω02 ≈ 36 Hz. f2 = 2π f1 =

(8.25)

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 Ruhe bleibt und die Sekundärmasse m2 mit der Eigenkreisfrequenz des angehängten Feder-MasseSystem schwingt, d. h.  1 k2 ftilgung = ≈ 33 Hz . (8.26) 2 π m2 Den Amplitudenfrequenzgang ermitteln wir mit der Bewegungsgleichung des gedämpften Systems     s s q d1 + d2 −d2 ˆ ˆ M y¨ + Dy˙ + K y = h sin Ωt, D = ; h = (8.27) 0 −d2 d2 mit M , K nach (8.22). Der reelle Lösungsansatz der stationären Schwingung nach Abschn. 3.3.2.1 y = yˆ c cos Ωt + yˆ s sin Ωt führt auf das lineare algebraische Gleichungssystem ⎡ ⎤ 0     ⎢ 0 ⎥ yˆ c K − Ω 2M D ΩD ⎢ =⎣ ⎥ . yˆ s D K − Ω 2M q ⎦ −ΩD 0 Die Maximalamplituden yˆ j = Programmschritten aus:

(8.28)

(8.29)

! yˆ2c j + yˆ2s j in Abhängigkeit von Ω werten wir in den folgenden

8.3 Schwingungstilger mit viskoelastischem Anschlag

379

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

8.3 Schwingungstilger mit viskoelastischem Anschlag

381

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 nachgeschalteten Sign Block 1 für x2 > Δ und 0 für x2 ≤ Δ durchgeschaltet wird. Die Aufschaltbedingung fN ≥ 0 realisieren wir mit dem logischen Relational 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 (Basisfrequenz) Ω – 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 . Zur Ermittlung der Maximal-Amplitude (Spitzenwert)  xˆ = a2 + b2

(8.34)

(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 2 s) der Tiefpässe

8.3 Schwingungstilger mit viskoelastischem Anschlag

385

enthält das stationäre Schwingungssignal ausschließlich die Basisfrequenz Ω . Die Amplitudenwerte 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, Bindungsgleichungen, differenzial-algebraische Gleichungen, M-File, physikalische Modellierung, SimMechanics-Modell und Animation, Gelenkkraftermittlung, Trimming-Mode, Gleichgewichtslagen, Newton-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 drehbar 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 bewegen, 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 Gleitsteine die 5-7 Kolben reibungsarm angelenkt. Die Zylinderbohrungen sind auf einem Teilkreisradius 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 α erreichbar. 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 beschrä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. Dieser Hebelmechanismus rotiert mit konstanter Winkelgeschwindigkeit Ω . Ausgehend von beliebigen Anfangswerten der Hebellage schwingt dieser um seine stationäre Lage. Dieses Schwingungsverhalten 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 rotierenden 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 SimMechanics 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 somit 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

8.4.3

Masse Massenträgheitsmomente bez. S Hebellänge Schwerpunktslage Anlenkmaße Federsteifigkeit Dämpfungskonstante Länge der entspannten Feder Erdbeschleunigung

mH = 1,2 10− 2 kg Ixx = 2,8 kg mm2 , Iyy = 3,3 kg mm2 , Izz = 0,62 kg mm2 ℓH = 24 mm sH = ℓH /2 aH = 7 mm, bH = 20 mm kH = 106 N/m dH = 10−4 kH Ns/m lF = bH + ℓH sin π/8 + mH g/kH sH /ℓH g = 9,81 m/s2

Anfangswerte z. B.

φ0 = π/8 rad; φ˙0 = 0,0 rad/s

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 Koordinaten Z xs (t), Z zs (t), φ (t) ein. Ausgang der Betrachtung ist deshalb die L AGRANGEsche Gleichung 1. Art nach Kapitel 5 d dt



∂L ∂ p˙

T

−



∂L ∂p

T

−



∂gg ∂p

T

λ = Q;

pT = [Z xs , Z zs , φ ]

(8.43)

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 ω 2 2

(8.44)

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 Trot =

1 1 T T K ω T KI I I T IK K ω = Kω KI Kω ,    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

8.4 Axialkolbenverdichter einer Pkw-Klimaanlage

und der Hebeldrehung φ ⎡ T IK

⎤⎡ cos γ 0 − sin φ ⎦ ⎣ − sin γ 1 0 0 0 cos φ

cos φ = T φT γ = ⎣ 0 sin φ

sin γ cos γ 0

389

⎤ 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 die Rotordrehung γ mitmacht ⎡ ⎤ Z xs Zr s = ⎣ 0 ⎦ Z zs

Ir s

und anschließend (Transformation von (Z) → (I)) Ir s

= T Tγ Z r s

I r˙ s

T = T˙ γ Z r s + T γT Z r˙ s ⎡ −γ˙ sin γ −γ˙ cos γ = ⎣ γ˙ cos γ −γ˙ sin γ 0 0

⎤ ⎡ ⎤⎡ 0 cos γ Z xs 0 ⎦ ⎣ 0 ⎦ + ⎣ sin γ 0 0 Z zs

− sin γ cos γ 0

bzw. ausmultipliziert ⎤ ⎡ ⎡ ⎤ −γ˙ Z xs sin γ Z x˙s cos γ I v s = ⎣ γ˙ Z xs cos γ ⎦ + ⎣ Z x˙s sin γ ⎦ . 0 Z z˙s

⎤ ⎤⎡ 0 Z x˙s 0 ⎦⎣ 0 ⎦ 1 Z z˙s

˙ φ˙ zu Die Winkelgeschwindigkeit K ω bilden wir mit den Elementarwinkelgeschwindigkeiten γ, ⎡ ⎤ ⎡ ⎡ ⎤ ⎤ 0 −γ˙ sin φ 0 ˙ ⎣ ⎣ ⎦ ⎣ ⎦ ⎦ . 0 φ φ˙ ω = T + = K φ γ˙ 0 γ˙ cos φ

Damit schreiben wir die kinetischen Energien (8.44) um:   1 mH γ˙2 Z xs2 + Z x˙s2 + Z z˙2s 2 1 1 1 = γ˙2 Ixx sin2 φ + γ˙2 Izz cos2 φ + φ˙ 2 Iyy . 2 2 2

Ttrans = Trot

(8.45)

Die potentielle Energie bildet sich zu V = mH g [1, 0, 0] I r s +

1 kH (Z xs + (ℓH − sH ) sin φ − ℓF )2 , 2

(8.46)

wenn ℓF die Federlänge der entspannten Feder ist, die generalisierte Kraft infolge der Dämpfung

390

8 Projekte

zu ⎡

Q=⎣

−dH

−dH



Z x˙s + (ℓH

− sH )φ˙ cos φ



⎤

⎦. 0  ˙ Z x˙s + (ℓH − sH )φ cos φ (ℓH − sH ) cos φ



(8.47)

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 Multiplikatoren λ = [λ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) 0 1 sH sin φ ∂p −λ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 Bewegungsgleichungen 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 φ   − dH Z x˙s + (ℓH − sH )φ˙ cos φ (ℓH − sH ) cos φ 0 0

(8.49)

− λ1 sH cos φ + λ2 sH sin φ = Z xs − bH − sH sin φ = 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 φ ) 0 = Z z¨s + sH (φ¨ sin φ + φ˙ 2 cos φ ).

(8.50)

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 Seite der obigen drei Differenzialgleichungen nur die zweiten zeitlichen Ableitungen stehen, d. h. wir müssen durch mH bzw. Iyy dividieren.

8.4 Axialkolbenverdichter einer Pkw-Klimaanlage

8.4.4

391

Das M-File, erste Ergebnisse

Zu 2): Da wir die Parameter aus Tabelle 8.2 einerseits im M-File für die Simulation unter MATLAB 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 Differenzialgleichung (8.49) aus [52] sind sie teilweise als globale Variable zu vereinbaren. Die konsistenten Anfangswerte p (0), 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 selbsterklä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) Bindungskrä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 Parameter 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 Ursprü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, Gleithülse aus, jedem Körper ist ein Body Block zuzuordnen. Die Zwangsdrehung des Rotors – Winkel, Winkelgeschwindigkeit, -beschleunigung – erzeugen wir mit dem MATLAB Function Block1 . Die Anbindung zur SimMechanics-Umgebung erfolgt mit dem Joint Actuator Block. Die Rotorlagerung 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ämpferElemente einerseits zwischen zwei Body Blöcken, andererseits zwischen Gleithülse und Ground – Dreh- und Inertial-Achse fallen zusammen – einzubringen. Die restlichen Komponenten können 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

8.4 Axialkolbenverdichter einer Pkw-Klimaanlage

393

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 Kraftkomponenten 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 vorangegangenen 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 Hebel.m angegeben. Bild 8.29 zeigt ein Ergebnis. Danach erhalten wir – wie zu erwarten – übereinstimmende 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ängigkeit von anfänglichen Störungen eine mögliche stationäre Lösung oder eine Gleichgewichtslage. 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, andererseits 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 zs 0

= 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 )− ⎥ ⎥ 2   f (pp0 ) = ⎢ ⎣ kH Z xs + (ℓH − sH ) sin φ0 − lF (ℓH − sH ) cos φ0 − λ10 sH cos φ0 ⎦ . (8.51) 0 Z xs0 − bH − sH sin φ0

Ausgehend von Schätzwerten zur Gleichgewichtslage können wir (8.51) mit Hilfe des N EWTONVerfahrens näherungsweise lösen. Hierzu bilden wir die TAYLOR-Entwicklung bis zum linearen Glied  ∂ f  ! Δpp = 0 , (8.52) f (pp0 + Δpp) = f (pp0 ) + p 0 0

8.4 Axialkolbenverdichter einer Pkw-Klimaanlage

woraus sich die Verbesserung  ∂ f  p f (pp0 ) Δp = − p 0 0

395

(8.53)

errechnet. Hiermit schreiben wir die Iterationsfolge pk−1 Δppk−1 = −JJ −1 (ppk−1 0 0 ) f (p 0 ), J regulär

(8.54)

pk−1 p k0 = p k−1 0 + Δp 0

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 =

0,525 rad ≈ 30° , 2,616 rad ≈ 150°

Z xs0

= 0,026 m,

λ10 = 2845,6 N,

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 Gleithü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 Auswertung, Ü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 insbesondere 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 vorzunehmen. 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 Drehträgheit bezüglich S1 Schwerpunktsabstand Lagerabstand 01 ,02 , 01 ,03

m1 C1 s1 ℓ

0,613 1,64 10−2 0,1065 0,18

kg kg m2 m m

m2 = m 3 C2 = C3 s2 = s 3

0,210 6,53 10−4 0,1145

kg kg m2 m

9,81

m / s2

Nebenpendel Masse Drehträgheit bezüglich S2 , S3 Schwerpunktsabstand Erdbeschleunigung

g

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 Gleichgewichtslage gemessen, womit der Koordinatenvektor q = [ϕ1 , ϕ2 , ϕ3 ]T ,

Minimalkoordinaten

(8.55)

fest liegt. Die Bezugspunkte der körperfesten Koordinatensysteme sollen mit den Massenmittelpunkten (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˙ si ermitteln wir symbolisch ∂rr s1 ∂rr s1 q˙ q˙1 oder r˙ s1 = ∂ q1 ∂qq ∂rr s2 ∂rr s2 ∂rr s2 = q˙1 + q˙2 oder r˙ s2 = q˙ ∂ q1 ∂ q2 ∂qq ∂rr s3 ∂rr s3 ∂rr s3 q˙ q˙1 + q˙3 oder r˙ s3 = = ∂ q1 ∂ q3 ∂qq

r˙ s1 = r˙ s2 r˙ s3

(8.57)

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 T =

 1 m1r˙ Ts1 r˙ s1 + m2r˙ Ts2 r˙ s2 + m3r˙ Ts3 r˙ s3 + ω T1I 1ω 1 + ω T2I 2ω 2 + ω T3I 3ω 3 2

(8.60)

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 symbolische Auswertung ∂ ∂ q˙



∂T ∂ q˙

T

q¨ +

∂ ∂qq



∂T ∂ q˙

T

q˙ +



∂ (V − T ) ∂qq

T

=0

(8.62)

8.5 Dreifachpendel

399

oder kurz M (qq)¨q + f (qq, q˙ ) = 0 .

(8.63)

Zur Ermittlung der Massenmatrix M sowie der Vektorfunktion f in (8.63) dient der Programmausschnitt 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

∑ i=1

 T   J Ti (p˙ i − f ei ) + J TRi L˙ i − m ei = 0 .

(8.64)

Für die JACOBI-Matrizen der Translation J Ti und der Rotation J Ri gilt J Ti =

∂rr si , ∂qq

J Ri =

ωi ∂ω . ∂ q˙

(8.65)

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˙ i = mir¨ si ,

L˙ i = I iω˙ i .

(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:      fe z¨1 M1 0 =0 (8.68) − JT z˙2 me 0 M2 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 ; M 1 = diag (m1E 3 , m2E 3 , m3E 3 ) ;

J ∈ R9,3 ,

M 1 ∈ R9,9 , E 3 ∈ R3,3

M 2 = diag (II 1 , I 2 , I 3 ) ; M 2 ∈ R9,9 , T  z 1 = r Ts1 , r Ts2 , r Ts3 ; z 1 ∈ R9 (inertiale Basis) T  z2 = ω T1 , ω T2 , ω T3 ; z2 ∈ R9 , ( ωi jeweils in der körperfesten Basis), T  f e ∈ R9 , f e = f eT1 , f eT2 , f eT3 ; T  m e = m Te1 , m Te2 , m Te3 ; m e ∈ R9

(8.69) (8.70) (8.71) (8.72) (8.73) (8.74) (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˙1 = z˙1 (qq, q˙ ),

z 2 = z 2 (qq, q˙ ) .

Die zeitlichen Ableitungen lassen sich mit (8.65), (8.69) in der Form z˙1 = J T q˙ und z 2 = J R q˙ und

z¨1 =J˙T q˙ + J T q¨ , z˙2 =J˙R q˙ + J R q¨

schreiben. Setzen wir (8.76) noch in (8.68) ein, dann folgt   fe J TM ⋆J q¨ + J TM ⋆J˙q˙ − J T =0 me

(8.76)

(8.77)

M 1 , M 2 ) aus (8.68). Die Elemente M , f aus (8.63) mit der Blockdiagonalmatrix M ⋆ = diag(M sind mit (8.77) direkt zuzuordnen. Der folgende Programmausschnitt von Drei_PNE.m aus [52] zeigt die symbolische Ermittlung der Elemente der Bewegungsgleichung (8.77) in der Form von (8.63).

8.5 Dreifachpendel

401

%---- 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); %---- JACOBI-Matrizen der Rotation J_R1=jacobian(om1,q_p); J_R2=jacobian(om2,q_p); J_R3=jacobian(om3,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 ⎥ ⎣ ⎦ 2 m2 ls2 sin(q1 − q3 ) 0 C2 + m2 s2 ⎡

⎢ ⎢ f =⎢ ⎣

s2 m2 cos (q1 − q2 ) q˙ 22 l − s2 m2 q˙ 23 l cos (q1 − q3 ) + gm1 s1 sin (q1 )   −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˙ = [qqT , q˙ T ]T , x ∈ R2 f ist aus (8.63) bzw. (8.77) die nichtlineare Zustandsgleichung     q˙ q˙ x˙ = (8.78) = f ⋆ (qq, q˙ ) M (qq)−1 f (qq, 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 numerischen Werte und bilden gleichzeitig f ⋆ = M −1 f , das Ergebnis ist vom Typ sym: %---- Parameter für Simulation %---- Hauptpendel m1=0.613; s1=0.1065; l=0.18; C1=1.6408e-02; %---- Nebenpendel m2=0.210; s2=0.1145; C2=6.53e-04; g=9.81; %---- Parameter substituiert M=subs(M); f=subs(f); f_star=inv(M)*f;

% % % %

Masse Schwerpunktsabstand Lagerabstand, Quertraverse Massenträgh. bez. Schwerpunkt

% % % %

Masse Schwerpunktsabstand Massenträgheitsmoment Erdbeschleunigung

% Massenmatrix % Vektorfunktion % Vektorfunktion M^(-1)*f

Die Vektorfunktion f_star ist immer noch exakt dargestellt, dadurch werden die Zahlenwerte 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 Function 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 – zweckmäß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); -eval(f_star)];

% Differenzialgleichung

8.5 Dreifachpendel

8.5.4

403

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˜ k , y˜ k genügen dann: Hauptpendel:



x˜ T1 (ti ) y˜ T1 (ti )



Nebenpendel:



x˜ Tk (ti ) y˜ Tk (ti )





 x T1 = T 1 (ti ) yT  1  Null-Lage = T k (ti )

   x Tk (−1)k−1 ℓ T + 1 (ti ) , 0 yT     k  Lage von 02,3 Null-Lage 

k = 2,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]); axis equal, L=axis; axis off set(gca,’Visible’,’off’)

% Achsskalierung % Achsen ausblenden

%---- 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

8.5 Dreifachpendel

405

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 Bewegungsgleichung (8.63) – vgl. Abschn. 2.6 – p(qq, q˙ , q¨ ) := M (qq)¨q + f (qq, q˙ ) = 0 um die Gleichgewichtslage q ≡ 0 . Die TAYLOR-Reihenentwicklung bis zum linearen Term ergibt p (qq, q˙ , q¨ ) ≈ p (00, 0 , 0 ) +

∂p ∂p ∂p |0 Δ¨q + |0 Δ˙q + |0 Δqq ≈ 0 q q ∂¨ ∂˙ ∂qq

bzw. wegen p (00, 0 , 0 ) = 0 M (00) Δ¨q +

∂f ∂f |0 Δ˙q + |0 Δqq = 0, ∂ q˙ ∂qq

so dass die lineare Variationsgleichung M 0 Δ¨q + P Δ˙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 =

Q =

3.6969e-002 0 0 6.4044e-001 0 0

0 3.4062e-003 0 0 2.3588e-001 0

0 0 3.4062e-003,

0 0 2.3588e-001

P = 0 0 0

0 0 0

0 0 0

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) Anfangswerte ϕ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 = f (qq, 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 Nebenpendels 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 Energieaustausch statt, wie dies auch in Bild 8.35 für die großen Anfangswerte

8.5 Dreifachpendel

ϕ1 (0) = 0, ϕ2 (0) = ϕ3 (0) = π, ϕ˙ i (0) = 0,

407

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 Funktionen 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 hinaus müssen mindestens die Schwerpunkte und die Gelenkpunkte in ausgewählten Koordinatensystemen angegeben werden. Zusätzliche Punkte dienen nur zur Vervollständigung des Modells im Visualisierungsfenster, siehe Kapitel 7. Bezüglich der gewählten körperfesten Koordinatensysteme 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 System 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 Koordinatensysteme 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

8.5 Dreifachpendel

409

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 Umgebung, 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 aktuellen Anfangswerte der Körper Joint Initial Condition Blöcke verwenden. Messungen der Gelenkwinkel (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: Simulation/Configuration Parameters unter SimMechanics/Visualization das Visualisierungsfenster 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 kleinen Zeitfensters 0 ≤ t ≤ 20 s bei hoher Genauigkeit, z. B. RelTol 1*10−6 , gute Übereinstimmungen erreicht werden. Auch bei leicht abweichenden Anfangswerten in den einzelnen Methoden unterscheiden sich die Schwingungen immer stärker mit fortschreitender Zeit. Diese Abweichungen 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öllig 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. Ausgehend von festgeschriebenen Bewegungen des Haupt- und der Nebenpendel sind die daraus resultierenden 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 Rotationsbewegung ϕ 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 Nebenpendel 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 auszuwählen. In Bild 8.40 sind die Gelenkmomente m0 j in den Drehpunkten 0 j dargestellt. Entsprechend 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 Anteile 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 Fahrbahn 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 Verhalten, 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 mittels eines geschwindigkeitsabhängigen Dämpfungskoeffizienten d(vD ) = α

c1 (vD − α)  + c2 , für vD < vlim , vD = x˙D − x˙R  vD − α 2 1+ α

'

approximiert, wobei α Übergangsparameter, α > 0 stetiger Verlauf von d(vD ), vgl. Bild 8.41 c2 = (de + dc )/2. c1 = (de − dc )/2, Damit gilt für die viskose Dämpferkraft  d(vD )vD für vD < vlim FDD = . d(vlim )vlim + db (vD − vlim ) für vD ≥ vlim

(8.79)

(8.80)

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 punktuell 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 Simulation 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

8.7

413

Dynamik des Levitron-Kreisels

Schlagworte: Gyroskopisches System, komplexe Bewegungsgleichungen, Übergang auf neue Variable, 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 Rotation versetzt. Danach wird der Kreisel mit der Lifterplatte so weit angehoben, 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 Kreiselparameter (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 Winkelgeschwindigkeit Ω bezüglich der Figurenachse auf das instabile Lagerungsprinzip – vgl. folgende 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 Freiheitsgrade, 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ämpfungsfreie MGK-System die Bewegungsgleichung M y¨ + Gy˙ + Ky = 0 , mit der symmetrischen Massenmatrix M = diag(m, m, A, A, m),

MT = M,

der schiefsymmetrischen gyroskopischen Matrix ⎡ ⎤  0 2,2 0 2,2 0 2,1 0 G = ⎣ 0 2,2 G˜ 0 2,1 ⎦ , G˜ = −ΩC 0 1,2 0 1,2 0 sowie der symmetrischen Steifigkeitsmatrix ⎡ ⎤ K r K ϕr 0 2,1 T K ϕϕ 0 2,1 ⎦ , K T = K K = ⎣ K ϕr 0 1,2 0 1,2 kz

(8.81)

ΩC 0



,

G G T = −G

(8.82)

(8.83)

414

8 Projekte

mit den Submatrizen    kr 0 0 , K ϕr = Kr = −kϕr 0 kr

kϕr 0



, K ϕϕ =



kϕϕ 0

0 kϕϕ



,

(8.84)

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 Trägheitsmomente Axial-Steifigkeit Radial-Steifigkeit Kipp-Steifigkeit Koppel-Steifigkeit

m = 20 10−3 kg A = 1,32 10−6 kg m2 C = 2,20 10−6 kg m2 kz = 0,82 N/m kr = −0,43 N/m kϕϕ = −8,6 10−3 Nm/rad kϕr = 0,11 N/rad

Folgende Punkte sind zu bearbeiten: 1. Bereiten Sie die Bewegungsgleichung für eine numerische Stabilitätsuntersuchung mit Hilfe 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 (Eigenwertkurven) 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 Strecke, 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 Roboter2 nach Bild 8.42 und [37] sollen die hier dargestellten Methoden zur mathematischen Modellierung angewendet werden. Wesentlich soll eine systematische Herleitung und symbolische Umsetzung in MATLAB der nichtlinearen Bewegungsgleichungen dieses räumlichen Modells sein. Bezüglich der Stabilisierung werden erste Reglerentwürfe diskutiert. Die Parametrisierung erfolgte 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 tangentiale 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 starren Körper, insbesondere der des Aufsatzes, seien diagonalförmig und jeweils auf den Schwerpunkt bezogen. Zur Dämpfung der Rollbewegung der Kugel werden sehr einfache Dämpfungsbzw. Reibmodelle, die im Kontaktpunkt P wirken, eingeführt. Grund ist, dass im eingeschwungenen 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 Auslenkungen simuliert werden. Wie unschwer zu erkennen ist, liegt ein instabiles System vor, welches durch einen Regeleingriff über die Omniwheels stabilisiert werden muss. In einem ersten Entwurf bilden wir die hierfü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 MotorWinkelgeschwindigkeiten werden Richtung, Geschwindigkeit und Drehung um die eigene Achse festgelegt. Z. B. für eine geradlinige Bewegung müssen zwei Rädern gleiche Winkelgeschwindigkeiten ü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 Differenzialgleichungen bezüglich Minimalkoordinaten symbolisch bzw. numerisch überführt werden. Da die Energiebilanzen und die damit hergeleiteten Elemente der Bewegungsgleichungen, Massenmatrizen und Vektorfunktionen, erheblichen Umfang annehmen, ist es rechentechnisch vorteilhaft 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örperfesten 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 Bewegungsgleichungen 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 .          Aufsatz Wheels Kugel

(8.86)

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 differentiellalgebraische 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.

W. D. Pietruszka, MATLAB® und Simulink® in der Ingenieurpraxis, DOI 10.1007/978-3-8348-8630-9, © Vieweg+Teubner Verlag |Springer Fachmedien Wiesbaden GmbH 2012

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ößenregelsystemen. 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 < , , >= größer, größer gleich, 26 { } Cell Array Element, 25 Algebraische Schleife, 205 – Elimination, 207 algebraisches Gleichungssystem, 87, 145, 151, 373 – inhomogen, 149 f, 155 – linear, 378 – nichtlinear, 123, 344 Amplitudenfrequenzgang, 50, 377 Analogiebeziehung, 95 analytische Lösung, 370 Anfangswert, 149, 160 – Anpassung, 373 – konsistent, 251, 255, 273, 391 Anfangswertproblem, 225, 241, 254 Animation, 66 – 3D-Modell, 73 – Drehbewegung, 76, 80 – Dreifachpendel, 403 – EraseMode, 67 ff – – background, 67 – – none, 67 – – normal, 67 – – xor, 67 – Fachwerk, 71

– Flächenmodell, 68 – getframe, 68, 76 – Linienmodell, 70 – – komplexe, 72 – Modellerstellung, 66 – Movie, 67 f, 70 – Rotorelement, 73 – Schraubenfeder, 71 – Volumenmodell – – cylinder, 77 ff – – ellipsoid, 77 – – sphere, 77 ff – Wellenelement, 73 Anonymous Function, siehe Function Anstückelmethode, 371 Arbeitspunkt, siehe Schwingung, 337 Ausführbarer Code, Funktionstaste F9, 6 Ausgangsmatrix, 145, 195 Backslash-Operator, 20 f Balancierender Roboter, 414 ff Basisvektor, 98 Befehlsübersicht – 2D Plot-Befehle, 47 – 3D-Grafik, 60 – Achs-Skalierung und Grafik-Beschriftung, 49 – Color (Grund-, Mischfarben), 56 – Ein- und Ausgabebefehle, Konvertierung, 32 – Farben, 48 – Grafikfenster-Befehle, 46 – Linien, 48 – Linien-, Marker-Spezifikationen und Farben, 56 – Logische Operatoren, 26 – Mathematische Funktionen, 9 – Operationszeichen, Built-In Variable, Online-Hilfe, 6 – Optischer Effekt, Ausleuchten, 65 – Script- und Function-Befehle, 30 – Variablenverwaltung, 8 – Vektor- und Matrix-Formulierung, 11 – Vektor- und Matrix-Operationen, Built-In Functions, 17 – Vergleichsoperatoren, 26 – Verzeichnis- und File-Verwaltung, 31 – Verzweigungen und Schleifen, 27 Beobachtbarkeitsmatrix, 360 Beobachterentwurf, 367

W. D. Pietruszka, MATLAB® und Simulink® in der Ingenieurpraxis, DOI 10.1007/978-3-8348-8630-9, © Vieweg+Teubner Verlag |Springer Fachmedien Wiesbaden GmbH 2012

422

Stichwortverzeichnis

Beschleunigung, 100, 102 Bewegungsgleichung – analytische Methode, 95 – autonom, 97, 310 – D’Alembert, 115, 243 – explizite Vektor-Form, 97 – implizite Vektor-Form, 97 – Klassifizierung, 133 – Lagrange, siehe Lagrange – linear, 132 – Newton-Euler, siehe Newton-Euler – nichtautonom, 97, 312 – nichtlinear, 125, 233 – Normalform, 97 – synthetische Methode, 95 – Trägheitskopplung, 205 Bewegungsraum, 61 Bifurkationen, 250 Bindungen, 252, 262, 338 – Übergang, 269 – JACOBI-Matrix, 269 – Beschleunigungsebene, 254 – explizit, 95 – Geschwindigkeitsebene, 254 – holonom, 268 – holonom rheonom, 252 – holonom skleronom, 252 – implizit, 95 – kinematische, 268 – Lageebene, 254 – Mannigfaltigkeiten, 249 – nichtholonom, 268, 416 – Schleifen-Schließbedingung, 262 – versteckte, 255 – Zwangsbedingungen, 252 Bodenkontakt, 412 Butcher-Tabelle, 166 Butterworth-Tiefpass, 190, 383 C Code S-Function, siehe Simulink Code-Beschleunigung, 42 Code-Erzeugung, 60 – Show Code, 60 Computeralgebra, siehe auch Symbolic Math Toolbox – MuPAD, 81 – symbolische Auswertung, 400 – symbolische Variable, 106 Control System Toolbox, 369 – acker, 361, 369 – bode, 156 ff – dlqr, 361 – freqresp, 156, 158 – impulse, 160, 231 – initial, 231 – lqr, 361 – lqry, 361

– lsim, 231 – place, 361, 369 – Riccati-Regler, 361 – ss Zustandsmodell, 231 – step, 160, 231 Corioliskraft, 351 Coulomb-Reibung, 289, 291, 317, 324, 345 Dämpfungsmaß – Lehrsches, 147 – logarithmisches Dekrement, 147 Datentyp, 7 – class, siehe MATLAB-Befehl – double, single, int8,..., 7 – sym, siehe Symbolic Math Toolbox Defekt, 91 Desktop – Command History, 2 – Command Window, 2 – Current Directory, 2 – Workspace, siehe Workspace differenzial-algebraische Gl., 226, 249, 351, 416 – DAE, 249 – Deskriptorform, 253 – Index, 249 ff, 352 – semi-explizit, 254, 257 Differenzialgleichung – autonom, 225 – explizit, 225 – gewöhnlich, 249 – – Index 0, 261 – implizit, 225, 227, 272 – kinematische, 253 – kinetische, 253 – linear, 131, 228 – nichtlinear, 233, 243 – semi-explizit, 251 – Steifigkeit, 169 Doppelpendel, 105, 111, 117, 121, 124, 262 Drall, 109 f, 116, 143, 399 – Stabilisierung, 143 Drallsatz, 95, 108 ff, 125, 127 Drehgelenk, 341, 345, 392, 407, 408 Drehtransformation, 100 Dreifachpendel, 396 Dreipunkt-Schaltlogik, 289, 294, 324 Drift, 259 f, 265, 351 f Editor, 30 – Cell divider, 34 Eigenschwingung, 131, 134 ff Eigenschwingungsform, 138 ff, 144 – Schwingerkette, 141 Eigenwerte, 137 ff, 414 Eigenwertproblem, 91, 137 ff, 142, 144, 373 f, 378 – condeig, 91

Stichwortverzeichnis

– gewöhnliche, 135 – in MATLAB, 134 ff – spezielle, 135 – Stabilitätsaussagen, 137 – Zustandsgleichung, 143 Einschrittverfahren, 164 elektrisches Netzwerk, 229 Elementardrehung, 99 f Elementarwinkelgeschwindigkeit, 101 erzwungene Schwingungen, siehe Schwingung Euler-Approximation, 37 Euler-Winkel, 100 Event, siehe Unstetigkeit Feder-Animation, 80 FFT-Analyse, 210 Freiheitsgrad, 104, 416 – holonome Bindung, 266 – nichtholonome Bindung, 268 frequenzmodulierte Schwingung, 377 Function – Anonymous Function, 41, 241 f – clear, 30 – Function Function, 35 – Function Functions, 37 – Function Handle, 36 – inline, 30 – Kopfzeile, 30 – Nested Function, 38 – – Parent Function Workspace, 38 – Schlüsselwort, 35 – Standard Function, 35 Fundamentalmatrix, 145, 158 Gelenkkräfte, 391 Geschwindigkeit, 100 – verallgemeinerte, 270 Gleichgewichtslage, 123, 131, 149, 160, 200, 337, 340 f, 394, 397, 413 – Linearisierung, 124, 129, 405 Grafik, 2D, siehe Grafik-Befehl Grafik, 3D, siehe Grafik-Befehl Grafik-Befehl, 44, 47, 49, 60 – Achsen und Beschriftung, 49 – Animation, siehe Animation – axis, 35, 49 f, 61, 76, 140, 404 – box, 60 f, 63 – clf, 46, 47, 50, 57 – close, 46 – close all, 46, 89 – comet, 47 – comet3, 60 – contour, 60 – contour3, 60, 63 – cplxroot, 180 – cylinder, 77, 78 ff

– DefaultLineLineWidth, 45 – delete, 46 – drawnow, 46, 70, 80 – ellipsoid, 77 – ezplot, 89 – FaceAlpha, 71 – figure, 46, 50, 56 f, 61, 404 – fill, 67, 71, 404 – fill3, 63, 75 – findobj, 45, 53 ff – fplot, 47 – gca, 44, 49, 56, 139, 404 – gcf, 44, 46, 57, 139, 183, 404 – get, 45 ff, 53 ff – gplot, 72 – grid, 49 f, 63 – Handle Graphics, 53 – hold on, off, 37, 47, 49 f, 61, 75, 241 – interpreter – – TEX-, LATEX-Mode, 49 – legend, 49 f – line, 47, 57 f – Linien-Eigenschaften, 56 – linkaxes, 51 – loglog, 47 – Marker-Eigenschaften, 56 – mesh, 60, 63, 77 – meshgrid, 60, 63, 68, 241 – nextplot, 54 ff – patch, 60, 62 ff – plot, 47, 49 f, 56 f, 404 – plot3, 60 f, 80, 180 – plotstil, 47 ff – – Color, 48 f – – Line Style, 48 – – Marker, 48 – plottools on/off, 58 – quiver, 241 – rotate, 80 – semilogx, 47 – semilogy, 47 – set, 45 ff, 53 ff, 68 ff, 79 ff – shg, 46 – sphere, 77 ff, 80 – spy, 16, 47 – stairs, 47 – stem, 47 – subplot, 46 f, 50, 63 f, 139 – surf, 60, 63 f, 68 ff, 74 f, 77 ff – surf2patch, 63 – surfc, 60, 64 – surfl, 67 – text, 49 f, 57 – title, 35, 49 f, 183 – view, 60 f, 63 – waterfall, 60, 63

423

424

Stichwortverzeichnis

– xlabel, ylabel, 49 f, 57, 61, 89, 183 – xlim, ylim, zlim, 49, 140 – zlabel, 60 f Grafik-Objekt-Hierarchie, 44 Grafikfenster, 46 – figure, siehe Grafik-Befehl – subplot, siehe Grafik-Befehl Gravitationsvektor, 340 gyroskopischer Einfluss, 141 – Eigenwerte, 142 – Kreiseleinfluss, 143 Handle Graphics, 45, 53 ff Hauptträgheitsmoment, 350 Hebelmechanismus, 388 help, siehe MATLAB-Befehl Help Browser, 4 Hilfs-Schaltfunktion, 292, 325 HTML Dokument, 34 Hubschwingungen, 411 I-Anteil, 356 Impuls, 116, 399 Impulssatz, 95, 108, 111, 113, 125 Index, 254 instationäre Schwingungen, 377 Integralanteil, 362 Integrationsaufruf, 238 – Optionen, 238 Integrationskonstante, 140, 373 Integrationsverfahren – Dormand-Prince, 167 – Einschrittverfahren, 164 f – Euler, 168 – – rückwärts, 165 – – vorwärts, 165 – explizit, 165, 167 – implizit, 165, 167 – Mehrschrittverfahren, 164 f, 168 – – Adams-Bashforth, 165, 168 – – Adams-Moulton, 165, 168 – – BDF, 164, 165 – – NDF, 164 – Prädiktor-Korrektor, 165, 168 – Runge-Kutta, 164 – Trapez-Regel, 167 Integratorwahl, 170 – Diskontinuität, 204 Interaktive Plot-Erstellung, 58 inverse Dynamik, 352 Jacobi-Matrix, 108, 115–121 – Zwangsbedingungen, Bindungen, 253 JIT-Accelerator, 5 Jordan-Matrix, siehe Symbolic Math Toolbox Kardan-Winkel, 99 f

– Kardangelenk, 105 – Kugel, 270 Kaskadenregler, 358 Kelvin-Voigt-Modell, 226 Kennlinienumschaltung, 284 Kinematik, 97 – Lage, 97 – Mehrkörpersystem, 103 – Orientierung, Drehung, 97 Knotenlinie, 99 Kollokation, 303 konservatives System, 136, 203 – Eigenwerte, 137 – gyroskopischer Einfluss, 141 Koordinaten – abhängige, 95 – generalisierte, 104 – redundante, 252, 262 – unabhängige, 95 – verallgemeinerte, 116 Koordinatensystem, 98 – CS, 338 ff – Inertialsystem (I), 98 – körperfest (K), 98 – raumfest, 98 – World (W), 340 Kreuzprodukt, 111 Kurbeltrieb, 262 Kurzschluss-Operator, 27 Lageregler, 358 Lagrange, 95, 118, 121 – Formalismus, 95 – Gleichung 1. Art, 252, 271, 388 – Gleichung 2. Art, 96, 108, 118, 121, 125, 398 – Multiplikator, 253, 351, 388 Levitron-Kreisel, 228, 413 ff lineare Gleichungssysteme, 20 – überbestimmtes, 22 – Backslash-Operator, 20 – Beispiele, 21 – direkte Methoden, 20 f – Gradientenmethoden, 21 – iterative Methoden, 21 f – Residuen Verfahren, 21 – Symmetrisches LQ-Verfahren, 21 – unterbestimmtes, 22 lineare Schwingungsmodelle, 131 ff Linearisierung, 122, 129, 405 Lissajous-Figuren, 221 magnetisch gelagerter Rotor, 355 – aktive Stabilisierung, 356 MATLAB Function, 35 ff MATLAB Script, 33 ff MATLAB-Befehl

Stichwortverzeichnis

– abs, 9, 27, 29, 38 f, 42, 138, 154, 158, 218, 286 f, 297 – addpath, 31 f – angle, 9 f – asin, 264 – atan, atan2, 9, 50 f, 61 f, 151 f – bicg, 21 – bicgstab, 21 – blkdiag, 117 – break, 27 – bvp4c, bvp5c, 303 ff – bvpinit, 306 – bvpset, 306 – cd, 31 – cell, 25 – – cellplot, 25 – cgs, 21 – char, 24 – chol, 21 – class, 6, 8, 83 – clear, 8, 30 – condeig, 91 – conj, 9 f – continue, 27 – ctranspose oder ’, 17 – decic, 257, 261 – det, 17, 91 – deval, 241, 307 – diag, 11 ff, 91, 113 f, 117, 140, 144 f, 258, 342, 374, 391, 401 – diary, 8 – dir, 31 – disp, 32, 122, 179 – doc, 4 – Doppelpunkt-Operator, 11 ff – double, 6 f, 16, 25, 83 ff, 93 ff – eig, 17, 91, 135, 138, 374, 405 – eigs, 135, 144 – end Op., 11, 50, 61, 283, 286, 374 – eps, 6 – error, 30, 218 – eval, 30, 41, 50, 93 f, 402 – exist, 26 – exp, 9, 84, 86 ff, 94, 145, 154, 158 f, 374 – expm, 145, 160 – eye, 11 ff, 91, 108, 117, 144, 158, 195, 374, 401 – feval, 30, 36 – find, 17 – fliplr, 11 – fopen, 32 f – for Schleife, 27, 28 ff, 38, 42, 50 ff, 70, 76 ff – format, 6 – fprintf, 32, 179, 325 – global, 30, 36, 218, 245 f, 264, 283, 391 – help, 4, 6, 30 – helpwin, 4

425

– if Abfrage, 27, 37, 42, 50, 91, 218, 297, 325, 405 – imag, 9, 144, 145 – inline, siehe Function – input, 32 f, 180, 286 – int2str, 32 – interp1, 241 – inv, 17, 91, 154, 158, 264 f, 402 – isempty, 30, 33, 199 – length, 17, 50, 91, 117, 144, 151 f, 404 – linsolve, 17, 21, 145 – linspace, 11, 35, 37, 50, 61, 70 f, 73, 140, 145, 151 f, 160, 241, 374, 402 – load, 8 – log, log10, 9 – logspace, 11 – lookfor, 4, 31 f – lu, 21 – min, max, 17, 61, 138, 297 – nargchk, 30 – nargin, nargout, 30, 37 – nthroot, 9 – num2str, 32, 35 – odeplot, 241 – odeset, 238 ff, 251, 258, 283 – odex, 164 ff – odexx, 226, 238 ff – – ode113, 168, 204 – – ode15i, 272 – – ode15s, 170, 204, 251 ff, 258, 391 – – ode23, 283 – – ode23s, 204 – – ode23t, 251 ff, 391 – – ode45, 204, 245, 258, 263 – ones, 11, 13, 23, 27, 61, 64, 73, 75 f, 241, 273, 404 – path, 31 – pause, 32, 70, 404 – persistent, 30, 36 – pi, 6 – prod, 17 – Profiler – – profile on, 42 – – profile viewer, 42 – Punktoperation, 132 – – elementweise Verknüpfung, 16 – pwd, 31 – qmr, 23 – quiver, 241 – rand, 11, 15, 84 – rank, 17, 91, 360 – real, 9, 145, 154, 158, 374 – realmax, realmin, 6 – repmat, 11, 14 – return, 30, 33, 37 – rmpath, 31 f – rref, 21 – save, 8

426

Stichwortverzeichnis

– sign, 9, 218, 286 f – sin, cos, 9, 18, 35, 41, 61, 70, 75 f, 86 f, 93, 107 f, 151 f, 264 ff, 391, 404 – single, 6 f, 12, 16, 25, 93 – size, 17, 61, 73, 75 f, 218 – sort, 17, 91, 138, 144 – sparse, 11, 15 – sprintf, 32, 50 – sqrt, 9, 50, 61, 83 f, 138, 151 ff, 163, 284, 378 f, 405 – ss, 158 – struct, 24 – sum, 17 – switch, 27, 29 – tan, 9 – tic, toc, 28, 32 – transpose oder .’, 17 – vectorize, 94 – what, 31 – which, 31 – while Schleife, 27, 39, 286 ff – who, whos, 8 – xor, 26 – zeros, 11, 13, 23, 28, 117, 144, 151 f, 154, 158, 195, 273, 374, 401 MATLAB-Element – 3D-Matrix, 23, 152 – Anonymous Function, siehe Function – Ausgabeformat, 6 – Blockdiagonalmatrix, blkdiag, 117 – Built-In Variable, 6, 8 – Cell Array, 24 f – Code Analyzer, Code Check, 35 – Command Window, Fenster, siehe Desktop – Desktop, 2 – Diagonalmatrix, 13 – – Haupt-, Neben-Diagonalelemente, 14 – Doppelpunkt-Operator, 14 – Einheitsmatrix, 12 – Einsmatrix, 12 – Elementansprechung, 14 – Elementfolgen, 12 – Function Handle, siehe Function – global Variable, siehe MATLAB-Befehl – Inline Function, siehe Function – komplexe Variable, 7 – mathematische Funktionen, 9, 16 – Matrix-Operationen, 16 – mehrdimensionale Felder, 23 – Nested Function, 35, 311 – Not a Number, NaN, 6 – Nullmatrix, 12 – Online-Hilfe, 4, 6 – Operationszeichen, 6 – persistente Variable, siehe MATLAB-Befehl – Profiler, 35, siehe Profiler – Punktoperation, 132, 147

– Structure, 24, 286 – – struct, siehe MATLAB-Befehl – Unendlich inf, 6 – Value Editor, 3 – Variable Editor, 8 – Variablenverwaltung, 8 – Vektor- und Matrix-Formulierung, 11 – Vektor-Operationen, 16 – Vergleichsoperatoren, 26 – While-Schleife, 28 – Workspace Browser, 8 – Zeichenketten, 24 Matrixformulierung, 96 MATRIXx, 1 Mehrkörpersystem, 95, 335 – Baumstruktur, 267, 351 – geschlossene Schleifen, 351 – mechanisch, 254 – Mehrkörpermodell, 351 – MKS, 95 – offenen Schleife, 256 – Schleifensystem, 267 Mehrschrittverfahren, 168 Minimalgeschwindigkeiten, 235 Minimalkoordinaten, 95, 104, 249, 266 Mitnahme-Effekt, 313 Mitnahme-Effekte, 210 modellbasierter Entwurf, 391 Modellbildung, 95 – Programm-Code, 107 f, 113 ff, 117, 122, 124 Multiplikator – Elimination, 260 – Lagrange, siehe Lagrange MuPAD, 81 Nebenbedingung, 249 Nested Function, siehe Function Newton-Euler – Formalismus, 399 – Gleichung, 116 – Methode, 95, 111, 115, 120 f, 126 Newton-Raphson-Verfahren, 123 – Newton, 29, 39, 344, 394 nichtkonservatives System, 147 nichtlineare Schwingungen, 396 Normalkraft, 264 O-Matrix, 1 objektorientiert, 336 Octave, 1 Omniwheel, 415 Orthogonalmatrix, 99 OutputFcn, 242 Parameterempfindlichkeit, 375 Partikularlösung, 373

Stichwortverzeichnis

PD Regler, 359 Pendel, 256 Permanentmagnet, 355 Phasenebene, 61, 90, 235, 302 Phasenfrequenzgang, 50 physikalische Modelle, 335 PID Regler, 359 Pkw-Klimaanlage, 353, 386 Plot-Befehle, siehe Grafik-Befehl Plot-Umgebung, 58 – Figure Palette, 58 – Plot Browser, 58 – plottools on/off, 58 – Property Editor, 59 präallozieren, 28, 43 Profiler, 35 – Report, 42 Programm – Cell divider, siehe Editor – Code Analyzer, Code Check, 35 – Zellen (Cells), 34 Projektionsmethode, 352 Punktoperation, 148 Randwertproblem, 303 ff – Biegelinie, 308 – bvp4c, bvp5c, 303 – bvpinit, 306 – bvpset, 306 – Drei-Punkt, 308 – Kettenlinie, 304 – Mehrpunkt, 308 – periodische Schwingung, 310 ff – Zweipunkt-, 303 Rangabfall, 91 Rangfolgeregel, 23 Referenzlage, 122 Reglerstrukturen, 358 Reglerumschaltung, 356 Reibmodelle, 289 Reibung, 289, 344 – Zweimassenschwinger, 353 Relativkoordinaten, 336, 351 Resonanz, 246, 378 f Richtungsfeld, 241 Roboter, 414 rotationssymmetrisch, 414 Ruhelage, 122 Runge-Kutta-Methode, siehe Integrationsverfahren Schaltfunktion, 277, 285, 325 Schaltkoeffizient, 277, 325 Schaltpunkte, 278 Schließbedingung, 352 Schubgelenk, 340 Schwingerkette, 149

Schwingung – Arbeitspunkt, 131 – chaotisch, 407 – Eigenschwingung, 131 – erzwungen, 148, 312, 373 – fastperiodisch, 148 – freie, 134, 139, 373 – – komplexe Formulierung, 144 – harmonisch, 150 – Impulsantwort, 159 – instationär, 132 – – Zustand, 242 – komplexe Anregung, 153 – konservatives System, 136 – periodisch, 310, 354 – quasiperiodisch, 148 – selbsterregt, 210, 234, 302, 310 – Sprungantwort, 160 – subharmonisch, 313 Schwingungstilger, 376 Signalfluss – bidirektional, 336 – unidirektional, 320, 336 Signalflussgrafen, 161 SimMechanics, 335, 393 – Body Actuator Block, 340 – Body Block, 336 – Body Spring & Damper Block, 340 – Convex hulls, 350 – Equivalent ellipsoids, 350 – Forward Stiction Limit, 346 – Ground Block, 336 – Inverse Dynamik, 337, 410 – Joint Sensor Block, 336, 343 – Joint Spring & Damper Block, 340 – Joint Stiction Actuator, 344 – Kinematics, 337 – Kinetic Friction, 346 – Library, 335 f – Machine Environment Block, 337 – Massenmittelpunkt CG, 338 ff – Prismatic Block, 338 – Reverse Stiction Limit, 346 – Revolute Block, 342 – Stabilisierung, 266, 351 f – Trimming, 337, 394 – – Gleichgewichtslage, 394 – Visualisierung, 349, 395, 409 – Vorwärtsdynamik, 337, 341, 407 SimPowerSystems, 335 Simscape – Library, Überblick, 335 Simulationsprogramm, 237 Simulink – Algebraic Constraint Block, 205, 252, 258 – algebraische Schleife, 162, 184, 205, 252, 327

427

428

Stichwortverzeichnis

– Annotations, 176 – Band-Limited White Noise, 190 – Break Point, 184 – Click Function, 176 – Coulomb and Viscous Friction Block, 195 – Dead Zone Block, 381 – Debugger, 184 – Divide Block, 209 – Floating Scope, 329 – – Signal Selector, 330 – From Workspace Block, 190 – Function Block – – Fcn, 193 – – Interpreted MATLAB Function Block, 193 – – MATLAB Fcn Block, 328 – get_parm, 221 – Hit Crossing Block, 328 – imread, 180 – Inport (In) Block, 174 – JPG-Format, 180 – Library, 171 – Manual Switch Block, 381 – Maskierung, 179 ff – MATLAB Function Block, 194, 210 – Model Explorer, 183 – Option – – simset, 175, 334 – Outport Block, 174 – Parameterbox, 179 ff – Power Spectral Density Block, 210 – Relational Operator Block, 381 – S-Function, 214 – – Builder, 221 – – Builder Block, 221 – – C Code, 317 – – Level-1 M-File, 214 f – – Level-2 M-File, 214, 217, 221 – Scope, 174, 182 – set_param, 220 – Sign Block, 381 – simplot, 183 – Simulationsaufruf – – sim, 174 – Sine Wave Block, 220 – Startroutine, 198 – State Port, 327 – State Space Block, 174, 188, 369 – Subsystem, 177, 192, 326, 363, 365, 379 – Switch Block, 194, 363 – TO Workspace Block, 174 Sollbewegung, 122 f Sparse Matrix, 15, 135 Spulenmodell, 358 Störbewegungen, 122 Störgrößenbeobachter, 365 Störgrößenkompensation, 364

Stabilisierung, 259, 265 – Baumgarte, 265 – Projektion, 266 Stabilität, 131 – asymptotisch, 124, 134, 146 f, 406 – char. Multiplikatoren, 315 – grenzstabil, 134, 138, 143, 146 – instabil, 124, 130, 134, 138, 146, 148, 406 – periodische Schwingung, 314 – Stabilitätsaussagen, 137 Stabilitätsuntersuchung, 414 starrer Körper, 97 State-Space-Model (ss), 158 Stateflow, 317 – Chart, 317 f – Connective Junction, 318, 322 – Debugger, 317 – Default Transition, 318, 322 – History Junction, 318 – Label, 319 f – – Bind Action, 320 – – During Action, 320 – – Entry Action, 320 – – Exit Action, 320 – – on-Event Action, 320 – – Transition Action, 321 – – Transtition Condition, 321 – – Transtition Condition Action, 321 – MATLAB Function, 319 – Model Explorer, 318, 323, 332 – – Datentyp, 323 – – Initialisierung, 323 – – Scope, 323 – Model Workspace, 318 – Parser, 317 – State, 318 f – State Machine, 317, 332 – Stateflow Block, siehe Chart – Transition, 319, 320 – Update method, 323 – – Continuous, 323 – – Discrete, 323 – – Inherited, 329 – Weckvorgang, 333 – Zustand, siehe State – Zustands-Aktion, siehe Label – – bind, 320 – – during, 320 – – entry, 319 – – exit, 320 – – on event, 320 Steiner, 110, 119 Steuerbarkeitsmatrix, 360 Stick-Slip-Schwingungen, 300 Stoß, 281, 284, 288 Stoßdämpfer, 412

Stichwortverzeichnis

Stoßkraft, 376, 381 Stromregler, 358 strukturvariables System, 327 Sweep-Generator, 379 Sweep-Kreisfrequenz, 379 Symbolic Math Toolbox – D Ableitungsoperator, 88 – diff, 86, 89, 107, 117, 398, 401 – digits, 85 – double, single, siehe MATLAB-Befehle – dsolve, 88 f – Eigenwerte, 91 – findsym, 84, 85, 91 – int, 86 – jacobian, 86, 108, 113 ff, 122, 124, 399, 401, 405 – jordan, 91 – limit, 86 – 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

Vektorisierung, 44, 131, 371 – vektorisierte Form, 140 Viertelfahrzeugmodell, 186, 300, 317, 411 Vorwärtsdynamik, 352 Winkelbeschleunigung, 103, 105, 108, 126 Winkelgeschwindigkeit, 101, 126 Workspace, 3, 8, 33, 36, 174 – Workspace Browser, 3 Zeitereignis, 275 Zeittransformation, 311 Zentrifugalkraft, 351 Zustandsereignis, 275 Zustandsmodell, 156, 371 Zustandsregler, 360 f Zweipunkt-Schaltlogik, 279

429