[an error occurred while processing this directive] Suche

Callbacks

Callbacks nennt man Funktionen oder Routinen, die ausgeführt werden, wenn ein bestimmtes Ereignis auftritt. In Simulink beziehen sich diese Ereignisse häufig auf den Ablauf des Simulationsprozesses, die Callback-Routinen werden also aufgerufen, wenn der Simulationsprozess ein bestimmtes Stadium erreicht hat, etwa wenn ein Modell geladen wird oder wenn ein Simulationslauf gestartet wird. Andere Ereignisse werden durch Aktionen der Benutzer ausgelöst, etwa durch Doppelklick auf einen Block. Graphische Benutzeroberflächen sind ein Beispiel dafür, wo Callback-Funktionen eingesetzt werden, graphische Animationen ein anderes.

Beispiel 1:

Das folgende einfache Beispiel soll zeigen, wie Callbacks aufgebaut, verwendet und wann sie ausgeführt werden. Wir verwenden ein Modell mit Namen 'cb.mdl', das im aktuellen Arbeitsverzeichnis liegt:

Modell zu Beispiel 1

Im selben Arbeitsverzeichnis liegen auch die M-Skripte W1F, W2F und W3F, die jeweils nur einen Matlab-Befehl umfassen:

W1F: W1 = input('W1?');
W2F: W2 = input('W2?');
W3F: W3 = input('W3?');

Wert1 bis Wert3 sind jeweils Constant-Blöcke deren Constant-Value-Parameter mit 'W1','W2' bzw. 'W3' besetzt sind. Wir können die Variablen im Matlab-Fenster besetzen:

» W1=1;W2=1;W3=1;

und nachfolgender Simulationslauf über das Modell-Fenster liefert das Ergebnis 1.

Für die Ausführung stehen unterschiedliche Zeitpunkte zur Wahl, je nach Ausführungszeitpunkt spricht man von Init-Funktionen, Start-Funktionen u.s.w. Wir benutzen zuerst W1F als InitFcn zum Block Wert1:

» set_param('cb/Wert1','InitFcn','W1F')

Nach dem Start im Modell-Fenster erhält man im Matlab-Fenster dann die Anfrage:

» W1?

und nach der Antwort 10 das Ergebnis 10 und nicht, wie man auch vermuten könnte, 200.

Der Zeitpunkt zu dem eine StartFcn ausgeführt wird, liegt nach der Festlegung der Parameterwerte für den nachfolgenden Simulationslauf. Änderungen von Parameterwerten wirken sich daher nicht auf diesen Lauf aus.

Wenn wir in einem nachfolgenden Lauf W1 und W2 mit 10 und 30 besetzen, erhalten wir als Ergebnis 200, denn jetzt wirkt sich die Besetzung von W2 mit dem Wert 20 im Vorlauf aus, noch nicht aber die Besetzung mit dem Wert 30 aus dem aktuellen Lauf.

Wir löschen die StartFcn von Wert2 mit:

» set_param('cb/Wert2','StartFcn','')

und besetzen stattdessen OpenFcn von Wert2 mit W2F:

» set_param('cb/Wert2','OpenFcn','W2F')

Der Zeitpunkt zu dem eine OpenFcn ausgeführt wird, wird vom Anwender durch Doppelklicken auf den betreffenden Block vorgegeben. Änderungen eines Parameterwertes wirken sich auf einen nachfolgenden Simulationslauf aus.

Eine OpenFcn ersetzt also die übliche Reaktion eines Blockes auf einen Doppelklick, das Öffnen des Blockparameter-Fensters, durch die Ausführung der betreffenden OpenFcn.

» W1?
W2?

die wir mit 10 bzw. 20 beantworten, das gelieferte Ergebnis ist 10.

Callback-Routinen können einzelnen Blöcken eines Modelles zugeordnet werden, aber auch dem gesamten Modell. Teilweise werden dabei gleiche Namen für die Callback-Funktionen verwendet, teilweise verschiedene.
Der folgende Dialog findet im Matlab-Fenster statt, die verwendeten Callback-Routinen sind analog zu den bisher verwendeten aufgebaut. Neu tauchen in diesem Dialog auf:

