myAVR Board MK2 2.10 User guide [de]

Download

Dipl. Ing. Toralf Riedel

Dipl. Ing. Päd. Alexander Huwaldt

Benutzerhandbuch SiSy®

für die Programmierung

von Mikrocontroller-

und PC-Anwendungen

gültig ab SiSy-Version 3.4

Die Informationen in diesem Produkt werden ohne Rücksicht auf einen eventuellen Patentschutz veröffentlicht. Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt. Bei der Zusammenstellung von Texten und Abbildungen wurde mit größter Sorgfalt vorgegangen. Trotzdem können Fehler nicht vollständig ausgeschlossen werden. Die Autoren können für fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung noch irgendeine Haftung übernehmen. Für Verbesserungsvorschläge und Hinweise auf Fehler sind die Autoren dankbar.

Alle Rechte vorbehalten, auch die der fotomechanischen Wiedergabe und der Speicherung in elektronischen Medien. Die gewerbliche Nutzung der in diesem Produkt gezeigten Modelle und Arbeiten ist nicht zulässig.

Fast alle Hardware- und Softwarebezeichnungen, die in diesem Dokument erwähnt werden, sind gleichzeitig auch eingetragene Warenzeichen und sollten als solche betrachtet werden.

1. Auflage: April 2013

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Inhalt Seite: 3/152

Inhalt

1 Einleitung..........................................................................................................................................7

2 Vorbereitung.....................................................................................................................................8

2.1 Installation der Software..............................................................................................................8

2.1.1 Voraussetzungen.................................................................................................................8

2.1.2 Setup von der SiSy-CD........................................................................................................8

2.2 Beschaffen bzw. Herstellen der Hardware................................................................................11

3 Arbeiten mit SiSy, allgemein...........................................................................................................12

3.1 Projektarbeit ..............................................................................................................................12

3.1.1 Was ist ein SiSy-Projekt?...................................................................................................12

3.1.2 Neues Projekt erstellen......................................................................................................12

3.1.3 Vorhandenes Projekt öffnen ..............................................................................................14

3.1.4 Projekt archivieren .............................................................................................................14

3.1.5 Projektarchiv einlesen........................................................................................................14

3.1.6 Projektarchiv als Email versenden.....................................................................................14

3.2 Die Modellierungselemente von SiSy .......................................................................................15

3.3 Die Fenster für die Modellierung ...............................................................................................16

3.4 Modelle bearbeiten....................................................................................................................17

3.4.1 Modellelemente anlegen....................................................................................................17

3.4.2 Modellelemente auswählen ...............................................................................................17

3.4.3 Modellelemente untersuchen (Report) ..............................................................................17

3.4.4 Modellelemente verschieben .............................................................................................18

3.4.5 Die Größe von Modellelementen verändern......................................................................18

3.4.6 Modellelemente verbinden.................................................................................................18

3.4.7 Modellelemente löschen ....................................................................................................18

3.4.8 Modellelemente kopieren...................................................................................................19

3.4.9 Modellelemente ausschneiden ..........................................................................................19

3.4.10 Diagramme kopieren (flache Kopie) ..................................................................................19

3.4.11 Modelle kopieren (tiefe Kopie) ...........................................................................................19

3.4.12 Die Modellhierarchie bearbeiten (Jo-Jo)............................................................................20

3.5 Die Ansicht verändern...............................................................................................................20

3.5.1 Fensterinhalt verschieben..................................................................................................20

3.5.2 Fensterinhalt vergrößern oder verkleinern.........................................................................20

3.5.3 Fensterinhalt farbig oder als Kontur darstellen..................................................................20

3.5.4 Die Schriftart ändern..........................................................................................................20

3.6 Druckfunktionen in SiSy ............................................................................................................21

3.6.1 Diagramme drucken...........................................................................................................21

3.6.2 Grafiken und Inhalte drucken (QuickDok)..........................................................................23

3.6.3 Nur Quellcodes drucken ....................................................................................................24

3.6.4 Nutzen der Zwischenablage ..............................................................................................25

3.7 SiSy Add-Ons verwalten ...........................................................................................................26

3.7.1 Einführung..........................................................................................................................26

3.7.2 Add-Ons anzeigen .............................................................................................................27

3.7.3 Add-Ons hinzufügen ..........................................................................................................28

3.8 LibStore.....................................................................................................................................29

3.8.1 Handhabung: ein Projekt mit LibStore anlegen.................................................................29

3.8.2 Handhabung: LibStore in einem Projekt nutzen................................................................29

3.9 Die Hilfefunktionen in SiSy........................................................................................................30

3.9.1 Der Assistent......................................................................................................................30

3.9.2 Die Online-Hilfe..................................................................................................................31

3.9.3 Die allgemeine Hilfe...........................................................................................................32

3.9.4 SiSy Code Vervollständigung ............................................................................................33

4 Entwicklung eines kleinen Programms...........................................................................................34

4.1 Vorgehen für PC Programme....................................................................................................34

Seite: 4/152 Inhalt

4.2 Vorgehen für AVR Programme ................................................................................................36

4.3 Vorgehen für ARM Produkte .................................................................................................... 43

5 Entwicklung eines großen Programms.......................................................................................... 48

5.1 Einleitung..................................................................................................................................48

5.2 Vorgehen für PC Programme................................................................................................... 48

5.2.1 Zielstellung........................................................................................................................ 48

5.2.2 Hauptprogramm erstellen.................................................................................................. 48

5.2.3 Units (Unterprogramme) anlegen und verknüpfen............................................................ 49

5.3 Vorgehen für AVR Programme ................................................................................................51

5.3.1 Zielstellung........................................................................................................................ 51

5.3.2 Neues Projekt anlegen...................................................................................................... 51

5.3.3 Hauptprogramm erstellen.................................................................................................. 52

5.3.4 Units (Unterprogramme) anlegen und verknüpfen............................................................ 53

5.3.5 Interrupt-Service-Routine (ISR) im großen Programm ..................................................... 56

5.4 Vorgehen für ARM Programme................................................................................................ 57

5.4.1 Zielstellung........................................................................................................................ 57

5.4.2 Neues Projekt anlegen...................................................................................................... 57

5.4.3 Hauptprogramm erstellen.................................................................................................. 58

5.4.4 Units (Unterprogramme) anlegen und verknüpfen............................................................ 59

5.4.5 Übersetzen, Brennen und Test......................................................................................... 62

5.4.6 Interrupt-Service-Routine (ISR) im großen Programm ..................................................... 63

6 Entwicklung Programmablaufplan für AVR Programme ...............................................................64

6.1 Einleitung..................................................................................................................................64

6.2 Einfache Programmentwicklung aus einem PAP..................................................................... 64

6.2.1 Zielstellung........................................................................................................................ 64

6.2.2 Vorbereitung...................................................................................................................... 64

6.2.3 Grundstruktur laden .......................................................................................................... 66

6.2.4 Logik entwerfen................................................................................................................. 66

6.2.5 Befehle eingeben .............................................................................................................. 67

6.2.6 Übersetzen, Brennen und Test......................................................................................... 69

6.3 Unterprogrammtechnik im PAP................................................................................................72

6.3.1 Anlegen eines Unterprogramms.......................................................................................72

6.3.2 Ein Unterprogramm aufrufen............................................................................................. 73

6.3.3 Unterprogramme mehrmals benutzen..............................................................................74

6.4 Interrupt-Service-Routinen (ISR) im PAP.................................................................................75

6.5 Daten im PAP........................................................................................................................... 76

6.5.1 Anlegen eines Datenobjektes ........................................................................................... 76

6.5.2 Datenobjekt benutzen ....................................................................................................... 76

7 Programmentwicklung aus einem Struktogramm.......................................................................... 77

7.1 Einleitung..................................................................................................................................77

7.2 Vorgehen für AVR Programme ................................................................................................78

7.2.1 Zielstellung........................................................................................................................ 78

7.2.2 Vorbereitung...................................................................................................................... 78

7.2.3 Struktogramm entwickeln.................................................................................................. 79

7.2.4 Programmtest.................................................................................................................... 81

8 Entwicklung von Klassendiagrammen........................................................................................... 82

8.1 Einleitung..................................................................................................................................82

8.2 Vorgehensweise für PC- Programme mit SVL......................................................................... 83

8.2.1 Zielstellung........................................................................................................................ 83

8.2.2 Vorbereitung...................................................................................................................... 83

8.2.3 Grundgerüst für Fenster auswählen ................................................................................. 83

8.2.4 Schaltfläche mit Hilfe des Control-Wizards erstellen........................................................84

8.2.5 Quellcode hinzufügen ....................................................................................................... 85

8.2.6 Kompilieren und Linken des fertigen Programms............................................................. 85

8.3 Vorgehensweise für AVR Programme ..................................................................................... 86

8.3.1 Zielstellung........................................................................................................................ 86

8.3.2 Vorbereitung...................................................................................................................... 86

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Einleitung Seite: 5/152

8.3.3 Grundstruktur laden ...........................................................................................................87

8.3.4 Systemstruktur entwerfen ..................................................................................................88

8.3.5 Systemverhalten programmieren.......................................................................................91

8.3.6 Übersetzen, Brennen und Testen......................................................................................92

8.3.7 Interrupt-Service-Routinen (ISR) im Klassendiagramm ....................................................93

8.4 Vorgehensweise für ARM Programme......................................................................................94

8.4.1 Zielstellung.........................................................................................................................94

8.4.2 Vorbereitung.......................................................................................................................94

8.4.3 Grundstruktur laden ...........................................................................................................95

8.4.4 Systemstruktur entwerfen ..................................................................................................97

8.4.5 Systemverhalten programmieren.....................................................................................101

8.4.6 Übersetzen, Brennen und Testen....................................................................................102

8.5 Der Sequenzdiagrammgenerator............................................................................................103

8.5.1 Einführung in das Sequenzdiagramm..............................................................................103

8.5.2 Sequenzen.......................................................................................................................103

8.5.3 Sequenzen weiter verwenden..........................................................................................106

8.5.4 Besonderheiten des SiSy-Sequenzdiagramms...............................................................106

9 Programmieren mit dem UML Zustandsdiagramm ......................................................................107

9.1 Einführung in die Zustandsmodellierung.................................................................................107

9.2 Erstellen von Zustandsdiagrammen........................................................................................107

9.2.1 Zielstellung.......................................................................................................................107

10 Zusätzliche Werkzeuge ................................................................................................................112

10.1 Einführung...............................................................................................................................112

10.2 Das ControlCenter...................................................................................................................112

10.2.1 Einleitung .........................................................................................................................112

10.2.2 Besonderheiten für myAVR Systemboards.....................................................................112

10.2.3 Kommunikation mit dem Controller..................................................................................114

10.2.4 Empfangene Daten speichern .........................................................................................118

10.2.5 Daten an den Controller senden......................................................................................119

10.3 Der myAVR MK2 Simulator.....................................................................................................121

10.3.1 Einleitung .........................................................................................................................121

10.3.2 Simulator starten und konfigurieren.................................................................................121

10.3.3 Die Programmsimulation durchführen.............................................................................122

10.4 Der myAVR Code-Wizard .......................................................................................................124

10.4.1 Einführung........................................................................................................................124

10.4.2 Grundeinstellungen..........................................................................................................125

10.4.3 Geräteeinstellungen.........................................................................................................125

10.4.4 Unterprogramme..............................................................................................................126

10.4.5 Projektdaten.....................................................................................................................126

10.4.6 Codegenerierung .............................................................................................................127

10.5 Das STM32 ST-Link Utility ......................................................................................................128

10.6 Das myAVR ProgTool .............................................................................................................134

10.6.1 Übersicht zum myAVR Progtool ......................................................................................134

10.6.2 Einstellungen Fuse- und Lock-Bits für AVR Produkte.....................................................139

10.7 Der Debugger..........................................................................................................................143

10.7.1 Debuggen von SVL Programmen....................................................................................143

10.7.2 Der SVL-DebugMonitor....................................................................................................145

10.7.3 Das SVL-Werkzeug RegExp............................................................................................146

10.8 Weitere Werkzeuge.................................................................................................................147

11 Informationen zu SiSy-Ausgaben.................................................................................................148

Anhang: Tastaturbelegung, allgemein..................................................................................................149

Anhang: Mausoperationen ...................................................................................................................151

Einleitung Seite: 7/152

1 Einleitung

Sie haben eine Ausgabe des Modellierungswerkzeuges Simple System, kurz SiSy, erworben. Bevor auf die verschiedenen Funktionen des Programms eingegangen wird, noch einige Worte zum vorliegenden Handbuch. Mit Hilfe des Handbuchs werden dem Nutzer die Grundlagen der Bedienung von SiSy erläutert. Der Inhalt, die Gestalt und die Regeln der Modelle werden nur am Rand betrachtet. Das genaue Vorgehen für die Programmierung eines Mikroprozessors wird an einem Beispiel ausführlich beschrieben. Auf die Grundlagen der Mikroprozessorprogrammierung wird im Rahmen dieses Handbuches nicht eingegangen. Dazu dienen die myAVR Lehrbücher. Dem Nutzer wird in diesem Handbuch der Einstieg in das Programm erleichtert und die umfangreichen Funktionen von SiSy kurz und verständlich beschrieben. Bei der Arbeit mit SiSy erstellt der Anwender Modelle in Form von Diagrammen und in ihnen enthaltene Symbole. Die Grundlagen der Entstehung und Bearbeitung solcher Diagramme sind Gegenstand der Betrachtung dieses Handbuchs. Folgende Darstellungs- und Gestaltungsmittel sind für den Nutzer bei der Arbeit mit SiSy besonders wichtig:

• die Diagramme als Fenster zur Ansicht und Bearbeitung von Modellen;

• der Navigator als Fenster zur Steuerung und Bewegung in Modellen;

• der Assistent mit Hilfestellungen zum jeweils geöffneten Diagramm und mit Dia-

grammvorlagen (wenn vorhanden);

• die Menüs und Schalter für Befehle an Navigator, Diagramm und Objekt im Kontext

mit der Modellierung.

Zu den Bezeichnungen im Text:

• Falls ein Menübefehl nur über Untermenüs zu erreichen ist, werden die einzelnen Menübezeichnungen kursiv geschrieben und durch Schrägstriche voneinander getrennt. Beispiel: Menü Hilfe/über SiSy

• Titel von Dialogboxen, Schaltflächen und Menüpunkten werden in AnführungsZeichen gesetzt. Beispiel: Dialogbox „Definition“, Schaltfläche „OK“

Zu den beschriebenen SiSy Ausgaben und Referenzhardware

Die Beschreibungen in diesem Handbuch beziehen sich auf die SiSy Ausgaben

• SiSy AVR: Mikrocontrollerprogrammierung für AVR-Programmierung in Assembler und C/C++ sowie UML; die verwendete Referenzhardware für die Beispielprogramme ist ein myAVR Board MK2

• SiSy ARM: Mikrocontrollerprogrammierung für ARM- Programmierung in C/C++ sowie UML; die verwendete Referenzhardware für die Beispielprogramme ist ein Board STM32F4-Discovery

• SiSy Mikrocontroller++: Mikrocontrollerprogrammierung für AVR-, ARM- und Windows-Programmierung

Abbildungen im Handbuch Die Abbildungen in diesem Handbuch beziehen sich auf die jeweils gestellte Aufgabe und sind mit der entsprechenden Ausgabe erstellt.

Seite: 8/152 Vorbereitung

2 Vorbereitung

In diesem Kapitel werden Sie über notwendige Schritte zur Installation, Konfiguration und Aufbau einer funktionsfähigen Entwicklungsumgebung informiert.

2.1 Installation der Software

Für die Bearbeitung der Übungen und Aufgaben steht Ihnen die Entwicklungsumgebung SiSy AVR, SiSy ARM bzw. SiSy Microcontroller ++ zur Verfügung. Sollten Sie SiSy bereits installiert haben, können Sie dieses Kapitel überspringen. Die Installation und der erste Start müssen mit Administratorrechten ausgeführt werden.

2.1.1 Voraussetzungen

Für die Installation benötigen Sie einen Freischaltcode (Lizenzangaben). Falls Sie diese Angaben nicht mit der Software erhalten haben, können Sie diese online abrufen von

www.sisy.de  Meine SiSy-Lizenz

oder fordern Sie diese beim Hersteller an: Tel: 03585-470222 Fax: 03585-470233 e-Mail:

Bitte prüfen Sie, ob die Systemvoraussetzungen für die Installation und die Arbeit mit SiSy für die Mikrocontrollerprogrammierung gewährleistet sind.

• PC-Arbeitsplatz oder Notebook mit USB-Anschluss

• PC mit Windows XP, Vista oder Windows 7

• Microsoft Internet-Explorer 7 oder höher

• Maus oder ähnliches Zeigegerät

• Assembler bzw. C/C++ Entwicklungsumgebung (in SiSy bereits integriert)

• myAVR Board MK2 bzw. STM32F4-Discovery

• Programmierkabel

• Bei Bedarf (z.B. autonomer Einsatz des Boards) geeignete Spannungsversorgung

Des Weiteren sollten Sie Grundkenntnisse in einer beliebigen Programmiersprache besitzen.

2.1.2 Setup von der SiSy-CD

Legen Sie die CD „SiSy“ in Ihr CD-ROM-Laufwerk ein. Falls die CD nicht automatisch startet, wählen Sie bitte im Explorer das CD-ROM-Laufwerk und starten die „setup.exe“ aus dem Pfad CD-Laufwerk:\Ausgabe\SiSy. Auf dem Startbildschirm stehen Schaltflächen zur Verfügung zum Installieren der Software und zum Öffnen von Begleitdokumenten. Für die Installation der Software betätigen Sie die entsprechende Schaltfläche. In Abhängigkeit Ihrer Rechnerkonfiguration kann der Start des Setup-Programms einige Sekunden dauern. Das gestartete Setup-Programm wird Sie durch die weitere Installation führen.

oder

www.myAVR.de  Online-Shop Kontakt/Service

support@myAVR.de.

• USB Kabel (myAVR Board MK2)

• Mini-USB-Kabel (STM32F4-Discovery)

z.B. 9 V Batterie / stabilisiertes 9 V Netzteil

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Vorbereitung Seite: 9/152

Beginn der Installation

Betätigen Sie im Setup-Programm die Schaltfläche „Weiter“. Sie erhalten die Lizenzbestimmungen. Bitte lesen Sie diese sorgfältig durch. Wenn Sie sich mit diesen Bestimmungen einverstanden erklären, bestätigen Sie die Lizenzbestimmungen mit der Schaltfläche „Annehmen“. Sie werden im folgenden Dialog dazu aufgefordert, Ihre Lizenzangaben einzugeben.

Danach erscheint die Dialogbox „Komponenten auswählen“, welche Sie mit „Weiter“ bestätigen. Im darauf folgenden Fenster können Sie festlegen, unter welchem Pfad SiSy installiert werden soll. Wenn ein anderer Pfad (bzw. ein anderes Laufwerk) gewünscht wird, aktivieren Sie die Schaltfläche „Durchsuchen“. Eine Dialogbox erscheint, in der Sie Laufwerk und Verzeichnis auswählen können.

