Labor Modellgestütztes Software Engineeringeitidaten.fh-pforzheim.de/daten/labore/sdly/SDLY_Versuch... · 2019-10-01 · CountDown- CountDown[0], den Animated Statechart der Instanz

Labor Modellgestütztes Software Engineering

Versuch 2

Wintersemester 2019/20

Wintersemester 2019/20 Rhapsody 8.4 VS2015

Dipl.-Ing. (FH) Joachim Hampel

Version 10 1. Oktober 2019

Labor Modellgestütztes Software Engineering – Aufgabe 2

2

Inhaltsverzeichnis

1 EINFÜHRUNG ............................................................................................................................................. 3

2 VERWENDETE DIAGRAMME ................................................................................................................ 4

2.1 SIMPLE STATECHART ............................................................................................................................. 4 a) Startzustand ............................................................................................................................. 4 b) Einfacher Zustand.................................................................................................................... 4 c) Transition ................................................................................................................................. 4 d) Kreuzungspunkt ....................................................................................................................... 5 e) Endpunkt .................................................................................................................................. 5

2.2 SEQUENCE DIAGRAM ............................................................................................................................. 5 2.3 PROJEKT KOPIEREN ................................................................................................................................ 5

3 ÜBUNG COUNT DOWN ............................................................................................................................ 6

3.1 EINFÜGEN EINER EIGENSCHAFT ............................................................................................................. 6 a) Generierter Programmode: ...................................................................................................... 6

3.2 EINFÜGEN EINER VERHALTENSWEISE ..................................................................................................... 7 a) Generierter Programmode: ...................................................................................................... 7 b) Testen der Methode print ........................................................................................................ 8

3.3 STATECHART INS PROJEKT EINFÜGEN .................................................................................................... 8 3.4 RHAPSODY FRAMEWORK ..................................................................................................................... 10

a) Generierter Programmcode ................................................................................................... 11

4 ANIMATION .............................................................................................................................................. 12

4.1 PROJEKTKONFIGURATION KOPIEREN .................................................................................................... 12 4.2 KONFIGURATIONEN VERWALTEN ......................................................................................................... 12 4.3 ANIMIERT DEBUGGEN ........................................................................................................................... 13 4.4 STARTEN DER ANIMATION ................................................................................................................... 13 4.5 ANIMATED STATECHART ...................................................................................................................... 14

5 SEQUENCE DIAGRAM ZUR ANALYSE .............................................................................................. 15

5.1 EINFÜGEN EINES SEQUENCE DIAGRAMS ............................................................................................... 15 5.2 INSTANZEN IM SEQUENCE DIAGRAM EINFÜGEN ................................................................................... 16

6 EVENT ........................................................................................................................................................ 17

6.1 EVENT EINFÜGEN ................................................................................................................................. 17 6.2 EVENT IN DER ANIMATION AUSLÖSEN .................................................................................................. 18 6.3 ATTRIBUTE WÄHREND DER ANIMATION ANZEIGEN .............................................................................. 19

7 AUFGABEN ............................................................................................................................................... 20

7.1 FUßGÄNGERAMPEL ............................................................................................................................... 20 7.2 PARKPLATZSCHRANKE ......................................................................................................................... 20

8 LITERATUR .............................................................................................................................................. 21


3

1 Einführung

Im aktuellen Versuch werden folgende Lernziele verfolgt:

State Charts werden zur Verhaltensbeschreibung eingesetzt.

Mittels des Simulationsmodus wird im State Chart simuliert.

Als ein weiteres Analyse Werkzeug wird ein Sequence Chart verwendet

Änderungen vom Model werden im Programmcode untersucht.

Auswirkungen von Änderungen im Programmcode auf das Modell werden untersucht.


4

2 Verwendete Diagramme

2.1 Simple Statechart

Abbildung 1 Einfacher Zustandsautomat

Hier wurde der Übersichtlichkeit alle Aktionen direkt als Code an die Transitionen angehängt (Mealy-Automat). Ziel eines guten Designs ist es allerdings das Verhalten in Methoden zu implementieren und diese dann zu verwenden.