Lade-Funktion LoadFcn für einen Block. Diese Funktion wird ausgeführt nachdem das Modell geladen wurde.
Prä-Ladefunktion (PreLoadFcn) für ein Modell, diese Funktion wird ausgeführt bevor ein Modell geladen wird und kann dazu benutzt werden Matlab-Variablen zu initialisieren, Modell- und Block-Parameter zu besetzen.
Post-Ladefunktion (PostLoadFcn) für ein Modell, diese Funktion wird ausgeführt nachdem ein Modell geladen wurde und kann dazu benutzt werden eine graphische Benutzeroberfläche zu starten.
Start-Funktion für ein Modell. Diese Funktion wird ausgeführt bevor ein Simulationslauf gestartet wird und nachdem die Variablen aus dem Matlab Namensraum eingelesen wurden.

Da wir hier mehrere Ereignisse haben, die sich auf das Laden eines Modells beziehen, schließen wir das Modell mit Hilfe von close_system und laden es danach erneut, damit die betreffenden Funktionen überhaupt ausgeführt werden.

» gcs                                    % set_param funktioniert nur beim aktuellen System
ans = cb
» set_param('cb/Wert1','InitFcn','')     % loeschen der InitFcn
» set_param('cb/Wert2','InitFcn','')     % loeschen der InitFcn
» set_param('cb/Wert3','InitFcn','')     % loeschen der InitFcn
» set_param('cb/Wert3','StartFcn','')    % loeschen der StartFcn
» set_param('cb/Wert2','StartFcn','')    % loeschen der StartFcn
» set_param('cb/Wert1','StartFcn','')    % loeschen der StartFcn
» set_param('cb/Wert1','OpenFcn','')     % loeschen der OpenFcn
» set_param('cb/Wert2','OpenFcn','')     % loeschen der OpenFcn
» set_param('cb/Wert3','OpenFcn','')     % loeschen der OpenFcn
»
» set_param('cb/Wert1','LoadFcn','W1LF') % LoadFcn für Wert1
» set_param('cb/Wert2','LoadFcn','W2LF') % LoadFcn für Wert2
» set_param('cb/Wert2','InitFcn','W2F')  % InitFcn für Wert2
» set_param('cb/Wert3','LoadFcn','W3LF') % LoadFcn für Wert3
» set_param('cb','PreLoadFcn','SPrLF')   % LoadFcn für Wert1
» set_param('cb','PostLoadFcn','SPoLF')  % LoadFcn für Wert1
» set_param('cb','StartFcn','SStF')      % LoadFcn für Wert1
» close_system                           % aktuelles System schließen, Modellfenster verschwinden
» cb                                     % Modell cb laden, wird aktuelles System
ans =                                    % Preload-Funktion fragt Werte ab
PreLoadFunction
W1?1
W2?1
W3?1
ans =                          % Postload-Funktion fragt Werte ab
PostLoadFunction
W1?2
W2?2
W3?2
W1-LoadFcn: W1?3               % Load-Funktion zu Wert1
W2-LoadFcn: W2?3               % Load-Funktion zu Wert2
W3-LoadFcn: W3?3               % Load-Funktion zu Wert3
» [t,x,y]=sim('cb');           % Simulationslauf starten
W2?4                           % Init-Funktion zu Wert2 (Initialisierungsphase der Simulation)
ans =                          % Start-Funktion zum System (Startphase der Simulation)
StartFunction
W1?4
W2?4
W3?4
» y                            % Abfrage des y-Vektors
y =                            % da keine Angaben zu Schrittweite und Simulationslauf gemacht
    36                         % wurden, werden Default-Werte benutzt. Wir erhalten 50 mal
    36                         % dasselbe Ergebnis. Das Ergebnis W1*W2*W3 = 36 ergibt sich
    36                         % aus 3*4*3. W1=3 durch LoadFcn zu Wert1, W2=4 durch InitFcn zu
    36                         % Wert2, W3=3 durch LoadFcn zu Wert3. Die Wertzuweisungen durch
    36                         % die StartFcn wirken sich auf diesen Lauf nicht aus.
    ..
» [t,x,y]=sim('cb',[0 0]);     % Simulationslauf starten (nur 1 Zeipunkt)
W2?5                           % Init-Funktion zu Wert2 (Initialisierungsphase der Simulation)
ans =
StartFunction                  % Start-Funktion zum System (Startphase der Simulation)
W1?5
W2?5
W3?5
» y                            % Abfrage des y-Vektors. Ergebnis 4*5*4 = 80, bei W1, W3 werden die
y =                            % Wertzuweisungen der StartFcn des vorangegangenen Simulationslaufes
    80                         % wirksam, bei W2 die der InitFcn zu Wert2 des aktuellen Laufes.

