SIMULINK: Subsysteme

Subsysteme lassen sich auch in anderen Modellen, in denen dieselbe Funktionalität erforderlich ist, einsetzen und ermöglichen so die Wiederverwendbarkeit einer einmal gemachten Arbeit. Zu diesem Zwecke können Anwender eigene Block Bibliotheken entwickeln.

In unserem ersten Beispiel wollen wir eine Block Bibliothek mit zunächst zwei Subsystemen entwerfen, die wir in verschiedenen Modellen zur Überwachung der Integrationsverfahren benutzen wollen.

Beispiel 1:

   y' + 2*y = u(t) = sin(t); y(0) = 0

Die Gleichung liefert die Laplace-Transformierten:

   s*Y + 2*Y = U
-> (s+2)*Y = U
-> Y = (1/(s+2))*U

Die Uhr (clock) liefert uns die simulierte Zeit zu den Ereigniszeitpunkten des Systems. Wenn wir dafür sorgen, dass diese genau durch die Integrationsschritte gegeben werden, können wir aus t_k+1-t_k die Länge der einzelnen Integrationsschritte bestimmen.

Die Frage ist jetzt, wie erhalten wir die Differenzen der einzelnen Ereigniszeitpunkte?

Wer jetzt an diskrete Blöcke wie z.B. den Unit delay Block denkt, liegt leider im allgemeinen falsch. Das Problem ist, dass wir bei diesem Block die blockeigene Taktvorgabe nicht ausschalten können. Zumindest akzeptieren die mir zugänglichen Simulink-Versionen bei diesem Block nicht den Sample time Wert -1. Damit ist dieser Block im allgemeinen für unser Problem ungeeignet.

Was wir brauchen, ist ein Block, der uns zum Eingang u_k+1 den Ausgang u_k liefert, unabhängig davon, wie lange der Zeitabstand t_k+1-t_k ist. Dies macht der Memory Block den man in Simulink 3 in der Continous Library findet, nicht aber der Unit delay Block. Wir erhalten damit:

Die nachfolgenden Bilder zeigen:

1. • die Lösung des Problems (links)
   • die Schrittweiten des Dormand-Prince Verfahrens (rechts)
2. • die Schrittweiten des TR-BDF2 Verfahrens (links)
   • die Schrittweiten des ODE15s Verfahrens (rechts)

Erzeugen von Subsystemen:

Die Blöcke zur Bestimmung der Schrittweite wollen wir nun in ein Subsystem umwandeln, wobei wir den Scope-Block nicht mit in das Subsystem nehmen. Dazu markieren wir die betreffenden Blöcke mit der Maus:

Mit dem Modell selbst können wir arbeiten wie gewohnt.

Wir wollen nun den Subsystemblock umbenennen. Es gibt eine ganze Reihe von Möglichkeiten dazu, auch zur graphischen Umgestaltung des Icons. Wir beschränken uns im Moment aber auf folgendes Verfahren:

1. Subsystem-Block anklicken
2. Edit -> Mask Subsystem auswählen
3. im daraufhin erscheinenden Mask Editor Fenster geben wir im Eingabefenster Drawing commands ein:

   disp('delta t')

4. nach anklicken von Apply können wir die Auswirkung auf den Icon des Subsystems schon erkennen
5. durch anklicken von OK wird das Fenster des Mask Editors geschlossen und dieser selbst beendet.

Unser Modell mit dem Subsystem sieht jetzt wie folgt aus:

Als weitere Aufgabe wollten wir ein Subsystem konstruieren, das uns die Anzahl der Integrationsschritte unseres Systems angibt. Im Grunde ist das ganz einfach. Zu jedem Ereigniszeitpunkt des Systems muss ein Zustandswert um 1 hochgezählt werden. Wiederum müssen wir hier einen Block wählen, der die Ereigniszeitpunkte des Systems übernimmt und keine eigenen Ereigniszeitpunkte hervorruft, da die Blöcke aus der 'Discrete Library' alle mit eigener Taktzeit arbeiten, sind diese ungeeignet und wir modellieren den Zähler deshalb wieder mit einem Memory Block. Als Startwert (Initial condition) dieses Blockes müssen wir -1 wählen, weil wir die Anzahl der Schritte und nicht die um 1 höhere Anzahl der Ereigniszeitpunkte zählen wollen. Wir kommen damit zum folgenden Modell:

Wir können nun auch die Anzahl der durchgeführten Integrationsschritte mit den verschiedenen Integrationsverfahren ermitteln. Für die oben betrachteten Verfahren haben wir:

Bibliotheken:

Für die meisten Zwecke würde es genügen, unsere Blöcke einfach in einem eigenen Modell aufzubewahren, aus dem wir sie bei Bedarf in andere Modelle kopieren.
Das Bibliothekskonzept von Simulink bietet jedoch mehr Funktionalität auf Kosten eines größeren Aufwandes. Hauptvorteil einer Bibliothek ist der, dass die Kopie eines Blockes in einem Modell immer Verbindung zu ihrem Original in der Bibliothek (Bibliotheksblock) hat. Eine Korrektur am Bibliotheksblock wird damit automatisch von allen Kopien in den Modellen übernommen.