a) Startzustand

Ein Startpunkt bildet den Startpunkt für das Betreten des Zustandautomaten.

b) Einfacher Zustand

Ein Zustand entspricht einer Situation, in der sich das System befinden kann. Der Zustand

wird durch einen externen Auslöser verlassen.

c) Transition

Eine Transition mit Trigger[Guard]/Verhalten beschreibt den Übergang in einen neuen oder

den bisherigen State. Sie wird bestimmt von Trigger und Guard und kann ein Verhalten

auslösen.

Trigger: Auslöser der Transition. MehrereTrigger werden durch Komma getrennt

Guard: Bedingung, die wahr sein muss. Die Notation erfolgt mit eckigen Klammern

[].Verhalten: Verhalten, das beim Durchlaufen der Transition ausgeführt wird.


5

d) Kreuzungspunkt

Ein Kreuzungspunkt, hier Condition Connector genannt, bietet die Möglichkeit mit mehreren

Transitions auf einen gemeinsamen Condition Connector zu zeigen und von dort mit

verschiedenen Transitions wieder zu verzweigen.

e) Endpunkt

Mit dem Erreichen des Endzustandes, hier Terminition Connector, wird die Ausarbeitung des

Zustandsautomaten beendet.

2.2 Sequence Diagram

Abbildung 2 Sequence Diagram

2.3 Projekt kopieren

Ein bestehendes Projekt kann unter einem anderem Pfad und Namen abgespeichert

werden.

Nach Auswahl von File/Save as muss ein neuer Ordner angelegt und in diesen gewechselt

werden. Hier kann das aktuelle Projekt, wenn gewünscht auch unter neuem Namen

gespeichert werden. Die Einstellungen bleiben erhalten.


6

3 Übung Count Down

Sie legen ein Projekt an und fügen eine Klasse CountDown ein. Es wird eine weiters Object Model Diagram (Builder) eingefügt und eine Instanz von CountDown angelegt.

3.1 Einfügen einer Eigenschaft

Unter dem Menüpunkt Features/Attributes werden die Eigenschaften einer Klasse angezeigt

und können ergänzt oder bearbeitet werden. Für die aktuelle Anwendung wird eine Variable

iCount ergänzt und mit 0 initialisiert. Die Membervariable wird immer als protected angelegt,

die Visibility bezieht sich auf die get-Methode (Accessor) und set-Methoden (Mutator).

Abbildung 3 Einfügen einer Eigenschaft

a) Generierter Programmode:

public :

int getICount() const;

void setICount(int p_iCount);

protected :

int iCount; //## attribute iCount


7

3.2 Einfügen einer Verhaltensweise

Diese Vorgehensweise entspricht im Prinzip der zum Einfügen einer Eigenschaft - diesmal

wird jedoch eine Operation eingefügt. Es wird eine Operation ausgewählt hier die Methode

print. Mit einem Doppleklickauf print erreicht man das Feature-Menü der Methode print.

Programmcode kann unter dem Menüpunkt Implementation eingegeben werden. Das

benötigte Übergabeargument int n kann unter Arguments eingefügt werden.

Abbildung 4 Einfügen von Programmcode

Abbildung 5 Einschalten der Programmcodeansicht

Mit Apply kann die Änderung übernommen werden, ohne das Fenster zu

schließen.

a) Generierter Programmode:

void CountDown::print(int n) {

//#[ operation print(int)

cout<<"Count = "<<n<<'\n';

//#]

}

Eine weitere Möglichkeit, eine Methode einzufügen, liegt darin mit der rechten Maustaste auf

Operations zu klicken und AddNew/Operations auszuwählen.

Hier nochmals eine Methode print diesmal allerdings mit dem Übergabeparameter char* s

und dem folgenden Programmcode

cout<<s<<'\n';

Zur Umsetzung des Counters wird noch eine weitere Funktion isDone benötigt, die einen

