labor modellgestütztes software...
Post on 26-Jul-2020
1 Views
Preview:
TRANSCRIPT
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
Labor Modellgestütztes Software Engineering – Aufgabe 2
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.
Labor Modellgestütztes Software Engineering – Aufgabe 2
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.
Labor Modellgestütztes Software Engineering – Aufgabe 2
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.
Labor Modellgestütztes Software Engineering – Aufgabe 2
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
Labor Modellgestütztes Software Engineering – Aufgabe 2
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.
Labor Modellgestütztes Software Engineering – Aufgabe 2
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
Labor Modellgestütztes Software Engineering – Aufgabe 2
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
Labor Modellgestütztes Software Engineering – Aufgabe 2
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.
Labor Modellgestütztes Software Engineering – Aufgabe 2
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.
Labor Modellgestütztes Software Engineering – Aufgabe 2
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
Labor Modellgestütztes Software Engineering – Aufgabe 2
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
Labor Modellgestütztes Software Engineering – Aufgabe 2
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.
Labor Modellgestütztes Software Engineering – Aufgabe 2
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
Labor Modellgestütztes Software Engineering – Aufgabe 2
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
Labor Modellgestütztes Software Engineering – Aufgabe 2
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
Labor Modellgestütztes Software Engineering – Aufgabe 2
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
Labor Modellgestütztes Software Engineering – Aufgabe 2
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
Labor Modellgestütztes Software Engineering – Aufgabe 2
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.
Labor Modellgestütztes Software Engineering – Aufgabe 2
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/
top related