Zum Anlegen einer neuen Bibliothek gehen wir wie folgt vor:

• im Simulink Fenster zum Modellieren wählen wir File -> New -> Library, worauf ein mit 'Library: untiteled' betiteltes Fenster aufgeht,
• wir kopieren unsere Blöcke in dieses Fenster

  

• mit File -> Save im Bibliotheks-Fenster sichern wir die Bibliothek, wobei wir festlegen in welchem Verzeichnis sie unter welchem Namen zu erreichen ist. Wir legen sie hier in e:/simulink unter dem Namen IntegLib ab.

Beispiel 2:

• die Standard Simulink Bibliotheken,
• unsere Bibliothek e:/simulink/IntegLib auf dem normalen 'open'-Weg,
• ein Simulink Modellier Fenster

Zur Simulation verwenden wir dieselben Parameter wie in Beispiel 1, die 'sample time' der digitalen Uhr setzen wir auf 0.2. Mit dem Dormand-Prince Verfahren erhalten wir dann das folgende Bild für die Schrittweiten, wobei hier 202 Integrationsschritte anstelle der 145 in Beispiel 1 durchgeführt wurden.

Am einfachsten sehen wir das an unserem Test-System:

simout =

         0         0         0         0
    1.0000    0.0300    0.0300    0.0004
    2.0000    0.0601    0.0300    0.0017
    3.0000    0.0994    0.0393    0.0046
    4.0000    0.1478    0.0484    0.0099
    5.0000    0.2000    0.0522    0.0175
    6.0000    0.2654    0.0654    0.0295
    7.0000    0.3395    0.0741    0.0461
    8.0000    0.4000    0.0605    0.0614
    9.0000    0.4919    0.0919    0.0874
   10.0000    0.6000    0.1081    0.1210
   11.0000    0.7144    0.1144    0.1589
   12.0000    0.8000    0.0856    0.1880
   13.0000    0.9558    0.1558    0.2409
   14.0000    1.0000    0.0442    0.2556
   .......    ......    ......    ......

Beispiele wie dieses sollen nicht dazu anregen, möglichts komplizierte Modelle zu konstruieren, sondern darauf aufmerksam machen, dass durch einfache Änderungen am Modell völlig neue Situationen entstehen, die nicht miteinander vergleichbar sind.

Im folgenden Beispiel verwenden wir Subsysteme um eine große Anzahl gleichartiger Blöcke mit wenig Aufwand zu konstruieren. Das Grundprinzip sind dabei Hierarchien von Subsystemen.

Beispiel 3:

• wir &oeffnen dazu ein Simulink-Modell Fenster und erzeugen dort mittels File ->> New -> Library ein Bibliotheks-Fenster.
• in dieses Fenster kopieren wir einen Summen- und einen Transfer-Block.

  

• als Parameter für den Transferblock geben wir ein:

     Numerator:     [G]
     Denominator:   [C 2*G]

  Der Icon des Transferblockes ändert sich daraufhin in:

  

• wir markieren das gesamte Teilsystem und verwandeln es mittels File -> Create Subsystem in ein Subsystem

  

• wir markieren den Subsystem-Block und öffnen mittels File -> Mask Subsystem den Masken-Editor. Je nach Vorgeschichte kann anstelle von Mask Subsystem auch Edit Mask angeboten werden. Beides führt zum selben Fenster, das wir aus Beispiel 1 schon kennen. Das erste Fenster füllen wir wie gezeigt aus, was nach 'Apply' zur Wirkung hat, dass der Icon des Subsystems die Aufschrift '(RC)1R' trägt.

  

• wir öffnen jetzt auch das 'Initialization' Fenster des Masken-Editors und geben unter Prompt und Variable jeweils G als Wert ein, danach klicken wir auf Add und geben jetzt unter Prompt und Variable jeweils C ein. Diese Aktion schließen wir mit Apply ab. Das Fenster sieht dann etwa wie folgt aus:

  

  Mit OK verlassen wir den Masken-Editor.
• wenn man einen nicht maskierten Subsystem-Block mit Doppelklick anspricht, erscheint ein Fenster mit dem Subsystem. Bei einem maskierten Subsystem-Block erscheint dagegen, wie bei jedem anderen Block, das Parameter-Fenster.

  

  Wie man sieht können wir mit diesem Fenster die Parameter C und G des Blockes besetzen.
• um das Subsystem eines maskierten Subsystem-Blockes zu sehen, müssen wir Look under Mask benutzen, es liefert in unserem Falle:

  

• schließlich wollen wir unser Subsystem in ein Modell einbauen und testen. Wir öffnen dazu ein Modell-Fenster und konstruieren:

  

  Was wir sehen können ist, dass unterschiedliche Parameter unterschiedliche Ergebnisse liefern und folglich die Parameterübergabe mit dem Parameter-Fenster funktioniert.
  Wir setzen voraus, dass die Bibliothek mit dem (RC)1R-Block, aus der wir diesen kopieren, in unserem Arbeitsverzeichnis liegt.