booleschen Wert mit dem folgenden Programmcode generiert.


8

if(0==iCount)

return 1;

else

return 0;

Wird bei 0==iCount ein = vergessen, so generiert der Kompiler eine

Fehlermeldung, während iCount=0 akzeptiert wird.

Wenn die ersten Buchstaben eines Namens geschrieben wurden, so kann mit

Strg Leertaste eine Auswahlbox mit möglichen Namen geöffnet werden.

b) Testen der Methode print

In Programmcode wird im Konstruktor folgender Programmcode eingefügt:

print("Constructed");

Mit Save und Generate/Make/Run kann das bisherige Projekt getestet werden.

3.3 Statechart ins Projekt einfügen

Um das Verhalten der Count Down Timers zu modellieren wird ein Statechart benötigt.

Durch ein rechten Mausklick auf die Klasse CountDown kann im erscheinenden der Eintrag

Add New / Statechart ausgewählt werden. Das Statechart wird direkt der Klasse zugeordnet.

Abbildung 6 Auswahlmenue


9

Aus der Werkzeugleiste wird ein State ausgewählt, eingefügt und umbenannt hier soll der

State den Namen sACTIVE erhalten. Der zu setzende Default Connector stellt den

Einstiegspunkt in die Statemachine dar und muss immer gesetzt werden. Trigger und Guard

wird hier nicht benötigt, Das Verhalten hier Action genannt kann entweder direkt editiert oder

im über die rechte Maustaste erreichbaren Feature Menue eingegeben werden. Folgende

zwei Actions werden benötigt.

iCount=10;

print("Started");

Als Trigger wird in diesem Beispiel ein Timer verwendet. Der Timer gehört zum verwendeten

Framework und steht dem Benutzer zur Verfügung. Der Einsatz des Timers jetzt aber ein

System voraus, dass über Timer verfügt. Hier wird der Wert in mS angegeben

tm(200)/print(iCount);

Der Condition Collector kann über verschiedene Trigger verlassen werden, [else] stellt den

default Ausgang dar.

Abbildung 7 Fertiger Zustandsautomat

Mit Save und Generate/Make/Run kann das bisherige Projekt wie gewohnt getestet werden

Abbildung 8 Ausgabe des Zustandsautomaten


10

Nun verfügt die Klasse Display über ein Verhalten, die Details sind auch im Projektspace

sichtbar.

Abbildung 9 Ausgabe des Zustandsautomaten

3.4 Rhapsody Framework

Zur Generierung des Zustandsautomaten wird ein Framework in das Projekt eingebunden.

Die benötigten Headerfiles werden automatisch ergänzt.

#include <oxf/oxf.h>

#include <oxf/omreactive.h>

#include <oxf/state.h>

#include <oxf/event.h>

Die Klasse CountDown wird jetzt von einer der Framework Basisklassen OMReactive

abgeleitet. Zusätzlich wird ein Thread

CountDown(IOxfActive* theActiveContext = 0)erzeugt. Die Klasse wartet jetzt

auf einen Timeout oder einen Event. Tritt ein Event oder ein Timeout auf, so wird die

Methode rootState_processEvent() aufgerufen.


11

a) Generierter Programmcode

CountDown::CountDown(IOxfActive* theActiveContext)

Dem Konstruktor muss ein Zeiger übergeben werden, der auf den Thread zeigt, auf

welchen gewartet werden soll.

CountDown::initStatechart()

Die Methode wird durch den Konstruktor aufgerufen und initialisiert den

Zustandsautomaten.

CountDown::startBehavior()

Started den Zustandsautomaten.

CountDown::rootState_entDef()

Führt die an den Default Connector angeschlossen Transition aus.

CountDown::rootState_processEvent()

Diese Methode wird aufgerufen, wenn ein Event oder ein Timeout auftritt. Hier

findet sich auch der Programmcode, der das Verhalten der Transitions beschreibt.


12

4 Animation

4.1 Projektkonfiguration kopieren