Auch für das Ende eines Simulationsprozesses sind verschiedene Zeitpunkte für Callback-Routinen vorgesehen.
Die StopFcn zu einem System wird nach einem Simulationslauf ausgeführt, nachdem die Ergebnisse in den Matlab-Namensraum oder in Dateien geschrieben wurden. Die StopFcn wird häufig dazu benutzt Ergebnisplots auszugeben.
Die CloseFcn wird ausgeführt bevor das Modell geschlossen wird (z.B.: File -> Close). Dieser Zeitpunkt bietet sich an, nicht mehr notwendige Objekte auf dem Bildschirm und im Matlab-Namensraum zu löschen.

Beispiel 2:

Eine Masse m kann sich in x-Richtung um den Punkt x=0 herum bewegen. Auf die Masse wirken ein:

eine Feder mit der Federkonstante k
ein Dämpfungsglied mit dem Dämpfungsfaktor c

Wir erhalten damit die Differentialgleichung:

   m*x''(t) + c*x'(t) + k*x(t) = 0

Die Anfangsbedingungen seien:

   x(0) = 1, x'(0) = 0

Damit haben wir das Simulink-Modell:

Simulink-Modell

Wir haben in diesem Modell die beiden Verstärkungswerte mit den Ausdrücken c/m bzw. k/m besetzt. Vor dem Start müssen die Variablen c, k und m daher noch mit Werten besetzt werden. Das geht selbstverständlich problemlos im Matlab-Fenster. Die Kommandos:


» c=1;k=1;m=1;
» [t,x]=sim('A1')
» plot(t,x)

liefern die Graphen von x(t) und x'(t) in einem Fenster. Wir wollen aber sicherstellen, dass diese Werte immer besetzt sind und definieren deshalb eine PreLoad-Funktion für das System, die diesen Variablen Default-Werte zuordnet. Dies soll durch das M-File A1PLF erfolgen, das den folgenden Inhalt hat:

% PreLoadFcn zu Modell A1
c = 1; k = 1; m = 1;

Die Verknüpfung von M-File und Simulink-Modell erfolgt mittels Matlab-Kommando:


» set_param('A1','PreLoadFcn','A1PLF')

wenn unser Modell A1 das aktuelle System ist. Beim Aufruf des Modells A1 erhalten die Variablen jetzt die betreffenden Werte und das Modell kann nach dem Laden problemlos gestartet werden. Mit dem Kommando:


» set_param('A1','StopFcn','plot(t,x)')

erreichen wir, dass die Ergebnisse nach Ende des Simulationslaufes automatisch in einem Graphik-Fenster angezeigt werden. Als StopFcn haben wir diesmal ein Matlab-Kommando angegeben, das t und x als Argumente benutzt. Wir müssen daher dafür sorgen, dass:

diese Variablen in den Matlab-Namensraum geschrieben werden, was wir durch entsprechende 'To workspace' Blöcke erreichen.
die StopFcn erst ausgeführt wird, nachdem die Variablen in den Matlab-Namensraum geschrieben wurden, was für eine StopFcn garantiert ist.

Erweitertes Simulink-Modell

Schließlich können wir in diesem Beispiel auch noch eine CloseFcn sinnvoll einsetzen. Durch die StopFcn wird ein Graphik-Fenster auf dem Bildschirm geöffnet, dieses bleibt auch dann noch offen, wenn wir das Modell-Fenster mittels File -> Close schließen. Damit sich dann auch das Graphik-Fenster schließt, setzen wir:


» set_param('A1','CloseFcn','delete(gcf)')

Wie alle Objekte der Matlab-Graphik, werden auch die Fenster durch spezifische 'Handles' identifiziert. gcf steht für 'get current figure' und ist eine Funktion, die als Funktionswert das Handle der aktuellen Figur liefert.

Die einzelnen Callback-Routinen sollen hier nur klarmachen, wann die speziellen Callback-Funktionen ausgeführt werden und wozu man sie verwenden kann. Für den konkreten Einsatz müssten sie in verschiedene Richtungen abgesichert werden.
Weitere Callback-Routinen zu Beispiel 2 finden Sie im Abschnitt Graphische Benutzeroberflächen.