• Wir sichern die Bibliothek unter dem Namen RCLib in einem Verzeichnis.

Beispiel 4:

Ein Glied einer solchen Reihe, bestehend aus einem Widerstand und einer Kapazität nennen wir ein RC-Glied.

• einen Leitwert G, das ist der Kehrwert des Widerstandes R,
• eine Kapazität C
• einen Knoten zwischen Widerstand und Kapazität
• einen Eingangsspannung u(t)
• eine Knotenspannung phi(t)

      iRk = G*(phik-1(t)-phik(t))

      iCk = C*phik'(t)

      G*(phik-1(t)-phik(t)) = G*(phik(t)-phik+1(t)) + C*phik'(t)

(1)   C*phik'(t) + 2*G*phik(t) = G*(phik-1(t)+phik+1(t))

      G*(phin-1(t)-phin(t)) = C*phin'(t)

(2)   C*phik'(t) + G*phik(t) = G*phik-1(t)

• wie verhalten sich die Spannungen phi_k im Laufe der Zeit?
• welche Schrittweiten verwenden die unterschiedlichen Integratoren zur Lösung dieses Problems? (Die Simulationsparameter geben wir erst später an.)

Gleichung (1) und (2) lassen sich durch Transfer Blöcke simulieren, wobei:

• das Eingangssignal, das ist hier die Eingangsspannung, u_k(t) = phi_k+1(t) + phi_k-1(t) ist.
• im Transferblock, ausser beim letzten RC-Glied in der Reihe, der Zähler G und der Nenner C+2*G ist, bei letzten Glied haben wir im Zähler G und im Nenner C+G
• das Ausgangssignal, das ist hier die Ausgangsspannung, y_k(t) = phi_k(t) ist.

Die RCLib-Bibliothek benötigen wir natürlich zum Kopieren der (RC)1R-Blöcke, aber auch beim Simulationslauf. Sie muss deshalb entweder in unserem Arbeitsverzeichnis liegen oder aber über den Matlab Suchpfad erreichbar sein, ist das nicht der Fall, so müssen wir sie mit Hilfe des Befehls addpath Verzeichnisname wenigstens temporär in den Pfad eingliedern. Benötigte aber nicht auffindbare Bibliotheken werden bei der Simulation häufig durch Bad Link in den Block-Icons angezeigt.

• der Bildschirm bietet nur beschränkten Platz,
• die Modelle werden schnell unübersichtlich und fehlerhaft
• es ist sehr mühsam und auch fehleranfällig, die Parameter aller Blöcke in der Reihe von Lauf zu Lauf zu ändern.

Einfacher ist es da, hierarchisch gegliederte Subsysteme mit 2, 4, 8, ... RC-Gliedern aufzubauen. Hierarchisch gegliederte Subsysteme sind im Simulink möglich.

Wir öffnen ein neues Modell-Fenster und kopieren die beiden (RC)1R-Blöcke einschließlich des Mux-Blockes in dieses Fenster. Der vordere (RC)1R-Block hat keine Rückkopplung zu seinem Vorgänger, da es diesen nicht gibt. Wenn wir den neuen Block aber hinter einem anderen Block verwenden wollen, brauchen wir diese Rückkopplung und folglich einen entsprechenden Ausgang im Subsystem. Außerdem sind nach dem Kopieren meist einige kosmetische Korrekturen am Modell notwendig. Nachdem dies alles getan ist, sieht unser Subsystem wie folgt aus:

• wir setzen bei den Parametern der (RC)1R-Blöcke die unbestimmten Werte G und C ein,
• wir markieren das gesamte Teilsystem,
• wir wandeln das Teilsystem mittels Create Subsystem in ein Subsystem, das durch einen einzigen Block dargestellt wird:

  

• da dieser Block noch nicht maskiert ist, liefert ein Doppelklick auf den Subsystem-Block das darunterliegende Subsystem:

  

• wir markieren den Subsystem-Block und öffnen mit Mask Subsystem den Masken-Editor. Dort legen wir wie bekannt, die Beschriftung des Icons fest und definieren die Parameter G und C als Block-Parameter. Wir nennen den Block (RC)2R
• wir kopieren den maskierten Block in unsere RCLib-Bibliothek, Eventuell kann es erforderlich sein, dazu die Bibliothek mit Edit -> Unlock Library im Bibliotheksfenster entsperren.

1. von 0 bis 60
2. von 0 bis 200

• Dormand-Prince
• ODE15s

• Relative Tolerance: 1.0e-6
• Absolute Tolerance: 1.0e-9

	Dormand-Prince		ODE15s
	0 bis 60	0 bis 200	0 bis 60	0 bis 200
Schrittzahl	113	280	206	240
mittl.Schrittw.	0.8	0.8	1.2	4

Wie man sieht, zeigen die beiden Integrationsverfahren ein deutlich verschiedenes Schrittweitenverhalten. Bei kürzeren Integrationintervallen ist das Dormand-Prince Verfahren bezüglich des Aufwandes im Vorteil, bei längeren das ODE15s-Verfahren.

Wir werden sehen, dass dies eine typische Situation für ein 'steifes Problem' mit einer Transientenphase ist.