Um das Projekt graphisch zu debuggen ist es hilfreich eine weitere Projektkonfiguration

anzulegen. Es ist möglich die bestehende Konfiguration zu kopieren. In einem ersten Schritt

wird die bestehende Konfiguration in Release umbenannt.

Abbildung 10 Konfiguration umbenennen

Die Strg-Taste muss gedrückt gehalten werden, und die Release-Konfiguartion wird in den

Ordner Configurations gezogen. Es entsteht eine Kopie der bisherigen Konfiguration, die in

Debug umbenannt werden kann. Im Auswahlfenster Instrumentation Mode muss Animation

ausgewählt werden.

Abbildung 11 neue Konfiguration

4.2 Konfigurationen verwalten

Der Anwender muss die zu verwendende Konfiguration festlegen. Dies kann über ein

Auswahlmenü erfolgen. Für die Animation wird die Konfiguration Debug ausgewählt.

Abbildung 12 festlegen der aktiven Konfiguration


13

4.3 Animiert debuggen

Mit Save und Generate/Make/Run kann das bisherige Projekt wie gewohnt getestet werden.

Wir befinden uns jetzt allerdings im Animated Debug.Mode. Dem Anwender steht eine Tool

Bar zur Steuerung der Animation zur Verfügung. Es gehen auch zwei weitere Statusfenster

Call Stack und Event Que zur Beobachtung auf.

Abbildung 13 Animation Tool Bar

Bedeutung von Links nach rechts:

Go Step Go (F4)

Go Idle Go Event (F10)

Go Action Animation Break

Command Prompt Quit Animation (Shift + F5)

Threads Breakpoints

Event Generator Call Operations

Animation Mode

4.4 Starten der Animation

Eine schrittweise Abarbeitung kann mit Go Step erfolgen. Es sollten so viele Schritte

ausgeführt werden bis sich das System im Leerlauf befindet hier Executable is Idle. Im

Project Browser wird jetzt auch die Instanz der Klasse CountDown angezeigt.

Abbildung 14 Anzeige der angelegten Instanz


14

4.5 Animated Statechart

Ein Animated State Chart kann nicht der Klasse sondern nur einer Instanz zugeordnet

werden. Eine Klasse ist eine Beschreibung die tatsächliche Realisierung stellt die Instanz

dar.

Mit einem rechten Maus Klick auf die Instanz der Klasse CountDown[0] erreicht man das

Menue. Hier kann nun ein Animated Statechart mit Open instance Statechart geöffnet

werden werden. Neben der Dokumentenansicht CountDown gibt es jetzt eine weiter Ansicht

CountDown- CountDown[0], den Animated Statechart der Instanz CountDown[0]. Das im

Moment aktive Element wird fett eingefärbt dargestellt. Da wir bereits die Instanzierung

durchlaufen haben befindet sich der Zustandsautomat im Zustand sActive, den er erst durch

ein Timeout des Timers verlassen wird. Im Feature Menü der Instanz CountDown [0] kann

der Wert der Membervariabele iCount verfolgt werden. Aus der Toolbar kann jetzt die

gewünschte Aktion ausgewählt und ausgeführt werden.

Abbildung 15 Animated Statechart

Bei Änderungen im Zustandsautomat muss man darauf achten, dass die

Änderung in der Klasse CountDown und nicht in der Instanz CountDown -

CountDown[0] vorgenommen wird. Zur Simulation sollte dann aber wieder in die

Ansicht des Animated Statechart gewechselt werden.


15

5 Sequence Diagram zur Analyse

5.1 Einfügen eines Sequence Diagrams

Ein rechter Mausklick aufs Projekt Add New/Sequence Diagram fügt ein Sequence Diagram

ein. Hier wird der Name execution für das Diagramm gewählt. Als Diagram Mode wird

Analysis gewählt. Es handelt sich also um eine Ansicht, um im Projekt zu debuggen und zu

dokumentieren.

Abbildung 16 Sequence Diagram einfügen