Bestimmen Sie danach den Startmenü-Ordner, in dem die Verknüpfungen von SiSy eingefügt werden. Sie können den Zielordner ändern; Sie können dies durch auswählen von „Keine Verknüpfungen erstellen“ unterbinden.

Seite: 10/152 Vorbereitung

Beginnen Sie nun die Installation durch Betätigen der Schaltfläche „Installieren“. Während der Installation erhalten Sie ggf. Hinweise, dass verschiedene Treiber installiert bzw. aktualisiert werden sollten. Es wird stets eine Eingabe erwartet. In Abhängigkeit Ihrer Rechnerkonfiguration kann die komplette Installation einige Minuten in Anspruch nehmen. Zum Abschluß der Installation wird ein entsprechendes Dialogfeld angezeigt. Mit dem Aktivieren der Schaltfläche „Fertig stellen“ ist die Installation abgeschlossen.

Sie können nun SiSy starten. Es erscheint auf Ihrem Bildschirm der Dialog „Willkommen in SiSy“. Folgen Sie dann den Hinweisen des Assistenten, indem Sie „Assistent öffnen“ auswählen.

Hinweis: In SiSy sind 2 Dateien enthalten, die Makros beinhalten („handbuch.doc“, „multi.doc"). Von einigen Virenscannern werden diese Makros als „Virus“ erkannt und entsprechend behandelt. In den Heuristik-Einstellungen des Virenscanners kann diese Behandlung unterdrückt werden.

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Vorbereitung Seite: 11/152

2.2 Beschaffen bzw. Herstellen der Hardware

Alle Ausführungen, Übungen und Aufgabenstellungen in diesem Benutzerhandbuch beziehen sich für die AVR-Programmierung auf ein myAVR Board MK2 und für die ARM-Programmierung auf ein STM32F4-Discovery als Referenzhardware. Dokumente sowie Anwendungsbeispiele zu myAVR Boards stehen zum Download bereit unter

www.myAVR.de. Für das STM32F4-Discovery sind frei verfügbare, fertig lauffähige

Beispiele auf

www.st.com erhältlich.

myAVR Board MK2 mit USB-Port

STM32F4-Discovery mit Mini USB-Port

Für die Bearbeitung der Beispiele in diesem Handbuch benötigen Sie die nachfolgend aufgeführte Hard- bzw. Software; sie ist exemplarisch zu verstehen.

PC-Programme AVR-Programme ARM-Programme

Hardware

SiSy Microcontroller ++ oder SiSy Professional

Software

• bestücktes myAVR Board

• Programmierkabel (USB)

• Patchkabel

• 9 V Netzteil / Batterie

bei Bedarf

(z.B.: autonomer Einsatz) SiSy Microcontroller ++ oder SiSy AVR oder eine andere SiSy Ausgabe mit dem Add-On AVR

• STM32F4-Discovery

• Programmierkabel

(Mini-USB)

• STM-Patchkabel

• STM32-Board-F4D

(optional) SiSy Microcontroller ++ oder SiSy ARM oder eine andere SiSy Ausgabe mit dem Add-On ARM

Ausführliche Beschreibungen zur Programmierung mit Assembler sowie C/C++ sind nicht Inhalt dieses Handbuches. Weiterführende Erklärungen dazu sind im „myAVR Lehrbuch Mikrocontrollerprogrammierung“ enthalten.

Seite: 12/152 Arbeiten mit SiSy, allgemein

ein Projekt dieses Namens existiert bereits.

der das vorhandene Projekt

3 Arbeiten mit SiSy, allgemein

Um dem Nutzer zu erläutern, wie er in SiSy modellieren kann, werden zweckentsprechende Definitionen der Begriffe gegeben.

3.1 Projektarbeit

3.1.1 Was ist ein SiSy-Projekt?

Ein SiSy-Projekt ist eine abgegrenzte Menge von verknüpften Elementen für ein zu bearbeitendes Problem. Alle aktuellen Daten sind in einer Projektdatenbank gespeichert. Die Projektdatenbank besteht aus einer Anzahl von Dateien im Projektverzeichnis, wobei jedes Projekt sein eigenes Verzeichnis hat. Durch das Anlegen eines Projektarchivs können diese in einer Datei komprimiert werden.

3.1.2 Neues Projekt erstellen

In SiSy legen Sie stets ein Projekt an. In dieses Projekt integrieren Sie Ihr Programm bzw. mehrere Programme. Unabhängig vom Programmnamen benötigt jedes Projekt einen Namen. Ein neues Projekt wird eingerichtet und für die Bearbeitung bereitgestellt. Die Definition (Erstellung) eines neuen Projektes erfolgt durch Vergabe eines Projektdateinamens und/oder durch Überschreiben eines alten Projektes gleichen Namens. Über die Schaltfläche „Ordner für Projekte ändern“ kann die vorgeschlagene Pfadangabe geändert werden.

Hinweis: Falls ein bereits vorhandener Projekt- oder Verzeichnisname gewählt wird, erscheint folgende Meldung:

„Achtung: Ändern Sie den Projektnamen o wird gelöscht und durch das neue ersetzt.“

Vorgehensmodell auswählen

Nach der Vergabe eines Projektnamens kann im nachfolgenden Fenster ein Vorgehensmodell ausgewählt werden. Die Auswahl des Vorgehensmodells bestimmt im weiteren Projektverlauf die von SiSy zur Verfügung gestellten Werkzeuge. Je nach Vorgehensmodell können Vorlagen oder Assistenten das Erstellen eines neuen Projektes unterstützen. Stehen in Ihrer SiSy Ausgabe mehrere Vorgehensmodelle (Hauptebenen) zur Verfügung, wird eine Auswahl der Hauptebene angeboten. Mit der Auswahl des Vorgehensmodells (VGM) entscheiden Sie über das Profil des Projektes. Ist ein Projekt klein und die Modellierung von Programmablaufplänen nicht erforderlich, wählt man ein einfaches Vorgehensmodell; in den gezeigten Beispielen im Abschnitt 4 das Vorgehensmodell „Programmierung“. Damit sind die Menüs und Objektbibliotheken entsprechend übersichtlicher. Bei komplexen Projekten, für die neben kleinen Programmen auch Programmablaufpläne, Struktogramme oder Klassendiagramme nötig sind, wird ein komplexeres Vorgehensmodell wie z.B. „AVR-Vorgehensmodell“ bzw. „ARM-Vorgehensmodell“ ausgewählt. Die folgenden Abbildungen zeigen für 2 verschiedene Vorgehensmodelle die verfügbaren Werkzeuge.

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Arbeiten mit SiSy, allgemein Seite: 13/152

Verfügbare Werkzeuge

- kleines Programm ASM

- kleines Programm C

- großes Programm ASM

- großes Programm C

Vorgehensmodell „Programmierung“ mit den verfügbaren Werkzeugen

Verfügbare Werkzeuge

- kleines Programm ASM

- kleines Programm C

- großes Programm ASM

- großes Programm C

- Programmablaufplan ASM

- Struktogramm C

- Klassendiagramm C++

Vorgehensmodell „AVR Vorgehensmodell“ mit den verfügbaren Werkzeugen

Im weiteren Verlauf werden entsprechend der Auswahl des Vorgehensmodells unterschiedliche Hilfen zum Erstellen eines Programms angeboten. Für Einsteiger empfiehlt sich zuerst die Nutzung des Vorgehensmodells „Programmierung“.

Seite: 14/152 Arbeiten mit SiSy, allgemein

3.1.3 Vorhandenes Projekt öffnen

Ein vorhandenes Projekt wird geöffnet und die abgespeicherten Diagramme und Objekte sowie alle Möglichkeiten für die weitere Bearbeitung werden verfügbar gemacht. Die Wahl des Projektes erfolgt durch Klicken auf den entsprechenden Namen oder über die Schaltfläche „Projekt suchen“. Ist der Mauszeiger auf dem Projektnamen oder auf den Symbolen, dann werden Informationen angezeigt.

3.1.4 Projekt archivieren

Menü Projekt/Archiv/Anlegen. Es kann ein komprimiertes Archiv des Projektes erzeugt werden. Dies ist besonders aus Gründen der Datensicherheit sinnvoll. Zielverzeichnis und Dateiname für die Archivdatei werden vorgeschlagen und können korrigiert werden. Beim Aktivieren der Checkbox „Datum anfügen“ wird das Projekt mit Änderungsdatum gespeichert. Wenn ein Projekt unter einem bereits vorhandenen Archivnamen angelegt werden soll, wird eine Warnung vor dem Überschreiben angezeigt. Bei Auswahl von „Nein“ wird die Erstellung des Archivs abgebrochen, bei „Ja“ wird das Projekt archiviert.

Hinweis: SiSy bietet die Möglichkeit des regelmäßigen Abspeicherns verschiedener Arbeitsstände, d.h. ein archiviertes Projekt wird nicht überschrieben. Ein Projektstand kann in einer neuen Archivdatei abgelegt werden.

3.1.5 Projektarchiv einlesen

Menü Projekt/Archiv/Einlesen. Hierunter versteht man das Einlesen eines Archivs zum Zweck der Rekonstruktion des Projektes. Einlesen bedeutet Entpacken eines archivierten Projektes. Dazu muss das Archiv ausgewählt sein. Beim Aktivieren der Checkbox „Datum entfernen“ wird das Datum nicht im Projektnamen geschrieben.

Hinweis: Wenn im Zielpfad des Entpackens bereits ein Projekt existiert, erscheint eine Überschreibwarnung.

3.1.6 Projektarchiv als Email versenden

Menü Projekt/Archiv/Als Email versenden…. Um Projekte per Email zu versenden, sollten diese zu einem Archiv zusammengefasst werden. Die Funktion „Projektarchiv als Email versenden“ erzeugt von dem aktuell geöffneten Projekt ein Archiv, startet das Standard-Email-Programm Ihres Systems, legt eine neue Email an und fügt das Archiv als Anlage ein. Sie können jetzt die Email schreiben und sofort das Projektarchiv senden.

Hinweis: Das Standard-Email-Programm Ihres Systems muss ordnungsgemäß eingerichtet und registriert sein, damit diese Funktion korrekt ausgeführt werden kann. Es ist nicht möglich, diese Funktion mit einem WEB-Browser-Email-Programm zu nutzen.

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Arbeiten mit SiSy, allgemein Seite: 15/152

3.2 Die Modellierungselemente von SiSy

Werkzeug

SiSy stellt für die Bearbeitung der Modelle und Teilmodelle Werkzeuge der entsprechenden Methodik bereit. Werkzeuge sind Editoren, mit denen in einem Fenster die grafische Darstellung (Diagramme) der Modelle bearbeitet werden kann.

Modellelemente

Modelle bestehen aus Elementen, welche zueinander in Beziehung stehen. Diese Modellelemente werden nach bestimmten Regeln (Metamodell) durch SiSy verarbeitet und dargestellt (Notation). Modellelemente sind in der Regel Knoten (Objekte), Kanten (Verbindungen), Rahmen, Referenzen auf Modellelemente und Texte. Prinzipiell kann jedes Modellelement verfeinert werden. Typisch ist es Knoten (Objekte) dadurch zu verfeinern, dass „unter“ diesen Objekten weitere Modellelemente angelegt werden. Dabei entsteht eine Modellhierarchie. Jedes Modellelement verfügt über einen Kurznamen, einen Langnamen, eine Beschreibung und modellinterne Attribute (Inhalt).

Diagramme

Diagramme sind grafische Darstellungen von Modellen oder Teilmodellen, die mit einem bestimmten Werkzeug erstellt werden. Die Modellierungselemente werden als Objekte in den Diagrammen unter Einhaltung von Regeln zusammengestellt.

Objekte

Objekte sind mögliche Modellelemente in Diagrammen, z.B. „kleines Programm“ in der „Programmierung“. Objekttypen sind konkrete Ausprägungen von Objekten, die in einem Diagramm angelegt wurden, z.B. Objekttyp „Lauflicht“ vom Objekt „kleines Programm“.

Referenzen

Die Objekte eines Diagramms können in anderen Diagrammen wieder verwendet werden. Durch das Hineinziehen aus dem Navigator oder aus einem offenen Diagramm wird eine Referenz vom Originalobjekt erzeugt. Die Referenz ist nur ein Verweis auf das Original, alle angezeigten Informationen wie Kurzname, Langname und Beschreibung werden vom Original bezogen. Somit sind die Informationen in allen Referenzen eines Objektes identisch mit dem Original. Dadurch werden Änderungen dieser Informationen automatisch auf alle Referenzen übertragen. Weiterhin ist es möglich, diese Referenzierung über einen so genannten Report auszuwerten.

Kanten

Kanten sind Verbindungselemente zwischen Objekten. Eine Verbindung wird durch Ziehen mit der Maus (linke Maustaste) vom Verteiler des selektierten Objektes auf das gewünschte Objekt erreicht. Nach Loslassen der Maustaste und Prüfung der Verbindungszulässigkeit durch SiSy erscheint ein Kanten-Dialog, in dem das Element definiert und individuelle Einstellungen getroffen werden können.

Hinweis: Bei Verbindung mit gehaltener S

TRG

-Taste wird die Prüfung vernachlässigt und eine

Zwangsverbindung erreicht.

Rahmen

Ein Rahmen fasst ausgewählte Objekte des Diagramms optisch zusammen. Er besitzt einen Kurz- sowie Langnamen und eine Objektbeschreibung, kann also als Objekt aufgefasst werden. Inhalte von Rahmen sind in Reports oder einer Dokumentengenerierung auswertbar.

Seite: 16/152 Arbeiten mit SiSy, allgemein

3.3 Die Fenster für die Modellierung

Navigator

Dieser befindet sich im linken, oberen Teil des Fensters. Er ermöglicht dem Anwender die Orientierung über die in der Projektdatenbank gespeicherten Objekte sowie deren Bereitstellung für die weitere Verwendung. Nach dem Start von SiSy werden neben dem Vorgehensmodell eine Reihe leicht zu handhabender Schaltflächen, Menüs und weitere Hilfsmittel angezeigt.

SiSy Assistent

Am linken unteren Bildschirmrand befindet sich diese Nutzerunterstützung.

• Er begleitet den Anwender durch das gesamte Projekt und hält immer passende Informationen zur aktuellen Sicht parat

• Er ist auf die jeweilige Ausgabe von SiSy bezogen.

• Oft können Beispiele als Vorlagen vom Assistenten geladen werden.

Diagrammfenster

Am oberen Bildrand befinden sich das Hauptmenü, das hilfreiche Funktionen zu SiSy bereithält, und eine Werkzeugleiste, mit deren Hilfe schnell auf nützliche Anwendungen zugegriffen werden kann. Das Diagrammfenster nimmt die rechte Bildschirmseite ein und ist der Raum, in dem der Nutzer modelliert. Es enthält:

• das ausgewählte Vorgehensmodell,

• die Objektbibliothek mit den möglichen Objekten des aktuellen Diagramms sowie

• ein Fenster zur Beschreibung des markierten Objekts, in diesem Fall zum Editieren

des Quelltextes.

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Arbeiten mit SiSy, allgemein Seite: 17/152

Die Bedienelemente/Objektbibliothek

SiSy bietet, wie bei Windows-Anwendungen üblich, die Steuerung von Befehlen über das Hauptmenü, über die Werkzeugleisten, die Tastatur oder die Objektbibliothek an. Darüber hinaus enthalten das Kontextmenü und der Navigator Steuerfunktionen.

Die Anzahl der möglichen Befehle in der Menüleiste ist abhängig davon, ob ein Projekt geöffnet ist. Ist das nicht der Fall, erscheint ein Menü mit wenigen Befehlen. Bei einem geöffneten Projekt hält SiSy umfangreichere Menüs bereit. Die wichtigsten Menübefehle befinden sich auch als grafische Schaltfläche in der Werkzeugleiste, die eine schnelle und effiziente Bedienung des Programms ermöglicht. Die Toolbox-Darstellung bietet dem Anwender wichtige Programmfunktionen als direkten Link an. Ein weiteres Bedienelement ist die Objektbibliothek. Sie unterstützt das Anlegen neuer Objekte.

3.4 Modelle bearbeiten

3.4.1 Modellelemente anlegen

Modellelemente können auf verschiedene Art und Weisen erzeugt werden. Der häufigste Weg ist das Anlegen über die Objektbibliothek. Dabei wird das gewünschte Element per Drag und Drop von der Objektbibliothek in das dazugehörige Diagrammfenster gezogen. Referenzen auf vorhandene Modellelemente werden üblicherweise dadurch erzeugt, dass diese per Drag und Drop aus dem Navigator in das gewünschte Diagramm gezogen werden. Verbindungen lassen sich am Einfachsten über den Verteiler herstellen. Sie können aber Modellelemente auch durch kopieren oder importieren anlegen.

3.4.2 Modellelemente auswählen

Die meisten Modellelemente lassen sich in Diagrammen auswählen (selektieren). Das Selektieren erfolgt in der Regel durch Anklicken (linke Maustaste) mit dem Mauscursor. Eine Selektion per Klick mit der rechten Maustaste ist ebenfalls möglich, dabei öffnet sich nach dem Auswählen sofort das Kontextmenü für das selektierte Modellelement. Das Betätigen der Tabulatortaste bewirkt das Auswählen des nächsten Modellelementes in der Reihenfolge des Anlegens der Elemente. Wird über die Auswahl mit der Tabulatortaste das letzte Element erreicht, beginnt die nächste Iteration wieder beim ersten Modellelement im Diagramm. Durch Betätigen der Umschalttaste kann die Iterationsrichtung umgeschaltet werden. Es ist ebenfalls möglich, mehrere Modellelemente auszuwählen. Dafür muss beim Selektieren mit der Maus die Umschalttaste gehalten werden. Bei gehaltener Umschalttaste lassen sich mehrere Objekte (keine Kanten und Rahmen) durch Ziehen einer Markise mit dem Mauscursor auswählen. Über den Menüpunkt Bearbeiten/Diagramm/Alles markieren können Sie alle Objekte des aktiven Diagramms selektieren.

3.4.3 Modellelemente untersuchen (Report)

Modellelemente sind in den meisten Fällen nicht isoliert sondern haben vielfältige Beziehungen zu anderen Modellelementen. Um bei Änderungen, wie zum Beispiel Umbenennen oder Löschen, mögliche Auswirkungen auf das gesamte Modell zu überblicken, bietet der Objektreport die Möglichkeit die Modellbeziehungen des ausgewählten Objektes auszuwerten. Wählen Sie ein Objekt aus und öffnen Sie den Reportdialog über das Hauptmenü, die Werkzeugleiste oder das Kontextmenü (diagrammabhängig). Wählen Sie die erforderliche Modellanfrage und starten den Report. Das Ergebnis der Modellanfrage (z.B. Alle angebundenen Objekte) wird als Liste angezeigt. Sie können dann zu diesen Modellelementen navigieren.

Seite: 18/152 Arbeiten mit SiSy, allgemein

3.4.4 Modellelemente verschieben

Bestimmte Modellelemente (z.B. Knoten/Objekte) lassen sich im Diagramm frei anordnen. Das Positionieren erfolgt in der Regel durch Drag und Drop mit der Maus. Die Modellelemente werden dabei an einem Raster ausgerichtet. Das Raster erleichtert die Positionierung. Um die Rasterfangfunktion zu unterbinden, muss beim Drag und Drop eines Elementes die Umschalttaste betätigt werden. Viele Modellelemente lassen sich auch über die Cursortasten verschieben. Dabei bewegen sich die Modellelemente in Richtung der betätigten Taste auf dem Raster. Auch dabei lässt sich durch die Umschalttaste die Rasterfangfunktion unterbinden. Bei Kanten wird ein Stützpunkt verschoben, der in Abhängigkeit der ausgewählten Kantenform zum gewünschten Ergebnis der Darstellung führt. Rahmen haben nur eine eigene Position, solange diese leer sind. Ein Rahmen bezieht sich in Position und Größe immer auf die darin enthaltenen Modellelemente (umschließen). Beim Verschieben eines Rahmens mit enthaltenen Elementen wird nicht der Rahmen, sondern die enthaltenen Modellelemente verschoben.

3.4.5 Die Größe von Modellelementen verändern

In manchen Diagrammen verfügen Modellelemente über Anfassmarken zur Änderung der Größe. Die manuelle Größenänderung von Modellelementen ist jedoch in vielen Diagrammtypen nicht erwünscht. In diesen Diagrammen stehen keine Anfassmarken zu Größenänderung zur Verfügung. Sollte in Ausnahmefällen eine manuelle Anpassung der Objektgröße gewünscht sein, kann dies für selektierte Objekte durch die Kombination von gehaltener Steuerungstaste und den Cursortasten bzw. die Tasten Plus, Minus und Mal des Numerikfeldes erfolgen.

3.4.6 Modellelemente verbinden

Knoten und Rahmen können über Kanten verbunden werden (Verbindungen). Verbindungen werden als Linien mit unterschiedlichen Linientypen und -formen sowie Symbolen (Anfang, Ende, Mitte) und diagrammspezifischen Beschriftungen dargestellt. Das Verbinden erfolgt in der Regel über den Verteiler (rotes Rechteck an der Unterkante) eines selektierten Objektes. Dabei wird per Drag und Drop vom Verteiler die Verbindung vom Quellelement zum Zielelement gezogen. Es ist nicht nötig exakt den Rand des Zielelementes zu treffen sondern besser, die Verbindung weit in das Zielobjekt hinein zu ziehen. Nach dem Loslassen der linken Maustaste wird die Verbindung erzeugt und die Randpunkte bis zu denen die Verbindung gezeichnet wird (Clipping) automatisch ermittelt. Sie können während des Drag und Drop durch Klick mit der rechten Maustaste bereits den zukünftigen Stützpunkt der Verbindung festlegen.

3.4.7 Modellelemente löschen

Zu löschende Modellelemente müssen zuerst selektiert werden. Die Löschaufforderung erfolgt mittels der Taste „Entfernen“, der Werkzeugleiste oder über das Hauptmenü Be- arbeiten/Objekt/Löschen bzw. das Kontextmenü. Der Löschvorgang selbst ist abhängig von der Art des zu löschenden Modellelementes. Zum Beispiel werden frei stehende Referenzen ohne Rückfrage gelöscht, Originale werden in zwei Stufen gelöscht. Dabei erfolgt zuerst das Entfernen aus dem Diagramm und dann auf Anfrage auch das Löschen aus der Datenbank. Objekte die verfeinert oder verknüpft sind lassen sich nicht ohne erhöhten Aufwand aus dem Modell entfernen. Zuerst müssen die Modellbeziehungen des Elementes aufgelöst werden bis es für den Löschvorgang isoliert ist. Dazu springt in entsprechenden Fällen der Löschassistent an. Dieser gibt dem Anwender die Möglichkeit zuerst die Auswirkungen auf das Gesamtmodell zu beurteilen und kann dann auf Anforderung komplexe Löschvorgänge, zum Beispiel von ganzen Teilmodellen in der Modellhierarchie, durchführen.

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Arbeiten mit SiSy, allgemein Seite: 19/152

3.4.8 Modellelemente kopieren

Um eine Kopie eines Modellelementes zu erzeugen wählen Sie im Menü oder in der Werkzeugleiste den Befehl „Kopieren“. Sie können dieses Objekt jetzt innerhalb des Projektes in ein Diagramm passenden Typs einfügen. Sollte das Diagramm den Objekttyp nicht akzeptieren, erhalten Sie dazu eine Meldung. Rahmenelemente wie zum Beispiel Klassen können mit deren Inhalt kopiert werden. Dabei werden jedoch Modellelemente in der Verfeinerung nach unten nicht berücksichtigt (flache Kopie). Innerhalb eines Diagramms können Sie von einzelnen Objekten durch Drag und Drop bei gleichzeitig gedrückter Steuerungstaste Kopien erzeugen.

Hinweis:

Beachten Sie, dass eine Kopie immer dem kopierten Element entspricht. Das heißt, die Kopie eines Originals ist wieder ein neues Original, die Kopie einer Referenz ist eine neue Referenz auf das ursprüngliche Original.

3.4.9 Modellelemente ausschneiden

Zum Ausschneiden eines Modellelements wählen Sie im Menü oder der Werkzeugleiste Bearbeiten/Objekt/Ausschneiden. Sie können dieses Objekt jetzt innerhalb des Projektes in ein Diagramm passenden Typs einfügen. Sollte das Diagramm den Objekttyp nicht akzeptieren, erhalten Sie dazu eine Meldung. Rahmenelemente wie zum Beispiel Klassen können mit deren Inhalt verschoben werden. Dabei werden auch ModellElemente in der Verfeinerung nach unten berücksichtigt.

Hinweis:

Beachten Sie, dass dieser Vorgang starke Auswirkungen auf die Modellstruktur hat. Vergewissern Sie sich über den Objektreport über die möglichen Auswirkungen.

3.4.10 Diagramme kopieren (flache Kopie)

Sie können Kopien von gesamten Diagrammen anlegen und einfügen. Dabei unterscheidet man zwischen einer flachen Kopie bei der alle Elemente der gezeigten Ebene (Diagramm) kopiert werden und einer tiefen Kopie bei der alle Elemente dieser Ebene und der darunter liegenden Ebenen (Teilhierarchie) kopiert werden. Eine flache Kopie erzeugen Sie über die Menübefehle Bearbeiten/Diagramm/Diagrammkopie anlegen

(flache Kopie) und Bearbeiten/Diagramm/Diagrammkopie einfügen (flache Kopie). Hinweis:

Beachten Sie, dass das Einfügen der Diagrammkopie nur in einem Diagramm des gleichen Typs und innerhalb des gleichen Projektes möglich ist.

3.4.11 Modelle kopieren (tiefe Kopie)

Sie können Kopien von gesamten Teilmodellen anlegen und einfügen. Dabei unterscheidet man zwischen einer flachen Kopie bei der alle Elemente der gezeigten Ebene (Diagramm) kopiert werden und einer tiefen Kopie bei der alle Elemente dieser Ebene und der darunter liegenden Ebenen (Teilhierarchie) kopiert werden. Eine tiefe Kopie erzeugen Sie über die Menübefehle Bearbeiten/Diagramm/Diagrammkopie anlegen

(tiefe Kopie) und Bearbeiten/Diagramm/Diagrammkopie einfügen (tiefe Kopie). Hinweis:

Beachten Sie, dass eine tiefe Kopie dem Wesen nach ein Export und Import von Teilmodellen darstellt. Das Einfügen eines solchen Imports in ein anderes Projekt kann zu Modellkonflikten führen.

Seite: 20/152 Arbeiten mit SiSy, allgemein

3.4.12 Die Modellhierarchie bearbeiten (Jo-Jo)

Die Modellhierarchie kann durch Einfügen neuer Ebenen oder Auflösen von ModellEbenen verändert werden (Jo-Jo). Diese Funktion erreichen Sie am besten über das Haupt- oder Kontextmenü. Um eine gewünschte Anzahl von Modellelementen zu einer neuen Ebene zusammenzufassen, selektieren Sie diese und wählen im Menü Bearbeiten/Objekt/Jo-Jo/Objekte zusammenfassen. Es wird ein neues Objekt erzeugt und in das Diagramm eingefügt. Die ausgewählten Objekte wurden dem neuen Objekt untergeordnet. Bei der Funktion Jo-Jo/Objekt auflösen werden die untergeordneten Objekte in das aktuelle Diagramm eingefügt und das ausgewählte Objekt gelöscht.

3.5 Die Ansicht verändern

3.5.1 Fensterinhalt verschieben

Modelle werden oft viel größer als der sichtbare Bereich des Diagrammfensters. Um den sichtbaren Teil eines Diagramms zu verändern (Scroll) haben Sie folgende Möglichkeiten:

- die Scrollleisten des Fensters benutzen

- den Diagrammhintergrund per Drag und Drop schieben

- wenn kein Modellelement ausgewählt ist, mit den Cursortasten scrollen

- Menüpunkt Ansicht/Fenstermitte um zum Diagrammursprung zurück zu kehren

Hinweis: Beachten Sie, dass der Diagrammursprung nicht wie bei einer Textverarbeitung oben links des Arbeitsbereiches liegt sondern wie bei einer MindMap oder vielen Konstruktionsprogrammen (CAD) in der Mitte (Nullpunkt, Fenstermitte) und das Modell sich somit in alle Richtungen entwickeln lässt. Vergleichen Sie dazu die Position der Scrollbalken. Versuchen Sie auf keinen Fall zu Beginn der Arbeit die Scrollposition oben links herzustellen!

3.5.2 Fensterinhalt vergrößern oder verkleinern

Um einen Überblick über größere Diagramme zu gewinnen, können Sie die Darstellung vergrößern oder verkleinern (Zoom). Eine elegante Möglichkeit das aktuelle Diagramm zu zoomen ist das Scrollrad der Maus. Sie können aber auch über das Kontextmenü oder den Menüpunkt Ansicht feste Zoom-Faktoren einstellen. Die Funktion Ansicht/Zoom/Alles aus dem Menü oder der Werkzeugleiste passt das Diagramm an die Fenstergröße an. Eine weitere Möglichkeit das Diagramm zu zoomen, erhalten Sie über die Tasten des Numerikfeldes:

- Numerikfeld + ... Ansicht vergrößern

- Numerikfeld

3.5.3 Fensterinhalt farbig oder als Kontur darstellen

Temporär kann die farbige Darstellung von Elementen unterbunden werden. Dazu können Sie über das Kontextmenü oder das Menü Ansicht/Darstellung/Konturen zwischen farbiger oder Konturdarstellung umschalten.

3.5.4 Die Schriftart ändern

Die in Diagrammen verwendete Schriftart lässt sich über die Werkzeugleiste oder den Menüpunkt Einstellungen/Schriftart… verändern. Dabei sollte die Schriftgröße 10 bis 12 eingehalten werden.

- ... Ansicht verkleinern * ... Ansicht alles (einpassen)

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Arbeiten mit SiSy, allgemein Seite: 21/152

3.6 Druckfunktionen in SiSy

Sie haben in SiSy verschieden Möglichkeiten Projektinhalte wie Grafiken, Übersichten, Quellcodes oder ganze Projektdokumentationen zu drucken. Dabei ist zu berücksichtigen, dass in SiSy bestimmte Informationen wie zum Beispiel die Darstellung eines Programmablaufplanes sichtbare Elemente eines Diagramms sind und andere Teile wie zum Beispiel der Quellcode eines Elementes nur über Dialoge oder bei Selektierung des Elementes sichtbar sind. Je nachdem, welchen Inhalt Sie dokumentieren wollen, richtet sich die Auswahl der betreffenden Druckfunktion.

3.6.1 Diagramme drucken

Wenn Sie ein einzelnes Diagramm, also den sichtbaren Inhalt eines Diagrammfensters drucken wollen, gehen Sie wie folgt vor:

• ggf. Projekt öffnen

• das gewünschte Diagramm öffnen

• die Menüfolge Bearbeiten/Diagramm/Drucken… wählen oder das Druckersymbol in

der Werkzeugleiste aktivieren

• Sie erhalten den Dialog zum Einrichten der Druckseite, wählen Sie die gewünschten Optionen aus!

Seite: 22/152 Arbeiten mit SiSy, allgemein

Feld für das

seite und

gramm kann manuell oder immer automatisch

angepasst werden.

men

Für bestimmte Drucktypen kann

Eingerahmtes InfoDiagramm.

Erweiterung des InfoFeldes um eine Legende für die Marker im Diagramm. Marker sind Symbole an den Diagrammelementen zum Bearbeitungsstand.

Das Größenverhältnis zwischen Druck Dia

• Zum Drucken wählen Sie die Schaltfläche „OK“. Der Ausdruck erfolgt auf dem Standarddrucker des Systems

• Im Hintergrund ist die Druckvorschau zu sehen. Der Druckvorgang kann hier abgebrochen werden, um die Einstellungen zu überarbeiten. Dabei kann die relative Position und das Größenverhältnis der Druckseite zum Diagramm verändert werden. Der Dialog zum Verändern der Einstellungen lässt sich per Doppelklick auf den Selektierungsmarken der Druckseite öffnen.

• Die Druckseitenansicht lässt sich über die Menüfolge Ansicht/Druckseite ein- und ausblenden

• Der Druckvorgang kann über das Druckersymbol in der Werkzeugleiste jederzeit gestartet werden

Sichtbarer Rah um das Diagramm

Papierformat

Große Diagramme können auf mehrere

Blätter verteilt werden

die Füllfarbe der Objekte abgeschaltet werden

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Arbeiten mit SiSy, allgemein Seite: 23/152

Grafik

code

3.6.2 Grafiken und Inhalte drucken (QuickDok)

Viele Projektinformationen sind kein sichtbarer Teil von erstellten Diagrammen. Diese wurden über Dialoge und Masken eingegeben und stehen als Attribute in der Projektdatenbank zur Verfügung. Um diese Informationen auszudrucken, stellt SiSy für jeden Diagrammtyp eine Reportfunktion zur Verfügung, mit der die wesentlichen Informationen, Inhalte und Attribute des Diagramms und der Objekte in einem Diagramm, als Word-Dokument generiert werden.

Für das Generieren des Word-Dokumentes muss auf dem PC MS Word installiert sein. Die Dokumentengenerierung basiert auf Makros; unterstützt wird Version Word 2007. Vorgehensweise in Word:

• Wählen Sie die Schaltfläche „Office“

• Menüfolge: Word-Optionen / Vertrauensstellungscenter / Einstellungen für das Ver-

trauensstellungscenter / Einstellungen für Makros

• Aktivieren Sie unter „Einstellungen für Makros“ den Auswahlpunkt „Alle Makros aktivieren“

• Setzen Sie im Unterpunkt „Entwicklermakroeinstellungen“ den Haken bei „Zugriff auf das VBA-Projektobjektmodell vertrauen“

Hinweis

: Für die Nutzung anderer Word-Versionen finden Sie Hinweise in unseren FAQs (www.sisy.de  SiSy-Wiki  weiteres FAQ  DokGen)

Die Reportfunktion zum Generieren des Word-Dokumentes aktivieren Sie über das Symbol „QuickDok“ in der Werkzeugleiste.

• Symbol

(QuickDok) in der

Werkzeugleiste wählen

• Aus der Liste der angebotenen

Reportfunktionen auswählen

• Dateinamen für den Report

vergeben

• Makros aktivieren

Diagramminformation

Generierter Quell aus den Elementen

Seite: 24/152 Arbeiten mit SiSy, allgemein

3.6.3 Nur Quellcodes drucken

Für das Ausdrucken von Quellcodes bietet SiSy einen speziellen QuellcodeDruckassistenten. Damit ist es möglich Quellcodes formatiert, in Syntaxfarben und mit Zeilennummern auszudrucken.

• kleines Programm, Quellcode drucken

o kleines Programm selektieren o rechte Maustaste „Definieren…“ o Dialogseite „Quellcode“ o Schaltfläche „>>öffnen“

• Programmablaufplan, Quellcode drucken

o PAP öffnen o Aktionsmenü aktivieren o „Quellcodedatei öffnen/drucken“

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Arbeiten mit SiSy, allgemein Seite: 25/152

3.6.4 Nutzen der Zwischenablage

Oft ist es erforderlich in Projektdokumentationen die Diagramme als Bilder einzufügen. In SiSy werden die Diagramme nicht als Bilder gespeichert sondern zur Laufzeit aus den Modellinformationen generiert. Um die Bilder der Diagramme weiter zu verwenden, steht dem Anwender die Funktion „Bild in Zwischenablage“ zur Verfügung. Dabei erstellt SiSy eine skalierbare Vektorgrafik (WMF) und legt diese in die Zwischenablage (Copy). Die Grafik kann nun von anderen Anwendungen über den Befehl „Einfügen“ (Paste) beliebig weiter verwendet werden.

• gewünschtes Diagramm öffnen

• Menüfolge Bearbeiten/Diagramm/Bild in Zwischenablage wählen

• Zielanwendung, zum Beispiel Word öffnen

• Menüfolge Start/Einfügen oder Start/Einfügen/Inhalte einfügen wählen

• Gegebenenfalls einzufügendes Grafikformat wählen

Seite: 26/152 Arbeiten mit SiSy, allgemein

3.7 SiSy Add-Ons verwalten

3.7.1 Einführung

Das Modellierungswerkzeug SiSy besteht aus seinen Kernkomponenten:

- Anwendungssystem SiSy mit

o Rahmenanwendung o Assistent o Diagrammfenster

- Laufzeitbibliotheken

o Datenbanktreiber (Repository) o Grafikbibliotheken o Metamodell-Engine o SiSy BASIC Interpreter

- Allgemeine Hilfe (dieses Benutzerhandbuch) … und installierten Add-Ons. Add-Ons enthalten zusätzliche Komponenten, SiSy-BASIC-Skripte, erweiterte Hilfen und spezielle Informationen für die Modellierung (Metamodell). Dabei können Add-Ons wiederum aus Add-Ons thematisch zusammengestellt werden. Diese zusätzlichen Bausteine werden während der Laufzeit vor allem durch die Metamodell-Engine verarbeitet. Dadurch können beliebige Modellierungsaufgaben durch SiSy verarbeitet werden. Es ist nur das entsprechende Add-On erforderlich. Für die aktuelle Version von SiSy sind zum Beispiel folgende Add-On Zusammenstellungen verfügbar:

- AVR: Programmierung von AVR Mikrocontrollern

o einfache Programmierung mit dem Zeileneditor in Assembler und C o grafische Programmierung mit dem Programmablaufplan in Assembler, dem

Struktogramm in C, dem UML-Klassendiagramm in C++ und dem UML-State chart in C++

o Codegenerierung mit dem myAVR Code-Wizard für Assembler und C o myAVR Werkzeuge für Test und Kommunikation mit AVR Controllern

- ARM: Programmierung von ARM Mikrocontrollern

o einfache Programmierung mit dem Zeileneditor in C o grafische Programmierung mit dem Struktogramm in C, dem UML-Klassen-

diagramm in C++ und dem UML-Statechart in C++

o Integrierter Debugger für ARM Mikrocontroller

- SPRG: einfache Programmierung für Konsolen- und GUI-Anwendungen

o Integrierte Programmiersprachen C/C++, JAVA, C#, PASCAL, Assembler

Integrierter Debugger

- UML: objektorientierte Systementwicklung für Konsolen- und GUI-Anwendungen

o Typische UML-Diagramme z.B.: Klassendiagramm, Anwendungsfalldiagramm,

Aktivitätsdiagramm, Zustandsdiagramm, Sequenzdiagramm, u.a.

o Codegenerierung für C++, C#, JAVA o Integrierter Debugger mit Modellnachführung im Schrittbetrieb

- SVL: Smart Visual Library

o Einfache bausteinartige Entwicklung von Windows-Anwendungen (RAD Rapid

Application Development) im UML Klassendiagramm

- SysML: System Modeling Language

o Fachübergreifende Systementwicklung mit dem OMG Sprachstandard

- SA/SD: Strukturierte Techniken zur Systementwicklung

o Round Trip Engineering mit den klassischen Analyse und Entwurfswerkzeugen

bis zur Codegenerierung, Strukturierte Analyse, Entity Relationship Diagramm mit SQL-Generierung und Struktogramme mit Codegenerierung

- DOKGEN: Dokumentengenerierung

Generieren von Dokumentationen direkt aus den Modellen heraus

- GPM / QM: Geschäftsprozessmodellierung und Qualitätsmanagement

o Modellierung von integrierten Managementsystemen

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Arbeiten mit SiSy, allgemein Seite: 27/152

Aus den verfügbaren Add-Ons werden entsprechend der unterschiedlichen Einsatzgebiete des Modellierungswerkzeuges SiSy spezielle Ausgaben zusammengestellt. Die jeweiligen Ausgaben können jederzeit durch weitere Add-Ons ergänzt werden. Es sind unter anderem folgende SiSy-Ausgaben verfügbar (Stand Februar 2013):

Ausgabe (Auswahl)

SiSy Professional

umfasst alle verfügbaren Add-Ons

SiSy Business

umfasst Add-Ons für Prozessmodellierung, Qualitäts- und Projektmanagement

SiSy Developer

umfasst umfangreiche Add-Ons zur Systementwicklung

SiSy Microcontroller ++

umfasst die Add-Ons AVR, ARM, ausgewählte Teile der UML, SVL und SysML

- SiSy AVR

beinhaltet nur das Add-On AVR

SiSy ARM

umfasst die Add-Ons ARM, ausgewählte Teile der UML und SysML

3.7.2 Add-Ons anzeigen

Für die Anzeige der installierten Add-Ons nutzen Sie den Menüpunkt Einstellungen/ Add-On hinzufügen.

Liste der installierten Add-Ons

Hinweis: Beachten Sie, Änderungen an den Add-Ons haben in jedem Fall Auswirkungen auf die Funktionalität von SiSy und abhängiger Add-Ons.

Seite: 28/152 Arbeiten mit SiSy, allgemein

On auswählen

3.7.3 Add-Ons hinzufügen

Für das Hinzufügen von Add-Ons nutzen Sie den Menüpunkt Einstellungen/Add-On hinzufügen. Wählen Sie im Add-On Dialog die Schaltfläche „Hinzufügen“. SiSy Add-Ons

besitzen die Dateierweiterung *.exp.

Addund installieren

Installation bestätigen

Hinweis: Für die Installation von Add-Ons sollten Sie Administratorrechte besitzen. Beachten Sie, dass Änderungen an den Add-Ons in jedem Fall Auswirkungen auf die Funktionalität von SiSy und abhängiger Add-Ons haben.

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Arbeiten mit SiSy, allgemein Seite: 29/152

3.8 LibStore

LibStore ist eine online-Sammlung von Vorlagen, Mustern, Beispielen und Bibliotheken. Diese werden Ihnen bei der Arbeit mit SiSy angeboten, sobald bei der Modellierung im jeweiligen Diagramm LibStore verfügbar ist und Sie online sind. Die Nutzung der im SiSy-LibStore zur Verfügung gestellten Inhalte ist, wenn durch den Autor nicht anderweitig geregelt, an die Lizenzbedingungen Ihrer SiSy-Version gebunden.

3.8.1 Handhabung: ein Projekt mit LibStore anlegen

Nach dem Start von SiSy legen Sie ein neues Projekt an und wählen ein Vorgehensmodell aus. Es öffnet bereits LibStore und bietet, soweit für dieses VGM vorhanden, eine Auswahl von Vorlagen an.

LibStore aus AVR-Vorgehensmodell LibStore aus ARM-Vorgehensmodell

Aktivieren Sie Ihre gewünschte Vorlage und aktivieren Sie im nächsten Fenster die Schaltfläche „Download“. Die ausgewählte Vorlage wird in ein leeres Diagramm geladen; sie steht Ihnen uneingeschränkt zur weiteren Arbeit zur Verfügung.

3.8.2 Handhabung: LibStore in einem Projekt nutzen

Aus der Objektbibliothek ziehen Sie ein neues Objekt vom Typ „LibStore“ in das geöffnete Diagramm. In Abhängigkeit von den verfügbaren Add-Ons in Ihrer SiSy-Ausgabe und dem Diagrammtyp werden Ihnen von LibStore Vorlagen, Beispiele, usw. angeboten. Zur Einschränkung können Sie in der Suchzeile Begriffe eingeben, wie z.B. Controllernamen, dann Ihre Auswahl treffen und den Download ausführen.

Seite: 30/152 Arbeiten mit SiSy, allgemein

3.9 Die Hilfefunktionen in SiSy

Nutzen Sie die zahlreichen Hilfen und Vorlagen, die SiSy dem Entwickler bietet!

3.9.1 Der Assistent

Der Assistent ist hilfreich bei der Unterstützung und Führung des Nutzers im Umgang mit SiSy. Er befindet sich standardmäßig im linken, unteren Bildschirmbereich. Der Assistent kann über die Werkzeugleiste ( -Symbol) geöffnet werden, falls dies nicht beim Programmstart erfolgte. Der Assistent begleitet Sie im gesamten Projekt. Sie erhalten immer passende Informationen zum aktuellen Diagrammtyp und haben die Möglichkeit, durch verschiedene Links weitere Hilfethemen aufzurufen oder Vorlagen in Ihr Projekt zu laden.

Beachte: Der Assistent ist auf die jeweilige Ausgabe von SiSy, die verfügbaren Add-Ons und das gewählte Modell bezogen.

Bedeutung der verwendeten Symboliken im Assistenten:



öffnet eine Hilfedatei (*.chm, *.hlp, *htm)



öffnet eine Animation oder Videomitschnitt der Bildschirmarbeit (AVI, ScreenCam- oder FLASH-Film)



so geöffnete Diagramm kann über die Schließen-Schaltfläche des Diagramms wieder geschlossen werden;

Beispiel 1





zurück zur Startseite des Assistenten





nächster Schritt (Arbeitsschritt)



Verweis auf den Standardassistenten dieser Sicht;

blaue Schrift und blaue Symbole sind mit Links hinterlegt und können per Mausklick aktiviert werden

Beispiele für Assistenten:

weitere Informationen anzeigen

Demovideo zur Handhabung zeigen

;

entsprechendes Diagramm öffnen, das

eine Diagrammvorlage laden; Vorschau zur Diagrammvorlage;

;

ein kleines Skript zu Arbeitsschritten anzeigen

;

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Arbeiten mit SiSy, allgemein Seite: 31/152

3.9.2 Die Online-Hilfe

Bei der Eingabe von Quellcode im dafür vorgesehenen Editorfenster werden reservierte Worte (Bezeichner, Schlüsselworte) der gewählten Programmiersprache durch verschiedenfarbiges Einfärben (Syntaxfarben) hervorgehoben. Zu den hervorgehobenen Bezeichnern existiert in der Regel auch eine kurze Online-Hilfe und eine ausführlichere Hilfe. Die Online-Hilfe ist ein Pop-Up-Fenster, welches automatisch eingeblendet wird, wenn Sie mit dem Mauszeiger auf einen Befehl zeigen. In dem Pop-Up ist eine kurze Hilfestellung zu dem Bezeichner eingeblendet. Steht eine Hilfe mit ausführlicheren Informationen zur Verfügung, wird diese in dem Pop-Up (STRG+Klick für Hilfe) angezeigt.

Schlüsselwort-Hilfe

Bei der Eingabe von bekannten Registernamen wird die Bezeichnung des Registers und dessen Adresse eingeblendet. Durch betätigen der Taste „STRG“ und gleichzeitigem Klick auf das Register öffnet eine Hilfedatei mit dem entsprechenden Hilfethema zu dem eingegeben Register.

Bit-Hilfe

Wenn für ein Register detaillierte Informationen zu der Bedeutung/Funktion der einzelnen Bits vorliegen, wird zusätzlich im Pop-Up eine Kurzreferenz der Bits angezeigt. Durch drücken der Taste „STRG“ sowie Klick auf das Register öffnet SiSy eine Hilfedatei mit dem entsprechenden ausführlichen Hilfethema.

Seite: 32/152 Arbeiten mit SiSy, allgemein

Befehlshilfe

Bei der Eingabe von Befehlen wird in der Regel die Bedeutung bzw. Funktion des Befehls und ein kurzes Syntaxbeispiel eingeblendet. Durch drücken der Taste „STRG“ sowie Klick auf den Befehl öffnet SiSy eine Hilfedatei mit dem entsprechenden ausführlichen Hilfethema.

3.9.3 Die allgemeine Hilfe

SiSy bietet neben der direkten Hilfe bei der Eingabe von Schlüsselworten auch eine allgemeine Hilfe an.

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Arbeiten mit SiSy, allgemein Seite: 33/152

3.9.4 SiSy Code Vervollständigung

Der Codegenerator ist eine integrierte Hilfe in SiSy. Vorteilhaft erweist sich diese Hilfe bei der Generierung des Quellcodes aus einem Programmablaufplan sowie bei der Arbeit mit Klassendiagrammen. Des Weiteren fungiert er als Assistent zum Erstellen von Assembler- und C-Codes für die Programmierung von Mikrocontrollern, was die fehlerhafte Codeeingabe minimiert.

Bei der Programmierung springt die Codevervollständigung nach der Eingabe von drei zusammenhängenden Buchstaben an. Aus der angezeigten Liste kann der gewünschte Befehl selektiert werden.

Bedingungen im Programmablaufplan haben spezielle Vorlagen. Diese sind so konstruiert, dass eine JA/NEIN Entscheidung erzeugt werden kann. Findet der Codegenerator das Schlüsselwort JA oder NEIN an einer der folgenden Verbindungen, setzt er diese in eine entsprechende Sprunganweisung um.

Im UML Klassendiagramm erzeugt der Codegenerator eine Instanz der Klasse und ruft die Main-Methode auf. Das Zustandsdiagramm mit Quellcodegenerierung erhalten Sie über ein spezielles Attribut im Klassendiagramm der UML. Dieses Zustandsattribut kann mit einem Zustandsdiagramm verfeinert werden. Dabei wird der Quellcode in spezielle Klassenmethoden generiert.

In den entsprechenden Kapiteln zur Programmierung, zum Programmablaufplan, zum Klassendiagramm und zum myAVR Code-Wizard wird explizit auf die CodeVervollständigung eingegangen.

Seite: 34/152 Entwicklung eines kleinen Programms

4 Entwicklung eines kleinen Programms

SiSy bietet die Möglichkeit, Programme in einem konventionellen Zeileneditor zu erstellen und zu übersetzen. Für den Einstieg bietet sich die einfache Programmierung an, ein „kleines Programm“.

4.1 Vorgehen für PC Programme

Hinweis: Dieses Beispiel ist erstellt mit der Ausgabe SiSy Microcontroller ++

Zielstellung

Die erste Aufgabe ist das berühmte „Hallo Welt“, programmiert in C, mit dem jeder Programmierer angefangen hat. Dieser Text soll auf dem Bildschirm ausgegeben werden.

Ein neues Projekt anlegen

Starten Sie SiSy und aktivieren Sie „Assistent öffnen“. Im SiSy-Assistent folgen Sie dem Link „Neues Projekt anlegen“ und vergeben den Projektnamen „Hallo_Welt“. Bestätigen Sie diesen Dialog mit „Projekt anlegen“. Wählen Sie das Vorgehensmodell „Programmierung“ und bestätigen Sie mit „OK“.

Hinweis: In SiSy legen Sie stets ein Projekt an. In dieses Projekt integrieren Sie Ihr Programm bzw. mehrere Programme. Unabhängig vom Programmnamen benötigt jedes Projekt einen Namen. Beachten Sie die Erläuterungen im Kapitel 3.1.2.

Das folgende Dialogfeld mit den Informationen zur Hardware-Konfiguration brechen Sie ab; danach bestätigen Sie die voreingestellte Auswahl „leeres Diagramm“.

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Entwicklung eines kleinen Programms Seite: 35/152

Ziehen Sie per Drag & Drop ein Objekt "kleines Programm" in das Diagrammfenster. Es öffnet ein Dialogfenster; oder klicken Sie mit der rechten Maustaste auf das Objekt und wählen im Kontextmenü „Definieren“. Vergeben Sie den Namen „Welt“ und wählen die Sprache „C/C++ Konsole (32 Bit)“ aus. Wechseln Sie zur Registerkarte „Programm gerüst“ und laden die Grundstruktur eines C-Programms (Struktur laden). Schließen Sie den Dialog mit „OK“.

Geben Sie im Quellcodefenster den folgenden Programmcode für „Hallo Welt“ ein:

printf ("Hallo Welt!");

Klicken Sie nacheinander auf „Kompilieren“, „Linken“, „Ausführen“ oder nur auf „>>>Ausführen“. Nun sollte sich ein DOS Fenster öffnen mit der Ausgabe "Hallo Welt". Ist dies nicht der Fall und Sie erhalten eine Fehlermeldung, prüfen Sie bitte die Schreibweise und beachten Sie den Syntaxfehler.

Seite: 36/152 Entwicklung eines kleinen Programms

4.2 Vorgehen für AVR Programme

Hinweis: Dieses Beispiel ist erstellt mit der Ausgabe SiSy AVR.

Zielstellung

In dem ersten AVR Beispielprogramm sollen die drei LED’s auf dem myAVR Board nacheinander aufleuchten und damit ein „Lauflicht“ erzeugen. Die Programmiersprache ist Assembler.

Aufgabe: Entwickeln Sie eine Mikrocontrollerlösung, bei der auf dem myAVR Board die 3 LEDs nacheinander aufleuchten.

Schaltung: Port D.2 = rote LED Port D.3 = grüne LED Port D.4 = gelbe LED

Ein neues Projekt anlegen

Starten Sie SiSy und wählen Sie „Assistent öffnen“. Aktivieren Sie im SiSy-Assistent den Menüpunkt „Neues Projekt anlegen“ und vergeben Sie den Projektnamen „Lauflicht“. Bestätigen Sie diesen Dialog mit „Projekt anlegen“. Wählen Sie das Vorgehensmodell „Programmierung“ und bestätigen Sie mit „OK“.

Es folgt ein Info-Fenster, welches Sie mit „Weiter“ bestätigen. Als nächstes wählen Sie Ihren Programmer und Ihren Controller aus; speichern Sie die Auswahl.

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Entwicklung eines kleinen Programms Seite: 37/152

Den folgenden Dialog mit der Info „Die Einstellungen wurden übernommen“ bestätigen Sie. Dann wählen Sie die verwendete Taktrate Ihres Mikrocontrollers aus; klicken Sie auf „Fertig stellen“.

Hinweis: Bei jedem neuen Projekt müssen die Grundeinstellungen zur verwendeten Zielplattform vorgenommen werden (Mikrocontrollertyp, Taktrate, Programmer und I/O-Port). Werden keine Einstellungen vorgenommen, so geht SiSy von einem mySmartUSB MK2 Programmer an COM 3 aus. Als Mikrocontroller wird ein Atmega8 mit 3,6864 MHz verwendet.

Im nächsten Fenster wählen Sie „leeres Diagramm“ aus. Beenden Sie das Fenster über „Weiter“ sowie „Fertig stellen“.

Kleines Assembler-Programm anlegen

Erstellen Sie ein Programm für den AVRMikrocontroller, indem Sie per Drag & Drop aus der Objektbibliothek ein Objekt „kleines Programm“ in das Diagramm fenster ziehen. Das Kontextmenü öffnet sich automatisch. Auf der Registerkarte „Definition“ tragen Sie den Programmnamen ein (im Beispiel „Lauflicht“) und wählen die Programmiersprache „AVR Assembler“ aus.

Hinweis

: Für spätere Bearbeitungen, markieren Sie das Objekt und wählen aus dem Kontextmenü (rechte Maustaste) „Definieren“.

Definition kleines Programm

Seite: 38/152 Entwicklung eines kleinen Programms

Zielplattform und Programmer einstellen

Kontrollieren Sie auf der Registerkarte „Extras (AVR)“ den ausgewählten Mikrocontroller. Die Option „Vorgaben benutzen“ überträgt automatisch die Grundeinstellungen (Mikrocontrollertyp, Taktrate, Programmer und I/O-Port) des Projektes in die lokalen Einstellungen. Sollen die lokalen Einstellungen unter „Extras (AVR)“ von den Projekteinstellungen abweichen, muss die Option „Vorgaben benutzen“ abgeschaltet werden.

Einstellungen Extras (AVR)

Programmgerüst laden, Quellcode erstellen

Über die Registerkarte „Programmgerüst“ können Sie das „Grundgerüst“ für ein AVR Assemblerprogramm laden; in der Registerkarte „Quellcode“ können Sie den Quellcode eigenständig eintragen.

Hinweis: Den Quellcode können Sie auch im Beschreibungsfenster/Editorfenster der SiSy-Benutzeroberfläche eintragen bzw. korrigieren.

Laden Sie die Vorlage für das Programmgerüst oder erstellen Sie den folgenden Quellcode. Vergleichen Sie dazu auch den Abschnitt zum myAVR Code-Wizard (Abschnitt

10.4). Das Programmgerüst darf erst geladen werden, wenn der Zielcontroller ausgewählt wurde; die Vorlagen sind controllerspezifisch.

Grundgerüst laden

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Entwicklung eines kleinen Programms Seite: 39/152

;+----------------------------------------------------------------------------;| Title : Assembler Grundgerüst für ATmega8 ;+----------------------------------------------------------------------------;| Prozessor : ATmega8 ;| Takt : 3,6864 MHz ;| Sprache : Assembler ;+-----------------------------------------------------------------------------

.include "AVR.H"

;-----------------------------------------------------------------------------begin:

reti ; TWI 2-wire Serial Interface

;-----------------------------------------------------------------------------main: ldi r16,hi8(RAMEND) ; Main program start

;Hier Init-Code eintragen. ;-----------------------------------------------------------------------------mainloop: ;Hier den Quellcode eintragen.

rjmp main ; Power-on Reset reti ; INT0 External Interrupt Request 0 reti ; INT1 External Interrupt Request 1 reti ; TIMER2 COMP Timer/Counter2 Compare Match reti ; TIMER2 OVF Timer/Counter2 Overflow reti ; TIMER1 CAPT Timer/Counter1 Capture Event reti ; TIMER1 COMPA Timer/Counter1 Compare Match A reti ; TIMER1 COMPB Timer/Counter1 Compare Match B reti ; TIMER1 OVF Timer/Counter1 Overflow reti ; TIMER0 OVF Timer/Counter0 Overflow reti ; SPI, STC Serial Transfer Complete reti ; USART, RXC USART, Rx Complete reti ; USART, UDRE USART Data Register Empty reti ; USART, TXC USART, Tx Complete reti ; ADC ADC Conversion Complete reti ; EE_RDY EEPROM Ready reti ; ANA_COMP Analog Comparator

reti ; SPM_RDY Store Program Memory Ready

out SPH,r16 ; Set Stack Pointer to top of RAM ldi r16,lo8(RAMEND) out SPL,r16

wdr

rjmp mainloop

Quellcode in Assembler erstellen

Das Lauflicht soll über die LEDs angezeigt und von dem Prozessorport D gesteuert werden. Die Realisierung erfolgt über je ein Bit im Register R18. Dieses wird mit dem Befehl Bit-Rotation nach rechts verschoben und an PORT D des Prozessors ausgegeben. Auf Grund der Prozessorgeschwindigkeit muss die Ausgabe des Lauflichtes für unser Auge verzögert werden. Geben Sie folgenden Quellcode ein bzw. ergänzen Sie die Programmvorlage!

Seite: 40/152 Entwicklung eines kleinen Programms

;-------------------------------------------------------------------------------;* Titel :Lauflicht für myAVR Board ;* Prozessor :ATmega8 mit 3,6864 MHz ;* Schaltung :PORT D.2 bis PORT D.4 an LED 1 bis 3 ;* Datum :31.01.2011 ;* Autor :Dipl. Ing. Päd. Alexander Huwaldt ;--------------------------------------------------------------------------------

.include "avr.h"

;--------------------------------------------------------------------------------

; Reset and Interruptvectoren ; VNr. Beschreibung

begin: rjmp main ; 1 POWER ON RESET

reti ; 16 EEPROM Ready

;-------------------------------------------------------------------------------; Start, Power ON, Reset

main: ldi r16 , lo8(RAMEND)

ldi r16 , hi8(RAMEND)

ldi r18 , 0b00000001 ; 1 Lauflicht-Bit

;--------------------------------------------------------------------------------

mainloop: wdr

skip: rjmp mainloop

;--------------------------------------------------------------------------------

up1: rol r18 ; Bit-Rotation out PORTD , r18 ret

;--------------------------------------------------------------------------------

reti ; 2 Int0-Interrupt reti ; 3 Int1-Interrupt reti ; 4 TC2 Compare Match reti ; 5 TC2 Overflow reti ; 6 TC1 Capture reti ; 7 TC1 Compare Match A reti ; 8 TC1 Compare Match B reti ; 9 TC1 Overflow reti ; 10 TC0 Overflow reti ; 11 SPI, STC Serial Transfer Complete reti ; 12 UART Rx Complete reti ; 13 UART Data Register Empty reti ; 14 UART Tx complete reti ; 15 ADC Conversion Complete

reti ; 17 Analog Comparator reti ; 18 TWI (I²C) Serial Interface reti ; 19 Store Program Memory Redy

out SPL , r16 ; Init Stackpointer LO

out SPH , r16 ; Init Stackpointer HI ldi r16 , 0b11111111 ; PORT D auf Ausgang out DDRD , r16 ldi r16 , 0b00000000 ; Alle Bits auf LOW out PORTD , r16 ldi r17 , 0b00000000

inc r16 ; Wait brne skip inc r17 ; Wait brne skip rcall up1 ; Lauflicht

Kompilieren und Linken

Der eingegebene Quellcode muss nun in Maschinencode für den AVR-Prozessor übersetzt werden. Wählen Sie dazu die Schaltflächen „Kompilieren“ und „Linken“. Bei fehlerfreier Übersetzung liegt das Programm als „Lauflicht.hex“ vor und kann auf den FLASHProgrammspeicher des Prozessors gebrannt werden.

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Entwicklung eines kleinen Programms Seite: 41/152

Hardware anschließen und brennen

Das myAVR Board verfügt über eine ISP (In System Programming) Schnittstelle. Der Prozessor muss also nicht für die Programmierung aus dem System entfernt werden, um ihn in einem gesonderten Programmiergerät zu brennen, sondern kann in dem myAVR Board direkt programmiert werden. Dazu verbinden Sie das myAVR Board über das Programmierkabel mit dem USB-Port Ihres Rechners.

Zum Brennen wählen Sie die Schaltfläche „Brennen“. Bei erfolgreichem Brennvorgang erhalten Sie im Ausgabefenster vom myAVR ProgTool folgende Meldung:

Ausgabefenster myAVR ProgTool

Seite: 42/152 Entwicklung eines kleinen Programms

Mikrocontrollerlösung testen

Für den Test des Programms ist es nötig, den Port D mit den LEDs zu verbinden.

• Wenn vorhanden, ziehen Sie die Batterie bzw. das Netzteil und das Programmierkabel ab.

• Verbinden Sie die LEDs mit dem Prozessorport D entsprechend der Abbildung. Nutzen Sie die Patchkabel!

• Prüfen Sie die Verbindungen und schließen Sie die Batterie/das Netzteil oder das Programmierkabel wieder an und nehmen die Mikrocontrollerlösung in Betrieb.

• Es ist jetzt an den LEDs ein Lauflicht zu sehen.

• Gratulation!

Das ist Ihre erste Mikrocontrollerlösung mit dem myAVR Board.

Beim Kompilieren, Linken und Brennen des Schnellstart-Beispiels öffnet sich ein Ausgabefenster und zeigt Protokollausgaben der Aktionen an. Beim Brennen öffnet sich zusätzlich das myAVR ProgTool. Wenn die Hardware ordnungsgemäß angeschlossen, von der Software erkannt und das Programm erfolgreich auf den Programmspeicher des Mikrocontrollers übertragen wurde, schließen Sie das myAVR ProgTool. Die letzte Ausschrift hat folgenden Inhalt:

brenne Daten neu

Ende.

Ausgabefenster mit "Brenn-Protokoll“

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Entwicklung eines kleinen Programms Seite: 43/152

4.3 Vorgehen für ARM Produkte

Hinweis: Dieses Beispiel ist erstellt mit der Ausgabe SiSy ARM.

Zielstellung

In dem ersten C-Programm sollen zwei LEDs auf dem STM32F4-Discovery in kurzen Zeitabständen aufleuchten und damit ein „Blinklicht“ erzeugen.

Ein neues Projekt anlegen

Starten Sie SiSy und wählen Sie „Assistent öffnen“. Aktivieren Sie im SiSy-Assistent den Menüpunkt „Neues Projekt anlegen“ und vergeben Sie den Projektnamen „Hallo_ARM“. Bestätigen Sie diesen Dialog mit „Projekt anlegen“. Wählen Sie das Vorgehensmodell „Programmierung“ und bestätigen Sie mit „OK“. Es öffnet das Diagrammfenster für die weitere Bearbeitung.

Kleines C-Programm anlegen

Erstellen Sie ein Programm für den ARMMikrocontroller, indem Sie per Drag & Drop aus der Objektbibliothek ein Objekt „kleines Programm“ in das Diagrammfenster ziehen. Das Kontextmenü öffnet sich automatisch. Auf der Registerkarte „Definition“ tragen Sie den Programmnamen ein (hier „Blinklicht“) und wählen die Sprache „ARM C++“.

Hinweis

: Für spätere Bearbeitungen, markieren Sie das Objekt und wählen aus dem Kontextmenü (rechte Maustaste) „Definieren“.

Seite: 44/152 Entwicklung eines kleinen Programms

Über die Registerkarte „Extras (ARM)“ treffen Sie die Hardware-Auswahl und aktivieren die Schaltfläche „Vorgabe laden“. In unserem Beispiel ist die Hardware „STM32F4-Discovery“.

Programmgerüst laden, Quellcode erstellen

Über die Registerkarte „Programmgerüst“ können Sie das folgende Grundgerüst für ein ARM Programm laden; in der Registerkarte „Quellcode“ können Sie den Quellcode eigenständig eintragen.

Hinweis: Den Quellcode können Sie im Beschreibungsfenster/Editorfenster der SiSy-Benutzeroberfläche eintragen bzw. korrigieren.

Laden Sie die Vorlage („Struktur laden“) für das Programmgerüst oder erstellen Sie den folgenden Quellcode.

#include <stddef.h> #include <stdlib.h> #include "stm32f4xx.h"

void initApplication()

{ SysTick_Config(SystemCoreClock/100);

// weitere Initialisierungen durchführen

}

int main(void)

{ SystemInit(); initApplication();

do{ // Eingabe // Ausgabe // Verarbeitung } while (true); return 0;

}

extern "C" void SysTickFunction(void)

{

// Application SysTick

}

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Entwicklung eines kleinen Programms Seite: 45/152

Quellcode in C erstellen

Das Blinklicht soll über die LEDs angezeigt und von dem Prozessorport GPIOD gesteuert werden. Die Realisierung erfolgt über GPIO Pin 12 und 13. Dieses wird mit dem Befehl Bit-Rotation nach rechts verschoben und an den Port GPIOD des Prozessors ausgegeben. Auf Grund der Prozessorgeschwindigkeit muss die Ausgabe des Blinklichtes für unser Auge verzögert werden. Geben Sie folgenden Quellcode ein bzw. ergänzen Sie die Programmvorlage!

Bei der Eingabe des Quellcodes springt nach drei zusammenhängenden Buchstaben die Codevervollständigung an und listet alle Bezeichner fortlaufend gefiltert. Wählen Sie jetzt die Cursor-Taste mit Pfeil nach unten, Sie können in der Liste rollen und per Enter einen Eintrag auswählen.

#include <stddef.h> #include <stdlib.h> #include "stm32f4xx.h"

void initApplication()

{ SysTick_Config(SystemCoreClock/100);

// weitere Initialisierungen durchführen /* GPIOG Periph clock enable */

RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

/* Configure PG6 and PG8 in output pushpull mode */

GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_Init(GPIOD, &GPIO_InitStructure); }

void delay(vu32 nCount)

{

while(nCount--);

}

int main(void)

{ SystemInit(); initApplication(); GPIO_SetBits(GPIOD,GPIO_Pin_13);

do{ // Eingabe // Ausgabe // Verarbeitung

GPIO_ToggleBits(GPIOD,GPIO_Pin_13|GPIO_Pin_12); delay(10000000); } while (true);

return 0;

}

extern "C" void SysTickFunction(void)

{

// Application SysTick

}

Seite: 46/152 Entwicklung eines kleinen Programms

Kompilieren und Linken

Der eingegebene Quellcode muss nun in Maschinencode für den ARM-Prozessor übersetzt werden. Wählen Sie dazu die Schaltflächen „Kompilieren“ und „Linken“. Bei fehlerfreier Übersetzung liegt das Programm als „Blinklicht.hex“ vor und kann auf den FLASH-Programmspeicher des Prozessors gebrannt werden.

Nur kompilie-

ren *.cc Datei

wird erstellt

Nur linken

*.hex Datei

wird erstellt

*.hex Datei

wird über-

tragen

Alle Schritte durchführen

Hardware anschließen und brennen

Das STM32F4-Discovery verfügt über eine ISP (In System Programming) Schnittstelle. Der Prozessor muss also nicht für die Programmierung aus dem System entfernt werden, um ihn in einem gesonderten Programmiergerät zu brennen, sondern kann im STM32F4 direkt programmiert werden. Dazu verbinden Sie das STM32F4-Discovery über das Programmierkabel mit dem USB-Port Ihres Rechners.

Zum Brennen wählen Sie die Schaltfläche „Brennen“. Beim Kompilieren, Linken und Brennen des Beispiels öffnet sich ein Ausgabefenster und zeigt Protokollausgaben der Aktionen an. Beim Brennen öffnet sich zusätzlich das ST-Link.

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Entwicklung eines kleinen Programms Seite: 47/152

Bei erfolgreichem Brennvorgang erhalten Sie im Ausgabefenster folgende Meldung:

Mikrocontrollerlösung testen

Für den Programmtest ist es nötig, dass das STM32F4-Discovery mit dem PC verbunden ist.

• Es ist an den LEDs ein Blinklicht zu sehen.

• Gratulation!

Das ist Ihre erste Mikrocontrollerlösung mit dem STM32F4-Discovery.

Die Datenkommunikation mit der Mikrocontrollerlösung erfolgt über das ControlCenter. Vergleichen Sie dazu den Abschnitt 10.2 zum ControlCenter.

Seite: 48/152 Entwicklung eines großen Programms

5 Entwicklung eines großen Programms

5.1 Einleitung

Für die Entwicklung eines größeren Programms ist es unzweckmäßig, alle Befehle in eine Datei (Unit) zu schreiben. Der Grund dafür ist, dass bei mehr als 60 bis 80 Zeilen Quellcode die Übersicht über die Programmstruktur verloren geht. Selbst die Unterteilung in Unterprogramme reicht ab einer bestimmten Größe von Programmen nicht mehr aus. SiSy erlaubt zwar in kleinen Programmen bzw. je Unit 10 Kilobyte Code. Das sind in Assembler zum Beispiel über 1000 Zeilen. Ein kleines Programm bzw. eine einzelne Unit sollte jedoch nie mehr als 80 bis 120 Zeilen haben. Wird diese Grenze erreicht, sollte das Programm in logische Einheiten (Units, Module) gegliedert werden. Dabei fasst man alles zusammen, was zu einer bestimmten Funktionalität oder einer bestimmten Baugruppe wie zum Beispiel dem AD-Wandler gehört. Physisch entstehen dabei mehrere Dateien, die für sich genommen wieder übersichtlich sind, da diese dann nur 80 bis 120 Zeilen Code enthalten. Das Übersetzungsprogramm (Assembler, Compiler, Linker) sorgt dann dafür, dass alle einzelnen Units zu einem vollständigen Programm zusammengefügt werden. Die folgenden Kapitel erläutern jeweils an einem sehr kleinen Beispiel die Handhabung der Komponenten eines großen Programms, welches in mehrere Units zerlegt wird.

5.2 Vorgehen für PC Programme

Hinweis: Dieses Beispiel ist erstellt mit der Ausgabe SiSy Microcontroller ++.

5.2.1 Zielstellung

Im folgenden Beispiel wird ein Programm mit mehreren Modulen veranschaulicht. In einer einfachen Anwendung wird vom Hauptprogramm ein Unterprogramm aufgerufen und ins Hauptprogramm zurückgekehrt. Auf dem Bildschirm werden die Texte dieser Aktionen ausgegeben.

5.2.2 Hauptprogramm erstellen

Starten Sie SiSy und legen Sie ein neues Projekt an. Vergeben Sie den Namen „Hallo„ und wählen Sie das Vorgehensmodell „Programmierung“. Das folgende Dialogfeld mit den Infos zur Hardware-Konfiguration brechen Sie ab; danach bestätigen Sie die voreingestellte Auswahl „leeres Diagramm“.

Für ein Programm mit mehreren Modulen ziehen Sie per Drag & Drop das Symbol für „Programm“ in das Diagrammfenster. Es öffnet ein Dialogfenster. Geben Sie für das Beispiel den Namen „Hallo“ ein und wählen Sie die Sprache „C/C++ Konsole“; schließen Sie mit „OK“.

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Entwicklung eines großen Programms Seite: 49/152

Klicken Sie mit der rechten Maustaste auf das Symbol und wählen im Kontextmenü „Nach unten“. Hier ziehen Sie zwei Units in das Diagramm und nennen diese „Main“ und „UP1“. In dem Dialogfenster zur Definition von „UP1“ setzen Sie einen Haken in den beiden Zeilen

- „Headerdef-Datei erzeugen, Datei mit Deklaration wird generiert“

- „Funktionsdef-Datei erzeugen (.cpp)“

5.2.3 Units (Unterprogramme) anlegen und verknüpfen

Übernehmen Sie nun folgende Quelltexte in die jeweiligen Units. In der Unit „Main“ fügen Sie folgenden Quelltext ein:

#include <stdio.h> #include <conio.h> #include "UP1.h" int main() { //Hier Quelltext eingeben! printf("Hallo Main"); up1(); printf("und wieder zurueck!"); getch(); return 0; }

In "UP1" fügen Sie den folgenden Quelltext ein:

#include <stdio.h> #include <conio.h> #include "UP1.h" int up1() { //Hier Quelltext eingeben! printf("\n -> Hallo UP1\n"); return 0; }

Danach wählen Sie in „UP1“ die Schaltfläche „*.h“ und tragen die Bibliotheken stdio und conio, sowie die Definition von „UP1“ ein:

#include <stdio.h> #include <conio.h> int up1();

Seite: 50/152 Entwicklung eines großen Programms

Zum Ausführen des Programms klicken Sie auf das Aktionsmenü in der Objektbibliothek. Es stehen verschiedene Möglichkeiten zur Auswahl. Nach „>>> Erstellen und Ausführen“ erscheint folgende Ausgabe auf dem Bildschirm.

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Entwicklung eines großen Programms Seite: 51/152

5.3 Vorgehen für AVR Programme

Hinweis: Dieses Beispiel ist erstellt mit der Ausgabe SiSy AVR.

5.3.1 Zielstellung

Es ist eine Mikrocontroller-Anwendung mit der Technik des großen Programms zu entwerfen und in der Sprache Assembler zu realisieren. Das Programm ist in mehrere Units zu teilen.

Aufgabe Entwickeln Sie eine Mikrocontrollerlösung, bei der ein Taster eine LED schaltet.

Schaltung: Port D.2 = Taster 1 Port B.0 = LED

5.3.2 Neues Projekt anlegen

Starten Sie SiSy und legen Sie ein neues Projekt an. Wählen Sie das Vorgehensmodell „Programmierung“. Nehmen Sie die Grundeinstellungen für die verwendete myAVR-Hardware vor oder lassen Sie die myAVR-Hardware automatisch suchen. Erstellen Sie ein leeres Diagramm!

Ziehen Sie aus der Objektbibliothek ein Objekt vom Typ „Programm“.

Legen Sie einen Namen für das Programm fest und die Sprache „AVR Assembler“. Überprüfen Sie gegebenenfalls die Einstellungen unter „Extras AVR“.

Seite: 52/152 Entwicklung eines großen Programms

5.3.3 Hauptprogramm erstellen

Öffnen Sie das Diagrammfenster für ein großes Programm, indem Sie mit der rechten Maustaste auf das Symbol klicken und aus dem Kontextmenü „Nach unten (öffnen)“ wählen. Legen Sie eine Unit an. Diese Unit bildet das Hauptprogramm. Nennen Sie die Unit „main“. Damit wird durch die Entwicklungsumgebung erkannt, dass es sich hierbei um das Hauptmodul handelt. Erstellen Sie hier das Hauptprogramm, nutzen Sie die angebotene Vorlage „Grundgerüst“ und aktivieren Sie „Struktur laden“. Der unten stehende Quellcode wird damit übernommen.

;------------------------------------

.include "AVR.H"

;-----------------------------------; Reset and Interrupt vectoren

begin: rjmp main reti reti reti reti

;...

main: ldi r16, lo8(RAMEND) out SPL, r16 ldi r16, hi8(RAMEND) out SPH, r16 ; Hier Init-Code eintragen.

;-----------------------------------

mainloop: wdr ; Hier Quellcode eintragen. rjmp mainloop

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Entwicklung eines großen Programms Seite: 53/152

5.3.4 Units (Unterprogramme) anlegen und verknüpfen

Zur Gliederung des großen Programms wird dieses in mehrere kleine Einheiten (Units bzw. Module) zerlegt. Diese Einheiten werden nach fachlichen/inhaltlichen Gesichtspunkten gebildet. So kann man alle Initialisierungsaufgaben in der Unit „init“ zusammenfassen. Eine Unit kann aus einer Funktion/Unterprogramm oder mehreren Funktionen/Unterprogrammen bestehen. Im einfachsten Fall enthält jede Unit ein Unterprogramm. Legen Sie zusätzlich zur Hauptunit „main“ die Unit „init“ an.

Die Hauptunit benutzt die Unit „init“. Daher ist eine Verbindung von der Hauptunit „main“ zur Unit „init“ zu ziehen. Selektieren Sie die Unit „main“ und ziehen vom Verteiler (rot) eine Verbindung auf die Unit „init“. Dabei wird in der Hauptunit „main“ ein IncludeEintrag für die Unit „init“ erzeugt:

.include "init.s"

Erstellen Sie die Initialisierungsroutine für die benötigten digitalen Ein und Ausgänge in der Unit „init“:

;----------------------------------------

init: push r16 sbi DDRB,0 ; B.0 Ausgang cbi PORTB,0 ; B.0 LED aus cbi DDRD,2 ; D.2 Eingang sbi PORTD,2 ; D.2 PullUp pop r16 ret

;----------------------------------------

Ergänzen Sie den Code des Hauptprogramms:

…

rcall init ;-----------------------------------

mainloop: sbic PIND,2 rjmp led_aus led_an: sbi PORTB,0 rjmp mainloop led_aus: cbi PORTB,0 rjmp mainloop

;-----------------------------------

.include “init.s“

Seite: 54/152 Entwicklung eines großen Programms

Die Unit „main“ enthält damit nachfolgenden Quellcode:

;+---------------------------------------------------------------;| Title : Assembler Grundgerüst für ATmega8 ;+---------------------------------------------------------------;| Funktion : ... ;| Schaltung : ... ;+---------------------------------------------------------------;| Prozessor : ATmega8 ;| Takt : 3,6864 MHz ;| Sprache : Assembler ;| Datum : ... ;| Version : ... ;| Autor : ... ;+------------------------------------------------------------------

.include "AVR.H"

;--------------------------------------------------------------------

begin: rjmp main ; RESET External Pin, Power-on Reset,

; Brown-out Reset and Watchdog Reset

reti ; INT0 External Interrupt Request 0 reti ; INT1 External Interrupt Request 1 reti ; TIMER2 COMP Timer/Counter2 Compare Match reti ; TIMER2 OVF Timer/Counter2 Overflow reti ; TIMER1 CAPT Timer/Counter1 Capture Event reti ; TIMER1 COMPA Timer/Counter1 Compare Match A reti ; TIMER1 COMPB Timer/Counter1 Compare Match B reti ; TIMER1 OVF Timer/Counter1 Overflow reti ; TIMER0 OVF Timer/Counter0 Overflow reti ; SPI, STC Serial Transfer Complete reti ; USART, RXC USART, Rx Complete reti ; USART, UDRE USART Data Register Empty reti ; USART, TXC USART, Tx Complete reti ; ADC ADC Conversion Complete reti ; EE_RDY EEPROM Ready reti ; ANA_COMP Analog Comparator reti ; TWI 2-wire Serial Interface reti ; SPM_RDY Store Program Memory Ready

;---------------------------------------------------------------------------

main: ldi r16,hi8(RAMEND) ; Main program start out SPH,r16 ; Set Stack Pointer to top of RAM ldi r16,lo8(RAMEND) out SPL,r16 rcall init ; Hier Init-Code eingetragen.

;----------------------------------------------------------------------------

mainloop: sbic PIND,2 ; Hier Quellcode eingetragen rjmp led_aus led_an: sbi PORTB,0 rjmp mainloop led_aus: cbi PORTB,0 rjmp mainloop

;--------------------------------------------------------------------------

.include "init.s" ; Eintrag bei Verbindung von "main" auf "init"

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Entwicklung eines großen Programms Seite: 55/152

Kompiliere die Datei main.s.

Übersetzen, Brennen und Test

Zum Übersetzen, Brennen und Testen wählen Sie im Aktionsmenü

den entsprechenden Menüpunkt. Im Ausgabefenster erscheint das Protokoll der ausgeführten Aktionen. Des Weiteren öffnet sich für kurze Zeit das myAVR ProgTool.

Linke die Datei grossesProgramm.elf.

brenne Daten neu

Öffne myAVR ControlCenter

Ende.

Zum Test des Programms stecken Sie auf dem Board die Verbindungen entsprechende der Vorgabe, nutzen Sie die Patchkabel. Die Datenkommunikation mit dem Board kann über das ControlCenter erfolgen. Weitere Informationen dazu im Absatz 10.2, (ControlCenter).

Seite: 56/152 Entwicklung eines großen Programms

5.3.5 Interrupt-Service-Routine (ISR) im großen Programm

Interrupt-Service-Routinen (im weiteren ISR) sind besondere Formen von Unterprogrammen. Diese werden von einer Interruptquelle des Mikrocontrollers (Timer, ADC, UART, usw.) bei entsprechenden Ereignissen automatisch an beliebiger Stelle im Programmfluss aufgerufen (Unterbrechung, engl. Interrupt). Es ist nötig, die Interruptquelle entsprechend zu konfigurieren. Es empfiehlt sich für jedes interruptfähige Gerät eine eigene Unit anzulegen. Diese ist mit der Hauptunit zu verbinden.

;------------------------------------------ ; Interruptvectoren

... rjmp onADC ;15 ADC Conversion Complete ...

;------------------------------------------ initADC: ldi r16,0

out ADMUX,r16 ldi r25,0b10011101 out ADCSRA,r25

ret ;------------------------------------------- onADC: reti

;-------------------------------------------

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Entwicklung eines großen Programms Seite: 57/152

5.4 Vorgehen für ARM Programme

Hinweis: Dieses Beispiel ist erstellt mit der Ausgabe SiSy ARM.

5.4.1 Zielstellung

Das Beispiel aus Kapitel 4.3 soll jetzt mit der Technik des großen Programms (Zerlegen in mehrere Units) erstellt werden, ebenfalls in der Programmiersprache C.

Aufgabe Entwickeln Sie eine Mikrocontrollerlösung, bei der ein Blinklicht erzeugt wird.

Schaltung: GPIOD.13 = LED GPIOD.12 = LED

5.4.2 Neues Projekt anlegen

Starten Sie SiSy und legen Sie ein neues Projekt an. Wählen Sie das Vorgehensmodell „Programmierung“ aus. Ziehen Sie aus der Objektbibliothek ein Objekt vom Typ „Programm“. Vergeben Sie für das Programm einen Namen und legen Sie die Sprache „ARM C++“ fest.

Über die Registerkarte „Extras (ARM)“ treffen Sie die Hardware-Auswahl und aktivieren die Schaltfläche „Vorgabe laden“. In unserem Beispiel ist die Hardware „STM32F4-Discovery“.

Seite: 58/152 Entwicklung eines großen Programms

5.4.3 Hauptprogramm erstellen

Öffnen Sie das Diagrammfenster für ein großes Programm (rechte Maustaste -> „Nach unten“). Legen Sie eine Unit „main“ an. Diese Unit bildet das Hauptprogramm. Damit wird durch die Entwicklungsumgebung erkannt, dass es sich hierbei um das Hauptmodul handelt. Erstellen Sie hier das Hauptprogramm, nutzen Sie die angebotene Vorlage „Grundgerüst“ und aktivieren Sie „Struktur laden“.

//---------------------------------------------------------------------// Titel : Grundgerüst einer einfachen ARM C Anwendung in SiSy //---------------------------------------------------------------------// Funktion : ... // Schaltung : ... //---------------------------------------------------------------------// Hardware : STM32F4 Discovery // Takt : 168 MHz // Sprache : ARM C // Datum : ... // Version : ... // Autor : ... //----------------------------------------------------------------------

#include <stddef.h> #include <stdlib.h> #include "stm32f4xx.h"

//#include "stm32f30x.h" //#include "stm32f0xx.h"

void initApplication()

{ SysTick_Config(SystemCoreClock/100); // weitere Initialisierungen durchführen }

int main(void)

{ SystemInit(); initApplication(); do{ // Eingabe // Ausgabe // Verarbeitung } while (true); return 0; }

extern "C" void SysTickFunction(void)

{ // Application SysTick }

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Entwicklung eines großen Programms Seite: 59/152

5.4.4 Units (Unterprogramme) anlegen und verknüpfen

Zur Gliederung des großen Programms wird dieses in mehrere kleine Einheiten (Units/ Module) zerlegt. Diese Einheiten werden nach fachlichen/inhaltlichen Gesichtspunkten gebildet. So kann man alle Initialisierungsaufgaben in der Unit „init“ zusammenfassen. Eine Unit kann aus einer Funktion/Unterprogramm oder mehreren Funktionen/Unter programmen bestehen. Im einfachsten Fall enthält jede Unit ein Unterprogramm. Legen Sie zusätzlich zur Hauptunit „main“ die Unit „init“ an.

Die Hauptunit benutzt die Unit „init“. Daher ist eine Verbindung von „main“ zur „init“ zu ziehen. Selektieren Sie „main“ und ziehen vom Verteiler (rot) eine Verbindung auf „init“.

Dabei wird in der Hauptunit „main“ ein Include-Eintrag für die Unit „init“ erzeugt. Prüfen Sie diese Eintragung; ggf. ergänzen Sie diese. Erstellen Sie die Initialisierungsroutine für die benötigten digitalen Ein- und Ausgänge in der Unit „init“. Nutzen Sie bei der Quellcode-Eingabe die Codevervollständigung, wie bereits im Kapitel 4.3 („Vorgehen für ARM Produkte“ – kleines Programm) beschrieben.

#include "init.h"

void initApplication()

{

SysTick_Config(SystemCoreClock/100); // weitere Initialisierungen durchführen /* GPIOG Periph clock enable */ RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE); /* Configure PG6 and PG8 in output pushpull mode */

Seite: 60/152 Entwicklung eines großen Programms

Ergänzen Sie die Unit „sysTick“ und die Unit „delay“. Tragen Sie in diese folgenden Quellcode ein.

In die Unit „sysTick“:

//----------------------------------------

#include "sysTick.h"

extern "C" void SysTickFunction(void) {

// Application SysTick GPIO_ToggleBits(GPIOD,GPIO_Pin_13);

}

//------------------------------

In die Unit „delay“:

//------------------------------

#include "delay.h"

void delay(vu32 nCount)

{

while(nCount) {

nCount--; } }

//------------------------------

Diese beiden Units sind noch mit der Hauptunit „main“ zu verbinden. Prüfen Sie in der „main“ die includeEintäge zu diesen Units; ggf. tragen Sie diese manuell ein.

Die Methoden void initApplication() und void SysTickFunction(void) sind jetzt in den Units hinterlegt und müssen demzufolge in der Hauptunit entfernt werden. Ergänzen Sie noch in dem Code des Hauptprogramms:

#include "main.h"

int main(void)

{

SystemInit();

initApplication(); GPIO_SetBits(GPIOD,GPIO_Pin_12);

do{ // Eingabe // Ausgabe // Verarbeitung

GPIO_ToggleBits(GPIOD,GPIO_Pin_12); delay(10000000);

} while (true); return 0;

}

Benutzerhandbuch SiSy © Laser & Co. Solutions GmbH

Entwicklung eines großen Programms Seite: 61/152

Damit hat das Programm nachfolgenden Quellcode:

Unit „main“

//-----------------------------------------------------------------// Titel : Grundgerüst einer einfachen ARM C Anwendung in SiSy //-----------------------------------------------------------------// Funktion : ... // Schaltung : ... //-----------------------------------------------------------------// Hardware : STM32F4 Discovery // Takt : 168 MHz // Sprache : ARM C // Datum : ... // Version : ... // Autor : ... //------------------------------------------------------------------

#include <stddef.h> #include <stdlib.h> #include "stm32f4xx.h"

//#include "stm32f30x.h" //#include "stm32f0xx.h"

#include "init.h" #include "delay.h" #include "sysTick.h" #include "main.h"

int main(void)

{ SystemInit(); initApplication(); GPIO_SetBits(GPIOD,GPIO_Pin_12); do{ // Eingabe // Ausgabe // Verarbeitung GPIO_ToggleBits(GPIOD,GPIO_Pin_12); delay(10000000); } while (true); return 0; }

Unit init.cc

#include "init.h"

void initApplication()

{ SysTick_Config(SystemCoreClock/100); // weitere Initialisierungen durchführen /* GPIOG Periph clock enable */ RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE); /* Configure PG6 and PG8 in output pushpull mode */ GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_Init(GPIOD, &GPIO_InitStructure); }

Seite: 62/152 Entwicklung eines großen Programms

Unit init.h

#include <stddef.h> #include "stm32f4xx.h"

void initApplication();

Unit delay.cc

#include "delay.h"

void delay(vu32 nCount)

{ while(nCount) { nCount--; } }

Unit delay.h

#include <stddef.h> #include "stm32f4xx.h"

void delay(vu32);

Unit sysTick.cc

#include "sysTick.h"

extern "C" void SysTickFunction(void)

{ // Application SysTick GPIO_ToggleBits(GPIOD,GPIO_Pin_13); }

Unit sysTick.h

#include <stddef.h> #include "stm32f4xx.h"

extern "C" void SysTickFunction();

5.4.5 Übersetzen, Brennen und Test

Zum Übersetzen, Brennen und Testen wählen Sie im Aktionsmenü

den entsprechenden Menüpunkt. Im Ausgabefenster erscheint das Protokoll der ausgeführten Aktionen. Des Weiteren öffnet die SiSy-Konsole.

Entwicklung eines großen Programms Seite: 63/152

Über das ControlCenter kann die Datenkommunikation mit dem STM32F4-Discovery erfolgen. Überprüfen Sie gegebenenfalls die Einstellungen entsprechend Absatz 10.2, „Das ControlCenter“.

5.4.6 Interrupt-Service-Routine (ISR) im großen Programm

Interrupt-Service-Routinen (im weiteren ISR) sind besondere Formen von Unterprogrammen. Diese werden von einer Interruptquelle des Mikrocontrollers (Timer, ADC, UART, usw.) bei entsprechenden Ereignissen automatisch an beliebiger Stelle im Programmfluss aufgerufen (Unterbrechung, engl. Interrupt). Es ist nötig die Interruptquelle entsprechend zu konfigurieren. Es empfiehlt sich für jedes interruptfähige Gerät eine eigene Unit anzulegen. Diese ist mit der HauptUnit zu verbinden.

…

SysTick_Config(SystemCoreClock/100);

…

//------------------------------------

#include

extern {

// Application SysTick

GPIO_ToggleBits(GPIOD,GPIO_Pin_13|GPIO_Pin_1); }

"sysTick.h"

"C"

void SysTickFunction(void)

Hinweis

: Die Parameter zum Aufruf der Interrupt-Routinen sind controllerabhängig. Sie sind dem jeweiligen Referenzblatt des Controllers zu entnehmen.

Seite: 64/152 Entwicklung Programmablaufplan für AVR Programme

6 Entwicklung Programmablaufplan für AVR Programme

Hinweis: Dieses Beispiel kann mit der Ausgabe SiSy Microcontroller ++ und SiSy AVR erstellt werden.

6.1 Einleitung

Für die Entwicklung eines Programmablaufplans (PAP) sind konkrete Vorstellungen über die Systemlösung und Kenntnis der Hardware nötig. Ein Programmablaufplan kann aus einer genauen Aufgabenstellung abgeleitet werden. In dieser Beispielanwendung wird die Aufgabenstellung in einem Programmablaufplan modelliert und aus diesem PAP der Quellcode in Assembler generiert. Das aus dem Quellcode erzeugte Programm kann sofort auf den Controller gebrannt werden.

6.2 Einfache Programmentwicklung aus einem PAP

6.2.1 Zielstellung

Es ist im ersten Schritt eine einfache MikrocontrollerAnwendung mit der Technik des Programmablaufplanes zu entwerfen und in der Sprache Assembler zu realisieren.

Aufgabe

: Entwickeln Sie eine Mikrocontrollerlösung, bei der ein Taster eine LED schaltet.

Schaltung

: Port B.0 = Taster 1 Port B.1 = LED

PAP zur Beispielaufgabe

6.2.2 Vorbereitung

Starten Sie SiSy und legen Sie ein neues Projekt an. Wählen Sie das AVRVorgehensmodell. Nehmen Sie die Grundeinstellungen für die verwendete AVR Hardware vor oder lassen Sie die myAVR-Hardware automatisch suchen.

START

Init PortB

Mainloop

Taste ?

LED ON

Mainloopende

Nein

LED OFF

Entwicklung Programmablaufplan für AVR Programme Seite: 65/152

Danach öffnet die typische Benutzeroberfläche von SiSy mit einem leeren Vorgehensmodell und Sie können mit der Arbeit beginnen. Ziehen Sie als nächstes aus der Objektbibliothek ein Objekt vom Typ „PAP“ in das leere Diagramm. Benennen Sie den PAP mit „Aufgabe1“. Beachten Sie die Einstellungen zum Controllertyp und Programmieradapter unter „Extras (AVR)“; vgl. Abbildung.

Anlegen des Objektes „PAP“ und Einstellungen

Der nächste Schritt ist das Aufstellen des Programmablaufplanes. Dazu muss das Diagramm unter dem Symbol geöffnet werden. Wählen Sie rechte Maustaste „Nach unten (öffnen)“, um in dieses Diagramm zu gelangen.

PAP öffnen

Seite: 66/152 Entwicklung Programmablaufplan für AVR Programme

6.2.3 Grundstruktur laden

Wenn ein Diagramm leer ist, bietet SiSy typische Vorlagen zum Importieren an. Diese können dann weiterbearbeitet werden. Wählen Sie die Diagrammvorlage „Grundgerüst Mainprogramm …“. Die Abbildung „Grundgerüst PAP“ zeigt den PAP zu diesem Grundgerüst.

Diagrammvorlagen

Grundgerüst PAP

6.2.4 Logik entwerfen

Für die Abbildung der Programmlogik im PAP muss die Vorlage um die fehlenden Elemente ergänzt werden. Des Weiteren sind die Elemente durch gerichtete Verbindungen (Kanten) in der Reihenfolge ihrer Abarbeitung zu verbinden. Ein Objekt wird im Diagramm ergänzt, indem der entsprechende Objekttyp in der Objektbibliothek mit der Maus ausgewählt und per Drag & Drop an die entsprechende Position im Diagramm gezogen wird. Verbindungen zwischen den Objekten können über den rot markierten Verteiler von selektierten Objekten hergestellt werden. Dazu ist das Ausgangsobjekt zu selektieren und mit dem Mauscursor von dem roten Verteiler bei gedrückter linker Maustaste eine Verbindung zum Zielobjekt zu ziehen. Für die Benennung der Objekte öffnen Sie den Definieren-Dialog aus dem Kontextmenü.

Objekte in das Diagramm einfügen und verbinden

Entwicklung Programmablaufplan für AVR Programme Seite: 67/152

Zeichnen Sie den nebenstehenden Programmablaufplan (vgl. Abbildung „Logikentwurf im PAP“):

6.2.5 Befehle eingeben

Nachfolgend soll aus dem Programmablaufplan Assemblerquellcode generiert werden. Dazu ist es nötig, die einzelnen Elemente des PAP mit den entsprechenden Assembleranweisungen zu versehen. Dafür gibt es mehrere Möglichkeiten. Zum einen bietet SiSy beim ersten Öffnen eines jeden Elementes typische Code-Vorlagen an, die über die Schaltfläche „Laden“ dem Element zugewiesen werden können. Wird der Definieren-Dialog mit „OK“ beendet, so wird die Auswahl im Objekt gespeichert und beim nächsten Aufruf des Dialoges „Definieren“ erscheinen die Code-Vorlagen nicht mehr; das Element kann ganz normal bearbeitet werden. In den beiden folgenden Abbildungen sind beide Varianten des Dialoges „Definieren“ zu sehen.

Codevorlage PAP

Definition PAP-Element

Seite: 68/152 Entwicklung Programmablaufplan für AVR Programme

Die zweite Möglichkeit besteht beim Selektieren von Elementen über den Quellcodeeditor oberhalb des Diagrammfensters, vgl. Abbildung „Quellcodefenster im PAP“ und Abbildung „Quellcodeeingabe PAP“.

Quellcodefenster im PAP

Quellcodeeingabe PAP

Geben Sie die gezeigten Quellcodes in die Objekte ein!

Bedingungen haben spezielle Vorlagen, die eine Codegenerierung bei übersichtlichem Programmablaufplan vereinfachen. Jede Bedingungsvorlage ist so konstruiert, dass eine JA/NEIN Entscheidung erzeugt werden kann. Findet der Codegenerator das Schlüsselwort JA an einer der folgenden Verbindungen, setzt er diese in eine Sprunganweisung breq um. Das Schlüsselwort

NEIN wird in brne umgewandelt. Alternativ können statt dieser Schlüsselworte auch der Sprungbefehl selber an eine der Kanten geschrieben werden (breq, brne, brge, brlo, usw.)

Codevorlage Bedingung

Quellcode einer Bedingung

Entwicklung Programmablaufplan für AVR Programme Seite: 69/152

Auch das Element „IN/OUT“ verfügt über spezifische Vorlagen. Diese sind gegebenenfalls mit zu ergänzen. Dazu sind spitze Klammern als Platzhalter in den Vorlagen eingefügt.

Vorlagen für IN/OUT

Ergänzen Sie den Quellcode der gezeigten Elemente!

6.2.6 Übersetzen, Brennen und Test

Sind alle betreffenden Elemente mit Quellcode hinterlegt, kann aus dem Programmablaufplan der komplette Quellcode generiert, kompiliert, gelinkt und auf den Mikrocontroller übertragen werden. Die gewünschte Funktion kann aus dem Aktionsmenü ausgewählt werden.

Hinweis: Beachten Sie, dass für das Brennen des Controllers das Programmierkabel angeschlossen sein muss und bei Bedarf eine geeignete Spannungsquelle anzuschließen ist.

Seite: 70/152 Entwicklung Programmablaufplan für AVR Programme

Auswahl aus Aktionsmenü

Funktionalitäten des Aktionsmenüs Benennung Funktion

Alles Ausführen Quellcode generieren, kompilieren, linken, brennen Nur Quelltext erstellen Quellcode generieren mit allen Marken Kompilieren Quellcode zu Objektdatei übersetzen Linken Objektdatei zu ELF-Datei binden Brennen ELF-Datei an den Controller übertragen Testen ControlCenter öffnen Quelltextdatei öffnen Quellcodedatei öffnen Quelltext bereinigen Quellcode von überflüssigen Marken bereinigen

Im Ausgabefenster werden die jeweiligen Aktionen angezeigt. Bei Compilerfehlern werden diese ebenfalls im Ausgabefenster mit der entsprechenden Zeilennummer angezeigt. Um zu dem Fehler zu gelangen, genügt meist ein Klick auf die Fehlermeldung. Das betreffende Objekt wird selektiert und die Zeile hervorgehoben.

Ausgabefenster

Entwicklung Programmablaufplan für AVR Programme Seite: 71/152

Fehlerbehandlung

Nachdem das Programm erfolgreich übersetzt und auf den Controller übertragen wurde, kann die Anwendung getestet werden. Stecken Sie auf dem Board die vorgegebenen Verbindungen, nutzen Sie die Patchkabel.

Seite: 72/152 Entwicklung Programmablaufplan für AVR Programme

6.3 Unterprogrammtechnik im PAP

Unterprogramme sind ein wichtiges Gestaltungsmittel für übersichtliche Mikrocontrollerprogramme. Sie werden für in sich abgeschlossene Aufgaben (Verarbeitungsschritte) benutzt, die auch mehrfach im Gesamtprogramm genutzt werden können.

6.3.1 Anlegen eines Unterprogramms

Ziehen Sie den Objekttyp „Unterprogramm“ aus der Objektbibliothek in das gewünschte Diagramm. Mit Doppelklick oder über rechte Maustaste -> Kontextmenü -> Definieren auf dem Element können Sie dem Unterprogramm einen Namen geben.

Damit ist ein Objekt angelegt, welches im aktuellen Diagramm als Aufruf (call) des Unterprogramms zu verstehen ist. Die Funktionalität des Unterprogramms wird in einem gesonderten Programmablaufplan für das Unterprogramm entworfen. Dazu ist das Diagramm „unter“ bzw. „hinter“ dem Objekt Unterprogramm zu öffnen. Um das zum Unterprogramm zugehörige Diagramm zu öffnen, wählen Sie auf dem Objekt rechte Maustaste -> Kontextmenü -> Nach unten (öffnen).

Sie erhalten eine Vorlagenliste für die Grundstruktur von Unterprogrammen. Bitte laden Sie die Vorlage „Grundgerüst Unterprogramm“. Auf dem Objekt „START“ können Sie eine benutzerdefinierte Sprungmarke festlegen (Rechtsklick -> Definieren), die durch den Codegenerator erstellt und verwendet werden soll. Die Vorlage muss entsprechend der vorgesehen Logik abgeändert werden.

Entwicklung Programmablaufplan für AVR Programme Seite: 73/152

push

r16

pop

r19

START

sichern

push r17

...

herstellen

push r18 push r19

pop r18 pop r17

RET

pop r16

6.3.2 Ein Unterprogramm aufrufen

Das Unterprogrammsymbol muss zum Aufruf an der entsprechenden Position im Programmablaufplan eingefügt werden. Der Codegenerator erzeugt dann entsprechend einen Unterprogrammaufruf und den Code für das Unterprogramm selbst. Dazu ist in das Diagramm zurückzukehren, in dem das Objekt „Unterprogramm“ angelegt wurde (zum Beispiel rechte Maustaste -> Kontextmenü-> nach oben…). Das Unterprogramm ist korrekt eingebunden, wenn es vollständig und eindeutig im Programmfluss integriert ist (mindestens ein eingehender Pfeil und genau ein ausgehender Pfeil).

UP aufrufen

Seite: 74/152 Entwicklung Programmablaufplan für AVR Programme

6.3.3 Unterprogramme mehrmals benutzen

Ein wesentliches Merkmal von Unterprogrammen ist, dass diese von verschiedenen Stellen im Programm aufgerufen (call) werden können und auch dorthin zurückkehren (return). Um diese Möglichkeit zu nutzen, bietet SiSy das Anlegen von Referenzen. Vergleichen Sie dazu Absatz 3.2. Um ein Unterprogramm zu referenzieren (wiederholend zeigen und einbinden) gehen Sie wie folgt vor:

1. zeigen Sie im Navigator das gewünschte Unterprogramm an a. über den Schnellzugriff,

dort lässt sich das Original per Drag & Drop ablegen, oder

b. über die Navigatorsortierung „Unterprogramme“

Navigator -> rechte Maustaste -> Kontextmenü -> Programmablaufpläne

2. Öffen Sie das gewünschte Zieldiagramm, in dem das Unterprogramm verwendet

werden soll

3. ziehen Sie per Drag und Drop das Unterprogramm in das Zieldiagramm, dabei

wird nur eine Referenz (Link) auf das Original angelegt.

4. Integrieren Sie Referenz wie oben beschrieben in den Programmfluss

Unterprogramme im Navigator anzeigen

Unterprogramm referenzieren

UP aufrufen

Entwicklung Programmablaufplan für AVR Programme Seite: 75/152

push

r16

pop

r16

6.4 Interrupt-Service-Routinen (ISR) im PAP

Interrupt-Service-Routinen (im weiteren ISR) sind besondere Formen von Unterprogrammen. Diese werden von einer Interruptquelle des Mikrocontrollers (Timer, ADC, UART, usw.) bei entsprechenden Ereignissen automatisch an beliebiger Stelle im Programmfluss aufgerufen (Unterbrechung, engl. Interrupt). Es ist demzufolge nicht vorgesehen, eine ISR in den Programmfluss zu integrieren. Um eine ISR zu erzeugen, ziehen Sie ein Objekt vom Typ INT-Routine aus der Objektbibliothek in das Diagramm des Hauptprogramms und definieren einen Namen.

Rechts klick, Definieren

Über rechte Maustaste -> Kontextmenü -> Definieren … legen Sie die Sprungmarke und den Typ des Interrupts fest. Damit erfolgt durch den Codegenerator die Zuordnung der ISR zum entsprechenden Interruptvektor. Beachten Sie, dass die Liste der Interrupts abhängig vom gewählten Controllertyp ist.

Zum Entwerfen der ISR-Logik wählen Sie auf dem Objekt rechte Maustaste -> Kontextmenü -> nach unten … Ihnen wird das Grundgerüst einer ISR als Diagrammvorlage angeboten. Laden Sie die Diagrammvorlage. Vervollständigen Sie danach die ISR-Logik. Die ISR wird nicht in den Programmfluss integriert.

START

push r17 push r18 push r19 in r16,SREG

disable INT

...

herstellen

enable INT

RETI

push r16

out SREG,r16 pop pop pop

r19 r18 r17

pop r16

Seite: 76/152 Entwicklung Programmablaufplan für AVR Programme

6.5 Daten im PAP

Konstante Daten, die im Programmspeicher (FLASH) des Mikrocontrollers abgelegt werden, können als Datenobjekt deklariert werden. Die im Datenobjekt deklarierten Daten werden durch den Codegenerator immer ans Ende des Quellcodes gestellt. Die zu generierende Marke/Marken für die Datenelemente können vom Entwickler frei gewählt werden.

6.5.1 Anlegen eines Datenobjektes

Zum Anlegen eines Datenobjektes ziehen Sie das betreffende Objekt per Drag & Drop aus der Objektbibliothek in das gewünschte Diagramm. Per Doppelklick können Sie einen Namen vergeben (Beachte: Menüfolge Einstellungen/Menü bei Doppelklick).

Die Marke und die Daten selbst können über rechte Maustaste -> Kontextmenü -> Definieren… festgelegt werden.

6.5.2 Datenobjekt benutzen

Im Quellcode werden die Daten über die vergegebenen Markennamen angesprochen.

Programmentwicklung aus einem Struktogramm Seite: 77/152

7 Programmentwicklung aus einem Struktogramm

7.1 Einleitung

Struktogramme (SG) oder auch Nassi-Shneiderman-Diagramme sind ein Entwurfsmittel der strukturierten Programmierung. Strukturiert meint in dem Fall, dass zur Realisierung eines Algorithmus auf das Verwenden von Sprunganweisungen (Goto, Jump) verzichtet wird. Für das Formulieren eines Algorithmus stehen dem Entwickler drei normierte Grundstrukturen zur Verfügung: Sequenz (Folge von Anweisungen), Alternative (Auswahl bzw. bedingte Anweisung), Iteration (Schleife, wiederholte Anweisung).

Struktogramme werden als Darstellungsmittel für strukturierte Sprachen wie C oder PASCAL verwendet, da hier im Gegensatz zu Assembler in der Regel auf Sprunganweisungen verzichtet wird.

Seite: 78/152 Programmentwicklung aus einem Struktogramm

7.2 Vorgehen für AVR Programme

Die Lösung der folgenden Aufgabe soll die Arbeitsweise und den Umgang mit dem Struktogrammeditor in SiSy verdeutlichen. Die Programmiersprache ist C, Referenzhardware ist ein myAVR Board MK2

Hinweis: Dieses Beispiel kann mit der Ausgabe SiSy Microcontroller ++ und SiSy AVR erstellt werden.

7.2.1 Zielstellung

Es soll eine Mikrocontrollerlösung entwickelt werden, bei der auf Tastendruck eine LED eingeschaltet wird.

Schaltung Port B.0 = Taster Port B.1 = LED

7.2.2 Vorbereitung

Das Struktogramm kann je SiSy-Projekt ein Hauptprogramm verwalten. Es ist also nötig, für jedes neue Struktogramm-Projekt auch ein neues SiSy-Projekt zu erzeugen. Starten Sie ggf. SiSy. Erstellen Sie ein neues SiSy-Projekt mit dem Namen „Test_SG“. Wählen Sie das Vorgehensmodell „AVR-Vorgehensmodell“.

Legen Sie im weiteren Verlauf die AVRGrundeinstellungen für das Projekt fest. Arbeiten Sie ohne Diagrammvorlage weiter. Ziehen Sie ein Objekt vom Typ „SG“ (Struktogramm) per Drag & Drop in das Diagrammfenster. Legen Sie den Namen für das Struktogramm fest und die Sprache „AVR C“.

Programmentwicklung aus einem Struktogramm Seite: 79/152

7.2.3 Struktogramm entwickeln

Für die Entwicklung des Struktogramms, muss das Struktogrammfenster geöffnet werden; rechte Maustaste -> Kontextmenü -> Nach unten (öffnen).

Beim Einfügen einzelner Struktogramm-Elemente in das Struktogramm sind die möglichen Positionen grün unterlegt. Bewegen Sie den Mauszeiger an die gewünschte Stelle, die grüne Linie wird zur Kontrolle breiter. Führen Sie folgende Arbeitsschritte aus, um den Algorithmus für die oben genannte Aufgabe zu entwerfen:

1. Konfigurieren Sie Port B 0 als Eingang und Port B 1 als Ausgang. Ziehen Sie dafür eine „Verarbeitungsroutine“ aus der Objektbibliothek in das Struktogramm.

Doppelklick, Definieren

2. Fügen Sie eine „WHILE-Schleife“ ein.

Doppelklick, Definieren

Seite: 80/152 Programmentwicklung aus einem Struktogramm

3. Ergänzen Sie die Mainloop durch eine „Alternative“ per Drag & Drop. Achten Sie darauf, dass die Alternative innerhalb der Mainloop liegt. Geben Sie den Titel und die Bedingung für die Alternative ein.

Doppelklick, Definieren

4. Als nächstes sind die Aktionen (DO-Elemente) in der Alternative zu ergänzen. Ziehen Sie dafür erneut jeweils eine „Verarbeitungsroutine“ in die Alternative des Struktogramms.

5. Tragen Sie den C-Quellcode zum Ein- und Ausschalten der LED in die DO-Elemente ein. Selektieren Sie dazu das betreffende DO-Element per Doppelklick. Mit ESC verlassen Sie den Editiermodus.

Programmentwicklung aus einem Struktogramm Seite: 81/152

6. Generieren Sie den Quellcode für dieses Struktogramm und lassen Sie sich den Quellcode anzeigen.

7.2.4 Programmtest

Verbinden Sie das Board mit dem PC und aktivieren Sie aus dem Aktionsmenü den Befehl „>>> Erstellen“, damit brennen Sie das Programm auf den Controller. Es öffnet das myAVR ProgTool und zeigt das Protokoll an. Für den Test des Programms stecken Sie auf dem Board die Verbindungen.

Seite: 82/152 Entwicklung von Klassendiagrammen

8 Entwicklung von Klassendiagrammen

8.1 Einleitung

Mit objektorientierten Programmiersprachen hat der Entwickler mächtige Sprachmittel, um komplexe Systeme realisieren zu können. C++ ist eine weit verbreitete objektorientierte Standardsprache. Als Visualisierungsmittel objektorientierter Programme gilt die international standardisierte Beschreibungssprache UML (Unified Modeling Language). SiSy bietet dem Entwickler das UML Klassendiagramm mit Codegenerierung für C++, AVR C++ und ARM C++. Der folgende Abschnitt beschreibt die Handhabung des Klassendiagramms in SiSy. Die Abbildung zeigt Ihnen eine Kurzübersicht der Modellierungselemente des UML Klassendiagramms.

Kurzübersicht Elemente des UML Klassendiagramms

Schreibweise von Attributen:

Attribute beginnen mit einem Kleinbuchstaben.

Sichtbarkeit name : Typ = Initialwert {Merkmal}

# temperatur : uint8_t = 25

Schreibweise von Operationen:

Operationen beginnen mit einem Kleinbuchstaben.

Sichtbarkeit name (Parameter:Typ = Standardwert, ...) : Rückgabetyp {Merkmal}

+ setTemperatur ( temp : integer = 25 ) : bool

Entwicklung von Klassendiagrammen Seite: 83/152

8.2 Vorgehensweise für PC- Programme mit SVL

Hinweis: Für dieses Beispiel benötigen Sie eine Ausgabe mit dem Add-On SVL

8.2.1 Zielstellung

Die Funktion des nachfolgenden Programms ist es, auf dem Bildschirm ein Fenster mit zwei Schaltflächen zu erstellen, welche das Fenster schließen bzw. eine Message Box erzeugen.

8.2.2 Vorbereitung

Starten Sie SiSy und wählen Sie „neues Projekt erstellen“. Vergeben Sie den Projektnamen „SVL_Button“, bestätigen Sie mit „Projekt anlegen“. Wählen Sie das Vorgehensmodell „UML mit SVL (Smart Visual Library) Projekt mit Beispielen“ und laden als Diagrammvorlage „Smart Visual Library (SVL)“, welches neben Beispielen und Tutorials auch ein Grundgerüst für SVL-Anwendungen beinhaltet.

8.2.3 Grundgerüst für Fenster auswählen

Nach dem Import der Diagrammvorlage steht Ihnen eine Auswahl an Tutorials und Beispielen zur Verfügung. Wählen Sie neben der Notiz „Meine Programme“ das Klassendiagramm „Mein_erstes_Programm“ aus und öffnen Sie dieses (rechte Maustaste

 „Nach unten (öffnen)“). Sie sehen das verfeinerte Klassendiagramm, welches das Grundgerüst für Ihr Programm ist.

Seite: 84/152 Entwicklung von Klassendiagrammen

Mit der Aktion „Erstellen & Ausführen“, welche Sie über das Aktionsmenü erreichen, wird der dazugehörige Quellcode generiert, das Programm kompiliert und ausgeführt. Als Ergebnis erhalten Sie ein Fenster, welches bereits eine Schaltfläche für das Schließen des Fensters besitzt.

Diesem Fenster kann man nun beliebig viele Controls, d.h. Elemente (Schaltflächen, Checkbox, Textfeld etc.), hinzufügen und diesen einzelnen Controls entsprechende Funktionen zuweisen. Dies erreicht man über eine direkte Eingabe des Quelltextes oder über den integrierten Control-Wizard, welcher das schnelle Einfügen und Konfigurieren der Controls ermöglicht und Bestandteil sowie Arbeitsmittel in der Abarbeitung dieses Beispiels ist.

8.2.4 Schaltfläche mit Hilfe des Control-Wizards erstellen

Für den 2. Teil der Zielstellung fügen Sie dem Fenster eine weitere Schaltfläche hinzu. Dazu ziehen Sie aus der Objektbibliothek ein Objekt vom Typ „Attribut“ per Drag & Drop in die Klasse „MainWnd“. Daraufhin öffnet sich automatisch der Control-Wizard, welcher das Anlegen von Controls und Funktionen erleichtert, indem er Schritt für Schritt alle notwendigen Anweisungen ausführt.

Wählen Sie im ersten Schritt „SButton : SButton“ und klicken Sie auf „Weiter“ um eine Schaltfläche zu erzeugen.

Als nächstes geben Sie als Beschriftung des Elements den Namen „Message“ ein. Der Variablenname wird dabei automatisch vergeben, hier „btnMessage“. Klicken Sie nun „Weiter“ um zum nächsten Schritt zu gelangen, welcher sich mit der Positionierung der Schaltfläche beschäftigt. Diesen und den Folgeschritt (Tooltipp) überspringen Sie, indem Sie dreimal auf „Weiter“ und dann auf „Fertig stellen“ klicken. Die Schaltfläche und die Funktion OnButtonMessage() wird nun erstellt und der entsprechende Quellcode, welcher zur Generierung notwendig ist, wird automatisch erzeugt.

Entwicklung von Klassendiagrammen Seite: 85/152

8.2.5 Quellcode hinzufügen

Damit die neu erzeugte Schaltfläche per Mausklick eine MessageBox aufruft, müssen Sie der Funktion OnBtnMessage() noch den entsprechenden Quellcode hinzufügen. Dazu wählen Sie in der Klasse „MainWnd“ die Funktion OnBtnMessage() aus und fügen folgenden Quellcode ein:

messageBox("Mein erstes SVL-Programm","SVL");

8.2.6 Kompilieren und Linken des fertigen Programms

Klicken Sie auf das Aktionsmenü und wählen Sie „>>> Erstellen & Ausführen“ um das Projekt zu kompilieren und zu linken. Das Programm wird nach erfolgreichem Abschließen des Vorgangs automatisch gestartet.

Sollten Sie keine Fehler im Ausgabefenster erhalten haben, dann können Sie nun durch einen Klick auf die Schaltfläche „Message“ eine MessageBox mit der Nachricht „Mein erstes SVL-Programm“ erzeugen.

Für eine andere Positionierung der Schaltfläche klicken Sie in der linken unteren Ecke auf das SVL-Logo und wählen „Positionierung“. Nun können Sie per Drag & Drop Verfahren die einzelnen Elemente des Fensters neu positionieren.

Seite: 86/152 Entwicklung von Klassendiagrammen

8.3 Vorgehensweise für AVR Programme

Hinweis: Dieses Beispiel kann mit der Ausgabe SiSy Microcontroller ++ und SiSy AVR erstellt werden.

8.3.1 Zielstellung

Es soll eine Mikrocontrollerlösung entwickelt werden, bei der auf Tastendruck eine LED eingeschaltet wird. Die Realisierung dieser Aufgabe soll mit dem Klassendiagramm in SiSy erfolgen.

Schaltung Port B.0 = Taster Port B.1 = LED

8.3.2 Vorbereitung

Starten Sie SiSy und wählen Sie „neues Projekt erstellen“. Vergeben Sie den Projektnamen „Test_UML“, bestätigen Sie mit „Projekt anlegen“. Wählen Sie das Vorgehensmodell „AVR-Vorgehensmodell“.

Legen Sie im weiteren Verlauf die AVR-Grundeinstellungen für das Projekt fest. Danach erscheint ein Dialogfenster mit möglichen Diagrammvorlagen, verwenden Sie keine Vorlage.

Hinweis

: Wenn Ihre online-Verbindung zum Internet aktiv ist, erhalten Sie an Stelle des Dialogfensters für die Auswahl der Vorlagen das Dialogfenster von LibStore. Hier können Sie die Auswahl treffen für „myAVR C++ Framework“ und den Download ausführen. Nach dem Import der Dateien steht Ihnen im Diagrammfenster das Objekt „myAVR_Library“ mit zahlreichen Beispielen zur Verfügung.

Ziehen Sie ein Objekt vom Typ „Klassendiagramm“ per Drag & Drop in das Diagrammfenster. Legen Sie in dem sich öffnenden Dialogfenster einen Namen für das Klassendiagramm fest und die Sprache „AVR C++“. Prüfen Sie unter „Extras (AVR)“ die Hardware-Einstellungen.

Entwicklung von Klassendiagrammen Seite: 87/152

run();

8.3.3 Grundstruktur laden

Zur Entwicklung des Klassenmodells öffnen Sie das Klassendiagramm (auf dem Objekt rechte Maustaste -> Kontextmenü -> Nach unten ). Laden Sie die Diagrammvorlage „Grundgerüst (GGKC1101)“ bzw. aus LibStore „AVR C++ Grundgerüst ohne Framework“.

do {

// hier // Eingabe // Verarbeitung // Ausgabe

} while (true);

// hier Initialisierungen // …

Seite: 88/152 Entwicklung von Klassendiagrammen

Hinweis: Die Struktur einer objektorientierten Mikrocontrollerlösung in SiSy erfordert im Klassenmodell eine Applikationsklasse (Hauptklasse), die sich dadurch auszeichnet, dass diese über eine Methode (Operation) mit dem Namen main verfügt. Der Codegenerator erzeugt eine Instanz diese Klasse und ruft die Main-Methode auf.

Beispiel:

#define cpp_Test_UML #define F_CPU 3686400 #include <avr\io.h>

main (void) { Controller MyApp; MyApp.main(); }

8.3.4 Systemstruktur entwerfen

Die Systemstruktur einer objektorientierten Anwendung bildet die Objekte und deren Beziehungen im Programm ab, welche im realen System als physische Elemente vorhanden sind. Als Bauplan der Objekte dienen Klassendeklarationen, welche die Eigenschaften (Attribute) und das Verhalten (Methoden/Operationen) der Objekte beschreiben. Das Klassendiagramm beschreibt also die Struktur der Klassen (Baupläne der Objekte) und die Beziehungen zwischen den Klassen. In unserer Aufgabenstellung finden wir die Objekte des Systems als

Substantive, deren Beziehungen und Verhalten als

Verbalphrasen.

Es soll eine Mikrocontrollerlösung entwickelt werden, bei der durch drücken eines Tasters eine LED

eingeschaltet wird. Dabei soll der Taster an Port B 0 und die LED an Port B 1 angeschlossen werden

Daraus lässt sich folgende Klassenstruktur ableiten:

Klassenstruktur, Systementwurf mit dem UML Klassendiagramm

Entwicklung von Klassendiagrammen Seite: 89/152

Zum Erstellen dieses Klassenmodells sind folgende Arbeitsschritte nötig:

1. Klassen einfügen und definieren, ziehen Sie dazu das Objekt vom Typ „Klasse“ per Drag & Drop aus der Objektbibliothek in das Diagramm. Definieren Sie den Namen der Klasse und setzen die Option „diese Klasse generieren“.

2. Klassen verbinden, selektieren Sie die Klasse, von der aus eine Verbindung gezogen werden soll. Ziehen Sie per Drag & Drop ausgehend vom roten Verteiler eine Verbindung auf die gewünschte Klasse. Wählen Sie den Verbindungstyp, zum Beispiel „Aggregation“ und beschriften Sie die Verbindung.

Seite: 90/152 Entwicklung von Klassendiagrammen

3. Operationen und Attribute einfügen und definieren, ziehen Sie dazu ein Objekt vom Typ „Operation“ oder „Attribut“ aus der Objektbibliothek auf die Klasse, in die das Attribut oder die Operation eingefügt werden soll. Bestätigen Sie die Sicherheitsabfrage zum Einfügen des Elementes.

Definieren Sie Zugriff (Sichtbarkeit), Name, Typ und Parameter der Operation bzw. Zugriff (Sichtbarkeit), Name, Typ und Initialwert des Attributes.

Vervollständigen Sie das Klassenmodell entsprechend der Abbildung.

Hinweis: Bei der Funktion pressed() ist bei Rückgabevariable/-wert „false“ einzutragen.

endgültiger Systementwurf mit dem UML Klassendiagramm

Entwicklung von Klassendiagrammen Seite: 91/152

return

Hinweis: SiSy kennt generischen Strukturen, Templates. Es sind Vorlagen, die zum Übersetzungszeitpunkt etwas Konkretes erstellen. Die Generierung der konkreten Klassen übernimmt dabei der Codegenerator. Die Templates finden sich im Paket Tempos und deren Unterordner. Tempos kann mit konventionellen Klassen durchaus gemischt eingesetzt werden. Die gewünschten Tempos-Pakete finden Sie über den Navigator (rechte Maustaste/UML-Pakete).

8.3.5 Systemverhalten programmieren

Die Operationen müssen mit der entsprechenden Logik versehen werden. Sie können den Quellcode der Operationen bearbeiten, indem Sie die gewünschte Operation selektieren und im Beschreibungsbzw. Quellcodefester die Befehle eingeben.

programmieren

selektieren

led_rot.init(); taster_1.init(); run();

cbi(DDRB,0); //Eingang sbi(PORTB,0); //PullUp

if (!(PINB&0x01)) return true; else

do {

if (taster_1.pressed())

led_rot.on();

else

led_rot.off();

while (true);

}

sbi(DDRB,1); //Ausgang

off();

sbi(PORTB,1); //LED on

cbi(PORTB,1); //LED off

//LED off

Seite: 92/152 Entwicklung von Klassendiagrammen

8.3.6 Übersetzen, Brennen und Testen

Die Codegenerierung aus dem UML Klassendiagramm, das Kompilieren, Linken und Brennen kann über das Aktionsmenü gestartet werden.

Sie erhalten im Ausgabefenster ein Protokoll der ausgeführten Aktionen.

Entwicklung von Klassendiagrammen Seite: 93/152

8.3.7 Interrupt-Service-Routinen (ISR) im Klassendiagramm

Interrupt-Service-Routinen (im weiteren ISR) werden in AVR C++ durch das Schlüsselwort ISR gekennzeichnet. Sie bilden eigenständige Funktionen. Die Besonderheit bei der Realisierung einer ISR liegt darin, dass es sich hier um ein C-Makro handelt und nicht um eine echte Funktion. Diese können also keine Methode einer Klasse sein. Um eine ISR im Klassendiagramm zu realisieren gehen Sie wie folgt vor (Erweiterung des Beispiels um die Klasse Timer und der ISR Timer0 Overflow):

1. Die Klasse für die interruptfähige Komponente modellieren und die Methode einfügen, welche beim Interrupt ausgeführt werden soll. In unserem Beispiel ist es die Klasse Timer mit der Methode overflow. Die Initialisierung des Timers muss entsprechend erfolgen.

2. Ergänzen Sie das Klassendiagramm weiter entsprechend der Abbildung.

Timer0.overflow();

Beispiel für Ergänzung der main:

#include <io.h>

// Instanz der interruptfähigen Klasse anlegen

Timer Timer0;

// Interuptmakro mit Aufruf der betreffenden Methode

ISR (TIMER0_OVF_vect)

{

Timer0.overflow();

}

In der Interrupt-Service-Routine rufen Sie nur die Methode der betreffenden Klasse auf.

Seite: 94/152 Entwicklung von Klassendiagrammen

8.4 Vorgehensweise für ARM Programme

Hinweis: Dieses Beispiel kann mit der Ausgabe SiSy Microcontroller ++ und SiSy ARM erstellt werden.

8.4.1 Zielstellung

Es soll eine Mikrocontrollerlösung mit einem Klassendiagramm entwickelt werden, bei der auf Tastendruck eine LED eingeschaltet wird. Die Referenzhardware ist ein STM32F4-Discovery.

Schaltung Port GPIOA.0 = Taster Port GPIOD.13 = LED.

8.4.2 Vorbereitung

Starten Sie SiSy und wählen Sie „neues Projekt erstellen“. Vergeben Sie den Projektnamen „Test_UML“, bestätigen Sie mit „Projekt anlegen“. Wählen Sie das Vorgehensmodell „ARM-Vorgehensmodell“.

Von den möglichen Diagrammvorlagen wählen Sie „ARM C++ Framework“ aus. Wenn Ihre online-Verbindung zum Internet aktiv ist, erhalten Sie an Stelle des Dialogfensters für die Auswahl der Vorlagen das Dialogfenster von LibStore. Hier können Sie die Auswahl treffen für „ARM Framework“ oder „ARM Framework mit Beispielen“.

Ziehen Sie ein Objekt vom Typ „Klassendiagramm“ per Drag & Drop in das Diagrammfenster. Vergeben Sie für das Klassendiagramm einen Namen und wählen Sie die Sprache „ARM C++“ aus. Auf der Registerkarte „Options (ARM)“ kontrollieren Sie die voreingestellte Hardware bzw. wählen Ihre Hardware aus und laden die Vorlage.

Entwicklung von Klassendiagrammen Seite: 95/152

Definieren

8.4.3 Grundstruktur laden

Zur Entwicklung des Klassenmodells muss das Klassendiagramm geöffnet werden. Wählen Sie dazu auf dem Objekt rechte Maustaste -> Kontextmenü -> Nach unten. Es öffnet das Dialogfenster mit Vorlagen oder LibStore.

do {

//hier //Eingabe //Verarbeitung //Ausgabe

} while (true);

Seite: 96/152 Entwicklung von Klassendiagrammen

Systick::config(SystemCoreClock/100);

// Led initialisieren

Rcc rcc; rcc.ahb1PeriphClockCmd(RCC_AHB1Periph_GPIOD,ENABLE); led.initStruct.GPIO_Pin |= 1<<12; led.initStruct.GPIO_Mode = GPIO_Mode_OUT; led.initStruct.GPIO_Speed = GPIO_Speed_50MHz; led.initStruct.GPIO_OType = GPIO_OType_PP; led.initStruct.GPIO_PuPd = GPIO_PuPd_NOPULL; led.init(GPIOD);

// Mainloop

this->run();

Da für dieses Beispiel die Hardware STM32F4 verwendet wird, sollte das Treiberpaket mit in das Klassendiagramm gezogen werden. Klicken Sie mit der rechten Maustaste auf den „Navigator“ und wählen Sie die „UML-Pakete“ aus. Danach ziehen Sie das Paket in das Diagramm.

Entwicklung von Klassendiagrammen Seite: 97/152

8.4.4 Systemstruktur entwerfen

Substantive, deren Beziehungen und Verhalten als

Verbalphrasen.

Es soll eine Mikrocontrollerlösung entwickelt werden, bei der durch drücken eines Tasters eine LED

eingeschaltet wird. Dabei soll der Taster an Port GPIOA.0 und die LED an Port GPIOD.13 angeschlossen werden

Daraus lässt sich folgende Klassenstruktur ableiten:

Klassenstruktur, Systementwurf mit dem UML Klassendiagramm

Seite: 98/152 Entwicklung von Klassendiagrammen

Zum Erstellen dieses Klassenmodells sind folgende Arbeitsschritte nötig:

1. Klassen einfügen und definieren, ziehen Sie dazu ein Objekt vom Typ „Klasse“ per Drag & Drop aus der Objektbibliothek in das Diagramm. Definieren Sie den Namen der Klasse und setzen die Option „diese Klasse generieren“. Führen Sie diese Aktion für „Taster“ und „Led“ aus.

Entwicklung von Klassendiagrammen Seite: 99/152

Definieren Sie Zugriff (Sichtbarkeit), Name, Typ und Parameter der Operation bzw. Zugriff (Sichtbarkeit), Name, Typ und Initialwert des Attributes.

Hinweis: Bei der Funktion isPressed() ist bei Rückgabevariable/-wert „press“ einzutragen.

Seite: 100/152 Entwicklung von Klassendiagrammen

4. Templates einfügen, klicken Sie mit der rechten Maustaste auf den „Navigator“ und wählen Sie die „UML-Pakete“ aus. Danach folgen Sie der Hierarchie und ziehen das gewünschte Template in das Diagramm. Zuletzt verbinden Sie das Template mit einer Klasse.

Vervollständigen Sie das Klassenmodell entsprechend der Abbildung.

endgültiger Systementwurf mit dem UML Klassendiagramm

myAVR Board MK2 2.10 User guide [de]

Specifications and Main Features

Frequently Asked Questions

User Manual