Abbildung 17 Sequence Diagram umbenennen


16

5.2 Instanzen im Sequence Diagram einfügen

Ein Sequence Diagram benötigt eine Systemgrenze hier System Border. Von der Klasse

Countdown wird das Objekt itsCountDown direkt aus dem Projektbereich ins Sequence

Diagram gezogen.

Abbildung 18 Sequence Diagram erstellen

Das System kann wie gewohnt getestet werden. Das Sequence Diagram bleibt unverändert,

es wird aber zusätzlich ein Animated Sequence Diagram generiert und es werden die

Nachrichten dokumentiert.

Abbildung 19 Animated Sequence Diagram


17

6 Event

6.1 Event einfügen

Zusätzlich zum Zustand sACTIVE wird ein Zustand sIDLE eingefügt. Das System wird erst

aktiv wenn ein evStart den CountDown auslöst. Ein im Feature Menue einer Transition

angegebener Event wird ins Projekt integriert.

Abbildung 21 Übergang mit Event

Abbildung 22 Weiterer Zustand mit Event als Übergang

Der in der Transition angegebene Event evStart wird auch im Projectspace angezeigt.

Abbildung 23 Event im Projectspace


18

6.2 Event in der Animation auslösen

Das Projekt kann wie gewohnt gestartet werden, allerdings bleibt es nun im Zustand sIDLE

stehen. Der benötigte Event evStart muss in der Animation vom Nutzer erzeugt werden.

Dazu steht ein Event Generator zu Verfügung. Die Zuweisung des Wertes 10 an iCount wird

beim Betreten des Zustandes sIDLE ausgeführt. Die Anzeige kann durch Klick auf das

Symbol ein- und ausgeschaltet werden.

Abbildung 24 Event Generator auslösen

Abbildung 25 Event im Sequence Diagram


19

6.3 Attribute während der Animation anzeigen Die Animation wird gestartet, es empfiehlt sich hierzu Go Idle zu verwenden. Die Animation wurde nun zu einem Zeitpunkt angehalten, an dem die Instanzen bereits angelegt sind.

Abbildung 26 Instanz einer Klasse

Mit einem Klick der rechten Maustaste auf die entsprechende Instanz kann das Feature Menue der Instanz geöffnet werden.

Abbildung 27 Feature Menue einer Klasse


20

7 Aufgaben

7.1 Fußgängerampel

Erstellen Sie ein Modell für eine Fußgängerampel. Für den Fußgänger gibt es nur Grün und

Rot, für die Autos Grün, Gelb und Rot. Alle Signallichter werden in einer Klasse verwaltet.

Auf Anforderung schaltet die Fußgängerampel nach einer Sekunde um und nach weiteren

zehn Sekunden wird der Ausgangszustand wieder hergestellt. Die Schaltvorgänge werden

durch Textmitteilungen kenntlich gemacht.

7.2 Parkplatzschranke

Auf einem Parkplatz stehen 10 Parkplätze zur Verfügung. Die Anzahl der freien Parkplätze

wird angezeigt. Fährt ein Auto über eine Kontaktschleife, so wird -ein freier Parkplatz

vorausgesetzt- die Schranke geöffnet und die Anzahl der freien Parkplätze heruntergezählt

und angezeigt (hier eine Textausgabe). Eine weitere Kontaktschleife überwacht die

Durchfahrt. Kommt das Auto über diese Schleife, so wird die Schranke geschlossen.


21

8 Literatur

Nachfolgend findet sich eine Zusammenstellung weiterführender Informationen, die mit dem

Inhalt dieses Laborversuchs in Zusammenhang stehen.

[1] Rupp, Queins, Zengler; UML 2 Glasklar; Hanser

[2] http://www.ibm.com/developerworks/rational/products/rhapsody/

Documents

Labor Modellgestütztes Software Engineeringeitidaten.fh-pforzheim.de/daten/labore/sdly/SDLY_Versuch... · 2019-10-01 · CountDown- CountDown[0], den Animated Statechart der Instanz