Einfuhrung in LabVIEW 3446415602, 9783446415607 [PDF]

Zitiervorschau

--

.� .� --

-

, .

-�

. '='

. .

'

,-

Georgi I Metin Einführung in LabVIEW

,J.. Bleiben Sie einfach auf dem Laufenden: �www.hanser.de/newsleHer Sofort anmelden und Monat für Monat

die neu esten Infos und Updates erhalten

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cfOS9d91b1gecaOOaO, Zentral- u 2009.07.31 21 :4�

Wolfgang Georgi

•

Ergun Metin

Einführung in

LabVIEW

4., neu bearbeitete Auflage mit 787 Bildern und 146 Aufgaben

Fachbuchverlag Leipzig

im Garl Hanser Verlag

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cfOS9d91b1gecaOOaO, Zentral- u 2009.07.31 21 :4�

Prof. Dipl.-Math. Wolfgang Georgi

Hochschule Ravensburg-Weingarten für Technik, Wirtschaft und Sozialwesen

Dipl.-Ing. Ergun Metin

Philipp Haudek Informatik GmbH (PHI)

Alle in diesem Buch enthaltenen Programme, Verfahren und elektronischen Schaltungen wurden nach bestem Wissen erstellt Wld mit Sorgfalt getestet. Dennoch sind Fehler nicht ganz auszu­

schließen. Aus diesem Gnmd ist das im vorliegenden Buch enthaltene Programm-Material mit keiner

Verpflichtung oder Garantie irgendeiner Art verbWlden. Autor und Verlag übernehmen infolgedessen keine Verantwortung Wld werden keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der Benutzung dieses Programm-Materials oder Teilen davon entsteht.

Die Wiedergabe von Gebrauchsnamen, Handelsnamen, WarenbezeichnWlgen usw. in diesem Werk

berechtigt auch ohne besondere KennzeichnWlg nicht zu der Annahme, dass solche Namen im Sinne

der Warenzeichen- Wld Markenschutz-GesetzgebWlg als frei zu betrachten wären Wld daher von

jedermann benutzt werden dürften.

Bibliografische Information der Deutschen Nationalbibliothek Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über hup:lldnb.d-nb.de abrufbar. ISBN 978-3-446-41560-7

Dieses Werk ist urheberrechtlich geschützt. Alle Rechte, auch die der Übersetzung, des Nachdruckes und der Vervielfaltigung des Buches, oder Teilen daraus, vorbehalten. Kein Teil des Werkes darf ohne schriftliche GenehmigWlg des

Verlages in irgendeiner Form (Fotokopie, Mikrofilm oder ein anderes Verfahren), auch nicht flir Zwecke der Unterrichtsgestaltung - mit Ausnahme der in den Sonderfalle

-,

reproduziert

oder

unter

Verwendung

§§

53, 54 URG genannten

elektronischer

Systeme

verarbeitet,

vervielfaltigt oder verbreitet werden.

Fachbuchverlag Leipzig im Carl Hanser Verlag

© 2009 Carl Hanser Verlag München Internet: http://www.hanser.de Lektorat: Dipl.-Ing. Erika Hotho u n d Mirja Werner, M. A. Herstellung: Dipl.-Ing. Franziska Kaufmann Covergestaltung: MCP . Susanne Kraus ObR, Holzkirchen Druck und Bindung: Kösel, Krugzell Printed in Oermany

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1 gecaOOaO, Zentral- u 2009.07.31 21 :4�

Vorwort

In der Industrie ist in letzter Zeit im mer häufg i er das Stichwort 'LabVIEW' zu hören, wenn es

um die Erstellung von Programmen für messtechnische Anwendungen geht. Große und

kleine Unternehmen bedienen sich dieses von der Firma National Instruments entwickelten

Softwaresystems. Obwohl es Eingeweihten schon seit mehr als 10 Jahren bekannt ist, haben deutsche Hochschulen erst vor kurzem begonnen, sich mit diesem Thema zu beschäftigen.

Das liegt sicher auch daran, dass es zwar eine Reihe englischer Titel, aber kaum deutschspra­ chige Lehrbücher gibt. Wegen der steigenden Verbreitung von LabVIEW sollte sich das ändern. Deshalb führt dieses Lehrbuch in das Programmieren mit LabVIEW ein. Wir setzen dabei voraus, dass der Leser die Beispiele und übungen am PC durcharbeitet. Dort sollte die Ver­ sion 8.0 oder 7.1 von LabVIEW installiert sein. Frühere Versionen wie 7.0 oder 6.1 sind im Kern recht ähnlich. Programme, die mit diesen Versionen erstellt werden, laufen auch unter der Version 7.1. Doch trifft das Umgekehrte naturgemäß nicht zu, weil jede neue Version auch neue Möglichkeiten bietet. Weiter wird vorausgesetzt, dass der PC unter einem der Betriebssysteme Windows 2000, Windows XP oder Linux arbeitet. Das Buch wendet sich an Studenten, aber auch an Ingenieure, die unter dem Stichwort des lebenslangen Lernens versuchen wollen, den neuesten Trends in der Industrie Rechnung zu tragen. Das Lehrbuch gliedert sich in drei Teile: Teil I:

Grundlagen des Programmierens in LabVIEW

TeilII:

Technische Anwendungen

Teil lll: Kommunikation In Teli I werden Installation und Aufruf von LabVIEW, grundlegende Arbeitsmittel wie (Front-)Panel, Diagramm, Paletten für Eingabe/Ausgabe, Funktionen und Werkzeuge be­ handeJt, ferner Konzepte von LabVIEW, Datentypen, Grundlagen der Programmierung und Visualisierungstechniken. Teil II befasst sich mit Anwendungen wie Fouriertransformation, Filterung, Lösen von Diffe­ renzialgleichungen und Differenzialgleichungssystemen in der Technik. Teil III schließlich geht auf die immer wichtiger werdende Kommunikation ein. Hier sind zwei Aspekte von Bedeutung: 1. Externe Kommunikation mit anderen Geräten und Rechnern, z.B. über USB, Datenerfas­ sungskarten, TCP/IP (Internetanbindung), 2. Kommunikation mit anderen Softwarepaketen, z.B. mit der Erstellung und Anbindung selbst geschriebener C-Module.

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zentral- u 2009.07.31 21:42:39 +02'00'

VOMllort

6

Das Lehrbuch ist knapp gehalten. Es kann also nur eine Einführung sein, die allerdings ver­ sucht, die wichtigsten Aspekte von LabVIEW zu berücksichtigen. Bei einem so umfangrei­ chen Softwarepaket wie LabVIEW sind jedoch Lücken unvermeidlich. Hier verweisen wir auf die weiterführende Literatur, auf die Veröffentlichungen von National Instruments, auf User Groups und auf das Internet ganz allgemein. Diese Hinweise werden wir in den ver­ schiedenen Kapiteln des Lehrbuchs noch vertiefen. Wir bedanken uns ganz herzlich bei denen, die uns geholfen haben: Dipl.-Ing. Heim für die

Beratung in Schnittstellenfragen, bei Prof. Oe. Wöllhaf für Mitarbeit (MATLAS·-Diagramm)

und Durchsicht der KapiteJ 10 bis 13. Ganz besonderer Dank geht an Frau Dipl.-Ing. 80sl für

die sorgfaltige Durchsicht von Texten und Bildern und eine Fülle von guten Ratschlägen im Sinne einer besseren Verständlichkeit.

Weingarten, November 2005

W. Georgi E. Metin

Vorwort zur 4. Auflage Die vierte Auflage der "Einführung in LabVIEW" wurde in einigen Teilen grundlegend um­ gearbeitet. Das betrifft besonders Teil III: Kommunikation und den mit der dritten Auflage eingeführten Teil IV: Fortgeschrittene Techniken. In Teil III wurden die KapitellS und 16 nahezu komplett neu geschrieben. In Teil IV wurde Kapitel 17 aus dem alten Kapitel 20 über Zustandsautomaten entwickelt und um Hinweise und Werkzeuge zur professionellen Programmierung erweitert. Kapitel 18 über OOP wurde unverändert übernommen. Dagegen wurde Kapitel 19 stark verändert: Die Linux-Beispiele wurden durch einen Abschnitt über Datenbankanbindungen ersetzt. Das neue Kapitel 20 zum Internet wurde aus den früheren Kapiteln 17 und 21 gebildet. Kapitel 22 über FPGAs wurde in Kapitel 21 umbenannt. Einige Abschnitte aus der dritten Auflage wurden entfernt, so z.B. Kapitel 2.4 über die Um­ stellung von Paletten durch den Anwender. Sie sind aber unter www.GeMe-LabYIEW.de im Internet zu finden. Alle Beispielprogramme wurden soweit möglich für die LabVIEW-Version 8.0 geschrieben. Im Wesentlichen wurde LabVIEW 8.2 nur in Kapitel 18 eingesetzt und Version 8.5 nur in Kapitel2!. Wieder bedanken wir uns bei vielen Helfern: bei Herrn Dipl.-Ing. Hübler für die Hilfe bei der Erstellung von Programmen

zum

GPIB-Bus, bei Herrn Dipl.-Ing. Herzer für Beispiele

zur USB-Programmierung unter Linux, bei Prof. Dr. Etschberger und seinen Mitarbeitern, besonders Herrn Dipl.-Ing. Stobe, für Unterstützung bei der Entwicklung von Vb für den CAN-Bus. Ferner danken wir Prof. Oe. Klemt für Beratung in messtechnischen Fragen. Der

Finna National Instruments danken wir für die leihweise überlassung verschiedener Geräte:

angefangen von GPlB-Steckern über ein lVI-Oszilloskop usw. bis hin zur PCI-Karte 4472, ohne die wir die entsprechenden Beispiele in KapitellS und 16 nicht hätten schreiben können.

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00. ID:7ac0427dS929S1cf089d91b1gecaOOaO, Zenlral- u 2009_07_31 21:42:39 +02'00'

Vorwort

7

Der Firma Brüel & Kjaer sei gedankt für die leihweise überlassung eines TEDS­ Beschleunigungssensors und der Firma ZILA Elektronik GmbH aus ZeUa Mehlis für ver­ schiedene CAN-Sensoren. Dem Fachbuchverlag Leipzig, und hier besonders Frau Hotho und Frau Kaufmann, danken wir für die gründliche Korrektur und viele Ratschläge zur Gestaltung des Layouts. Zuletzt möchten wir uns auch bei allen Lesern bedanken, die uns auf Fehler hingewiesen und damit zur weiteren Verbesserung der vierten Auflage beigetragen haben.

Weingarten, Februar 2009 Baienfurt

W. Georgi E. Metin

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO Zentral- u 2009_07_31 21:42:39 +02'00'

Inhalt

Tell I: Grundlagen des Programmlerens In LabVIEW

17

1

Was Ist LabVIEW7

1.1

Entwicklungsstufen ......................................................................................................... 19

,.

1.2

Was will dieses Lehrbuch? ..............................................................................................21

1.3

Installation .......................................................................................................................21

1.4

Einführendes BeispieJ ......................................................................................................21 1.4.1 1.4.2

15 1.6

Programmierung von c = a + b ...........................................

...........................

26

Speicherung als Programm Add.vi ................................................................ 29

1.4.3

Starten und Stoppen von Add.vi ....................................................................29

1.4.4

Fehlersuche in Add.vi (Debugging) ............................................................... 30

BeispieJ für eine Grafik in LabVIEW ................................... .......................................... 31 Grundlegende Konzepte von LabVIEW ........................................................................ 31 1.6.1

Frontpanel ....................................................................................................... 31

1.6.2

Blockdiagramm ............................................................................................... 32

1.7

Rezepte

1.8

Shortcuts ........................................................... .............................................................. 34

............................................................................................................................

33

2

Einstellungen, Sprachenwahl, Paletten

2.1

Einstellungen ................................................................................................................... 35 2.1.1 2.1.2 2.1.3

2.2

2.3

'Neu und geändert in 8.x'

3S

...........................................................

.................... 35

Frontpanel ....................................................................................................... 36

Blockdiagramm ............................................................................................... 37

2.1.4

Ausrichtungsgitter .......................................................................................... 39

2.15

Wiederherstellungen ...................................... ................................................ 40

Sprachenwahl ................................................................................................................... 41 2.2.1

Menüpunkte .................................................................................................... 41

2.2.2

Werkzeuge - Optionen ................................................................................... 41

2.2.3

Datei - VI-Einstellungen ................................................................................ 42

Paletten ............................................................................................................................ 42 2.3.1

Werkzeugpalette (Tools Palette) ....................................................................42

2.3.2

Eingabe-/Ausgabe-Elemente ......................................

2.3.3

Funktionenpaleue ...........................................................................................46

....................................

44

49

3

Programmstrukturen

3.1

Strukturiertes Programmieren ..............................................

3.2

Sequenz ........................................................................................................................... 51

3.3

Alternative, Case-Struktur .............................................................................................. 56

3.4

Schleifen ..........................................................................................................................60

.........................................

49

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zentral- u 2009_07_31 21:42:39 +02'00'

Inhalt

10

65

4

Datentypen

4.1

Numerische Datentypen .................................................................................................65 4.1.1

Kontextmenü: Darstellung ................................................ ............................65

4.1.2

Kontextmenü: Format und Genauigkeit .......................................................66

4.2

Boolesche Datentypen ....................................................................................................68

4.3

String und Pfad ...............................................................................................................70

4.4

Arrays

4.5

............................................................................................. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

73

4.4.1

Definition und Initialisierung eines I-dimensionalen Arrays ......................73

4.4.2

Definition und Initialisierung eines 2-dimensionalen Arrays ...................... 75

4.4.3

Rechnen mit Arrays: Addition .......................................................................76

4.4.4

Rechnen mit Arrays: Multiplikation ..............................................................78

4.4.5

Steuerung von FOR-Schleifen mit Arrays .....................................................79

4.4.6

Behandlung einzelner ArrayeJemente ........................................................... 81

Cluster ..............................................................................................................................83 4.5.1

Erzeugung eines Clusters ...............................................................................83

4.5.2

Clusterwerte ändern ........................................................................................85

4.5.3

Aufschlüsseln eines Clusters ..........................................................................86

4.5.4

Umordnen der Elemente eines Clusters ........................................................88

4.6

Ring & Enum ............................................. ..................................................................... 89

4.7

Gestaltung von Panel und Diagramm .............................................................................92

5

5.1 5.2

Unterprogramme

Erstellen von Unterprogrammen ................................................................................... 94 5.2.1

5.2.2

Einführendes Beispiel ..................................................................................... 94

Weitere Hinweise für die Erstellung eines Unterprogramms ....................... 97

5.2.3

Einstellungen für Programme und Unterprogramme .................................. 99

5.2.4

Erstellen von Unterprogrammen mit internem Zustand ........................... 101

5.2.5 5.3

93

Wozu Unterprogramme (SubVIs)? ............................................................................... 93

Erstellen von polymorphen Unterprogrammen ......................................... 103

Aufruf von Unterprogrammen .................................................................................... 105 5.3.1

Statische Bindung .......................................................................................... 105

5.3.2

Dynamische Bindung .................................................................................... 106

5.3.2.1

VI-Referenz öffnen und schließen ............................................................... 106

5.3.2.2

Aufruf eines VI über seine Referenz ............................................................ 108

5.3.2.3

Beispiel für den SubVI-Austausch während der Laufzeit.. ......................... 109

5.3.2.4

Rekursiver Aufruf von Unterprogrammen .................................................. 110

5.3.2.5

Testen (Debugging) von ablaufinvarianten SubVls ....... ............................ 111

6

Prozessvlsuallslerung

6.1

OOP-Konzepte ............................................................................................................. 113

113

6.2

Eigenschafts- und Methodenknoten ............................................................................ 113

6.3

Grafische Ausgabe ......................................................................................................... 117 6.3.1

Chart (Signalverlaufs-Diagramm) ................................................................ 118

6.3.1.1

Darstellung einer Sinuskurve ....................................................................... 118

6.3.1.2

DarsteJlung von zwei oder mehr Kurven in einem Chart ........................... 120

6.3. L3

Legende zu einem Chart oder Graphen ............... ....................................... 121

6.3.1.4

Skalierung der Ordinate in einem Chart .. ................................................... 122

6.3.2

Graph ......................................................... ................................................... 124

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zentral- u 2009_07_31 21:42:39 +02'00'

Inhalt

6.4

II 6.3.2.1

Darstellung einer Sinuskurve

6.3.2.2

Darstellung von zwei oder mehr Kurven in einem Graphen

6.3.2.3

Skalierung der Abszisse in einem Graphen

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..........

.......... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6.3.3

XY-Graph

6.3.3.1

Darstellung einer Relation im XY -Graphen

6.3.3.2

Darstellung mehrerer Relationen in einem XY-Graphen

6.3.4

Signalverlauf

Express-VIs

......................

......................................................................................................

................. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

...

. . . . . . . . . . . . . . . ........

..................................................................................................

....................................................................................................................

6.4.1

Ein Express-VI zur Erzeugung von Kurven

6.4.2

Express-VI zur Erstellung von Berichten

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .................

. . . . . . . . . . . . . . . . . ...................................

124 126 127 129 130 131 132 137 137 139

140

7

Referenzen

7.1

Einführendes Beispiel ................................................................................................... 140

7.2

7.1.1

Vertauschung von zwei Variablenwerten .................................................... 140

7.1.2

Referenzen auf Bedien- und Anzeigeelemente

7.1.3

Lösung des Vertauschungsproblems

Vererbung 7.2.1

Eigenschaften der Basisklasse

7.2.2

Eigenschaften von abgeleiteten Klassen

Datentransfer von und zur Festplatte Dateifunktionen

141 142 143 145 146

148 148

8.1.1

Allgemeines zur Speicherung von Dateien .................................................. 148

8.1.2

Menüs

8.1.3

Einführendes Beispiel

8.1.4

Modifiziertes Beispiel

8.1.5

Beispiel: Anlegen einer Protokolldatei

Pfade 8.2.1

............................................................................................................

...................................................................................

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ....................................

überschreiben ohne Warnung

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..........

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ................................

.......................................................................................................... . . . . . . . . . . . . . . . . . . . .

8.2.2

Pfadkonstanten pfadkonstante 'Standardverzeichnis'

8.2.3

'Standardverzeichnis' ändern

.............................................................................................

...........................................................

. . . . . . . . . . . . . . . . . . . . . . . ................................................

8.2.4

'Standard-Datenverzeichnis' ändern

8.2.5

Lesen und Schreiben anderer Datentypen

8.2.6

Verketten von Schreib- und Lesefunktionen

8.2.7

Tabellenkalkulation

8.3

Pfade in einer EXE-Datei

8.4

Fortgeschrittene Dateitypen

9.2

......................................................

.............................................................................................................

8.1.6

•

..........................................

. . . . . . . . . . . . . . . . . . . . . . . . ..............................................

8

9.1

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ...........

.....................................................................................................................

8.1

8.2

................

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..................

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ......

. . . . . . . . . . . . . . . . . . . . . . . .......................

......................................................................................

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ......................................

..........................................................................................

8.4.1

LVM-, TDMS- und TDM-Dateien

8.4.2

Diadem

8.4.3

ZIP-Dateien

8.4.4

Konfigurationsdateien

...............................................................

................................................................... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

..................................................................................................

.................................................................................

LabVIEW-Kurzüberbllck Aufbau des LabVIEW-Systems

151 152 153 154 155 155 156 157 158 158 159 160 160 163 163 167 168 169

17S . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .................................

9.1.1

Interpretieren oder kompilieren?

9.1.2

Datenflussprogrammierung

Projektverwaltung

150

................................................................

........................................................................

.................................................................................. . . . . . . . . . . . . . . . . . . . . . .

175 175 176 178

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zentral- u 2009.07.31 21:42:39 +02'00'

Inhalt

12 9.3

Erstellung von EXE-Dateien ......................................................................................... 179 Warum EXE-Dateien? .................................................................................. 179 9.3.2 Erstellung einer EXE-Datei ........... 180 Entwiclclungsumgebung von LabVIEW 8.x ................................................................ 185 9.4.1 Deaktivierungsstrukturen ............................................................................. 185 9.4.2 Debug-Einstellung in der Projektverwaltung ......................................... 187 LabVIEW-Bibliotheken .......................................................... 188 Umwandeln von llB-Bibliotheken ............................................................................. 192 Einbindung von C-Programmen unter Windows ...................................................... 194 9.7.1 Programmieren einer eigenen DLl in C oder C++ ................................. 194 9.7.2 Anschließen einer Dll an einen ClF-Knoten ............................................ 195 Hilfen zu LabVIEW ....................................................................................................... 198 9.3.1

...............................................................

9.4

.....

9.5 9.6 9.7

......................................

...

9.8

201

Tell 11: Technische Anwendungen

10

Fourlertransformatlon 202 Zeit- und Frequenzbereich ........................................................................................... 202 10.1.1 Die reelle Fouriertransformation .............................................................. 203 10.1.2 Darstellung der Fourierkoeffizienten-'l in LabVIEW ................................. 206 10.2 Diskrete Fouriertransfonnation............................................. 209 10.2.1 Satz von Shannon .......................................................................................... 210 10.2.2 Aliasing .......................................................................................................... 211 10.2.3 Frequenzauflösung........................................................................................ 212 W.I

...

.......................................

11

Filterung 214 Filtertypen 214 11.1.1 Ideale und reale Filter........................................................... 214 11.1.2 Beispiel eines digitalen Filters ................................................. 215 11.2 LabVIEW-Filterfunktionen .......................................................................................... 218 11.3 Filterung im Frequenzbereich ...................................................................................... 220 11.3.1 Idee der Filterung im Frequenzbereich ....................................................... 220 11.3.2 Die inverse Fouriertransformation in LabVIEW ........................................ 220 11.3.3 Beispiel eines Tiefpasses ............................................................................... 221 11.1

......................................................................................................................

.........................

.....................

12

Differenzialgleichungen 224 Lösen mit LabVIEW-ODE-Funktionen ........................................... 224 12.2 Lösen nach dem Analogrechnerprinzip ....................................................................... 227 12.2.1 Blockdiagramm-Darstellung ........................................................................ 227 12.2.2 Vereinfachungen ........................................................................................... 230 12.3 Globale Variablen .......................................................................................................... 23I 12.4 Genauigkeit numerischer Verfahren ....................................................... 232

12.1

...........................

.....................

13

Systeme von Differenzialgleichungen

236

13.1 Systeme gewöhnlicher Differenzialgleichungen .......................................................... 236 13.2

Gekoppeltes Feder-Masse-System ..............................................................

.................

236

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zentral- u 2009.07.31 21:42:39 +02'00'

Inhalt

13

13.2.1 Lösung mit eingebauter ODE-Funktion ...................................................... 237 13.2.2 Lösung mit Blockdiagramm wie in MATLAB ............................................ 239 13.3 Umwelt und Tourismus ................................................................................................ 240

14

Parallelverarbeitung, Erelgnls-, Zeltsteuerung 243 14.1 Einführendes Beispiel ................................................................................................... 243 14.2 Grundbegriffe der Parallelverarbeitung ....................................................................... 245 14.2.1 Multiprocessing, Multitasking,Multithreading .......................................... 245 14.2.2 Synchronisation von Prozessen ................................................................... 246 14.3 Parallelverarbeitung unter LabVIEW ..................... ..................................................... 247 14.3.1 Erzeugen von Ressourcen für die Prozesskommunikation................ ........ 249 14.3.2 Freigabe von Ressourcen der Prozesskommunikation .............................. 251 14.3.3 Zeitbegrenzung schont Ressourcen ............................................................. 252 14.4 Prozess-Synchronisation ohne Datenaustausch .......................................................... 252 14.4.1 Occurrences .................................................................................................. 252 14.4.2 Semaphor ...................................................................................................... 253 14.4.3 Rendezvous ................................................................................................... 255 14.5 Prozess-Synchronisation mit Datenaustausch ............................................................ 256 14.5.1 Melder-Operationen ..................................................................................... 256 14.5.2 Queue-Operationen ...................................................................................... 258 14.6 Ereignisgesteuerte Programmierung ........................................................................... 258 14.6.1 Frontpanel-Ereignisse .................................................................................. 258 14.6.2 Wertänderungs-Ereignisse ..................................................................... ..... 263 14.7 Zeitschleifen ............................... ................................................................................... 265

Tell 111: Kommunikation

267

15

Serielle ElngabefAusgabe 268 15.1 RS-232 268 15.2 Programmierung der RS-232 in LabVIEW ................................................................. 270 15.3 Die USB-Schnittstelle .................................................................................................... 273 15.3.1 Programmierung unter Windows ... ............................................................ 274 15.3.2 Programmierung unter Linux ...................................................................... 278 15.4 Feld-Bus,CAN-Bus ....................................................................................................... 278 15.4.1 CAN-Protokoll ............................................................................................. 279 15.4.2 CAN-Controller ........................................................................................... 280 15.4.3 CAN-Hardware, erste Anwendungen ......................................................... 284 15.4.4 Weitere Beispiele für den Datenaustausch mittels CAN-Bus.. ................... 289 15.4.5 CAN-Bus mit Laptop und einem Sensor ..................................................... 292 15.4.6 CANopen-Protokoll ..................................................................................... 294 15.4.7 CAN-Bus mit Laptop und mehreren Sensoren ........................................... 297 15.5 Der byte-serielle GPIB-Bus ........................................................................................... 299 15.5.1 Installierung der Software ............................................................................ 300 15.5.2 Entwicklung eines VI .................................................................................... 302 ...........................................................................................................................

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zentral- u 2009.07.31 21:42:39 +02'00'

Inhalt

14

16

Messdaten-Elngabef-Ausgabe 304 16.1 Datenerfassungskarten .................................................................................................. 304 16.2 Allgemeines ................................................................................................................... 305 16.2.1 Treiber, Measurement and Automation Explorer (MAX) ......................... 305 16.2.2 Physikalische und virtuelle Kanäle,Task .................................................... 31I 16.2.3 Programmierung von Datenerfassungs-VIs, simulierte Geräte ................. 312 16.2.4 Programmierung von VIs zur Analogausgabe ............................................. 317 16.2.5 Programmierung von VIs zum Digital-IfO ................................................. 318 16.2.6 Programmierung mit Hilfe des DAQ-Assistenten ...................................... 318 16.2.7 Programmatische Task-Erstellung .............................................................. 320 16.3 USB-GerätNI USB-6251 ............................................................................................... 321 16.3.1 Begriffe 'differentiell','RSE' und 'NRSE' ...................................................... 321 16.3.2 Zwei Analogwerte mit derNIUSB-6521 lesen ............................................ 323 16.3.3 Triggern mit NI USB-6521 ........................................................................... 324 16.3.4 Streaming mitNIUSB-6521 ......................................................................... 325 16.4 Ältere NI-Karte PCI-MIO-16E-4 .................................................................................. 331 16.5 TEDS 338 16.6 IVI-GerätNIUSB-513 .................................................................................................. 343 .................................................................. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Tell IV: Fortgeschrittene Techniken

347

17

Professionelle Programmentwicklung 348 17.1 Sequenzstruktur ............................................................................................................ 348 17.2 Zustandsautomaten ....................................................................................................... 349 17.2.1 Notation für Zustandsautomaten ................................................................ 350 17.2.2 Umsetzung Zustandsdiagramm 7 LabVlEW-Programm ......................... 351 17.2.2.1 Strings für die Zustandsauswahl ................................................................... 352 17.2.2.2 Enum für die Zustandsauswahl .................................................................... 354 17.2.2.3 Verwendung von Cd-Elementen bei der Enum-Programmierung ........... 355 17.3 Münzautomat ................................................... ............................................................ 357 17.4 Münzautomat mit Queues und Ereignisstrukturen ..................................................... 366 17.5 Programmierhilfen ........................................................................................................ 370 17.5.1 Arbeiten mit vorgefertigten Strukturen (Templates) .................................. 370 17.5.2 Beurteilung Programmeffizienz und geeignete Werkzeuge ....................... 371

374 Objektorientierte Programmierung 18.1 Warum objektorientiert? .............................................................................................. 374 18.2 Erstes Beispiel zur objektorientierten Programmierung ............................................. 377 18.2.1 Bildung einer Klasse ...................................................................................... 377 18.2.2 Private Eigenschaften der Klasse .................................................................. 378 18.2.3 Methoden der Klasse ..................................................................................... 379 18.3 Weitere Beispiele zur OOP ............................................................................................ 383 18.3.1 Vererbung ...................................................................................................... 383 18.3.2 Polymorphie .................................................................................................. 386 18.3.3 Modulaustausch ............................................................................................ 390 18.4 Schutz einer Klassenbibliothek .................................................................................... 398

18

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427d592981cf089d91b1gecaOOaO. Zentral- u 2009.07.31 21:42:39 +02'00'

Inhalt

15

19

LabVIEW: Tabellenkalkulation, Datenbanken 402 19.1 Schreib-/Lesebefehle zur Tabellenkalkulation 402 19.2 Allgemeines über ActiveX ............................ 405 19.2.1 ActiveX-Container in LabVIEW ............................. 405 19.2.2 ActiveX in LabVIEW zur Steuerung von Anwendungen 408 19.3 Beispiele zur Anwendung auf Exce1 408 19.3.1 Öffnen und Schlei ßen von Excel ................. 409 19.3.2 Sichtbarmachen einer Exce1-Tabelle ....... 410 19.3.3 Eintragen von Daten in eine Excel- Tabelle ....412 19.3.4 Verwendung vonSubVIs .............. 412 19.3.5 Geschwindigkeit der Datenspeicherung 415 19.3.6 Erstellen von Makros zumUmwandeln einer Tabelle in eine Grafik ..... 416 19.3.7 Aufruf von Makros in LabVIEW mit Hilfe von ActiveX .. 419 Erhöhung der Geschwindigkeit 421 19.3.8 19.3.9 Schreiben mehrerer Dateien 424 19.4 Microsoft-Datenbank Access ... 428 19.4.1 Einführung ............. 428 19.4.2 Verbindung mit der Datenbank .............429 19.4.3 SQL 431 19.4.4 Verwendung vonSubVIs ..............433 ............................................................

................................................................

....................................

...........................

.............................................................................

.................................................

....................................................

.............................................

...............................................................

.....................................................

...

..........................

...................................................................

........................................................................

....................................................................................

.......................................................................................

.....................................................

................................................................................................................

...............................................................

20

Internet, Server und Cllent 434 20.1 Allgemeine Bemerkungen zum Internet 434 20.1.1 Ethernet .........................................................................................................434 20.1.2 Ethernet-Karten,MAC- und IP-Adresse ................435 20.1.3 TCP/IP-Protokoll .......................................... 435 20.2 Einfaches LabVIEW-Beispiel: Ping 436 ......................................................... 438 20.3 Programmieren mit DataSocket 20.4 Programmieren mit TCP/IP .......................................................................................... 441 20.4.1 Server und Client........... 441 20.4.2 Beispiel für die übertragung von Sinusdaten über TCP/IP ............... 441 20.5 TCP/IP-Server und mehrere Clients ............................................................................. 444 20.5.1 Voruberlegungen ........................................................................... 444 20.5.2 TCP/IP-SubVls .............................. 445 20.5.3 Schreiben über TCP/IP .. 446 Lesen von TCP/IP 446 20.5.4 20.5.5 Anwendungsbezogene Fehlerbehandlung ................................... 447 20.6 Server und Client als Zustandsautomaten 447 20.7 ClientJ Server-Anwendung ........................................................................................ 450 20.7.1 Client-Anwendung ...................................................................... 450 20.7.2 Server mit einem Client 455 20.7.3 Server mit mehreren Clients ......................................................................... 456 ......................................................................

....................................

...............................................

..............................................................................

..........................

................................................................................

........

...............

..............................................................

..............................................................................

.........................................................................................

...............

...................................................................

...

................

................................................................................

21

Compact RIO-System und FPGA 21.1 Definition 21.2 Installation

461

......................................................................................................................

.....................................................................................................................

461 463

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zentral- u 2009_07_31 21:42:39 +02'00'

Inhalt

16 21.3 Programmierbeispiele 21.3.1 Zusammenarbeit cRIO-9012 mit einem Laptop 21.3.2 FPGA-Anwendung aufdem cRIO-9012 mit Laptopunterstützung 21.3.3 FPGA-Anwendung aufdem cRIO-9012 ohne Laptopunterstützung 21.4 Eine regelungstechnische Anwendung

467 .467 472 480 485

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ...........................

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ....

.

.........

.

......

........................................................................

Literatur

493

Index

494

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zenlral- u 2009.07.31 21:42:39 +02'00'

Teil I: Grundlagen des Programmierens in LabVIEW

Systematische Einführung in die wichtigsten Konzepte von LabVIEW. Das umfasst: Installation und Aufruf von LabVIEW, grundlegende Arbeitsmittel wie Frontpanel, Diagramm, Paletten für Eingabe!Ausgabe und ihre Anpassung an Benutzerwünsche, ferner Bediene1emente und Funktionen, Datentypen, das Erstellen von Unterprogrammen, Visuali­ sierungste

Unb"ndnnl I vi Frontpdnel '

,(

, 0

Bild 1.1 1 Panel mit Bedienelement für die Variable a

5. In gleicher Weise geht man mit der Variablen b um. 6. Dagegen muss man c als Ausgabevariable (Anzeigeelement), deren Wert nicht vom An­ wender gewählt, sondern vom labVIEW-Programm errechnet wird, etwas anders be­ handeln. Man erhält sie im Untermenü der Palette von Bild 1.7 unter 'Numerisch' 'Numerische Ausgabe' (oberste Zei l e, zweites Element von links). Bild 1.12 zeigt das Er­ gebnis.

I> Un�nannt l.v,Fr""tpan"l ·

I

Qat.,; �en /!(tlei9on E!rOje!o:t flushhen I!l� Eenster tlh �

11

I:!p: � .

Ic' :0;;. :11:1.

('1.

,0 b , 0

Bild 1.12 Panel mit Symbolen für zwei Eingabevariablen a und b sowie die Ausgabevariable C == Q +b

7. Haben Sie versehentlich ein falsches Symbol platziert, müssen Sie es löschen. Dazu das rechteckige FeJd in der ersten Zeile der Werkzeugpaleue anklicken und auf die Farbe Grün stellen, was Automatikbetrieb bedeutet. Je nach Anwendung wählt nun LabVIEW automatisch aus den nachstehenden Werkzeug-Icons dasjenige, das der jeweiligen Auf­

gabe entspricht. In diesem Fall das falsch gesetzte Icon mit ständig gedrückter linker Maustaste umfahren. Es bildet sich ein gestricheltes Rechteck, dessen Ränder blinken. Nun mit der -Taste löschen. Bemerkt man den Fehler unmittelbar nach dem Set-

Ausleihe: 31 _07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427d592981cf089d91b1gecaOOaO, Zentral- u 2009_07_31 21 :42:39 +02'00'

1

28

Was ist LabVIEW?

zen eines falschen kons, kann man diesen Schritt auch mit 'Bearbeiten' - 'Rückgängig. . . '

oder mit + korrigieren. Zurück zum alten Zustand mit 'Bearbeiten' - 'Wie­ derherstellen. . . ' oder mit ++.

8. Verknüpfen der Eingabe- mit der Ausgabevariablen über die gewünschte Funktion 'Addieren'. Das geschieht im Diagramm. Zunächst wählen Sie in der Funktionenpalette von Bild 1.8 das Icon 'Numerisch' links in der zweiten Zeile. Die Unterpalette zeigt Sym­ bole, wie man sie von elektrischen Schaltplänen her kennt. Hier ist der Plusoperator links oben anzuklieken und ins Diagramm zu ziehen, siehe Bi l d 1.15. I> lk>ben.n."

v.Blockd••g,amm*

Bild 1.13 Diagramm mit Additionsfunktion in der Mitte 9. Nun sind die kons noch mit Drähten zu verbinden, wie schon in Bild 1.2 angedeutet wurde. Dazu dient die Drahtrolle in der Werkzeugpalette. Entweder wählt man diese Rolle durch Mausklick oder man verlässt sich auf den Automatik-Modus der Werkzeug­ palette. Die Drahtrolle wird wirksam, wenn man sich entweder einem Terminal oder ei­ ner Funktion nähert. Jedes Icon streckt dann kleine Fühler aus, die so genannten 'Tip strips'. Berührt man mit dem Mauszeiger einen dieser Fühler, verändert er seine Form und wird zu einer kleinen Drahtrolle. Drückt man nun dort die inke l Maustaste, zieht man eine gestrichelte Linie hinter dem Mauszeiger her, mit der man die Icons verbinden kann. Die Verbindung ist hergestellt, sobald man an einem der Fühler des zweiten Icons die Maustaste loslässt. Die Wegeführung des Drahtes ist ebenfalls zu beeinflussen, indem man an beliebigen Zwischenpunkten die Maus kurz loslässt. Dieser Punkt ist dann fixiert,

und der Programmierer kann die Drahtrichtung ändern. Das Endergebnis ist in Bild 1.14 zu sehen.

10. Falsche Verbindungsleitungen kann man löschen, indem man sie hinreichend weit von den Tip strips entfernt anklickt und dann auf drückt. Dabei wird meist nur ein Tei l der Verbindungslinie gelöscht. Alle restlichen Teile beseitigt man mit dem 5hortcut +, Das ist einfacher, als alle Teillinien mit zu löschen.

'Lli!I:iI

J

� Bild 1.14 Diagramm des fertigen Programms zur Berechnung von c=a+b

Ausleihe: 31 _07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zenlral- u 2009_07_31 21 :42:39 +02'00'

1.4

Eitz/ihi rendes Beispiel

1.4.2

29

Speicherung als Programm Add.vi

Das fertige Programm sollte jetzt unter einem einprägsamen Namen auf der Festplatte gespeichert werden. Z.B. könnte man unser Programm mit 'Datei' - 'Speichern unter.. .' und dem Namen 'Add.vi' ablegen. Die Erweiterung 'vi' ist erforderlich, wenn man das Programm später aus einem Ordner heraus mit Mausdoppelklick aufrufen möchte.

1.4.3

Starten und Stoppen von Add.vi

Das Programm kann in den Hauptspeicher geladen werden: •

durch Doppelklick aufseinen Namen in dem Ordner, n i dem es gespeichert ist,

•

vom LabVIEW-Startfenster aus mit 'Öffnen. . . ' und Pfadwahl,

•

von einem anderen, bereits geöffneten VI aus mit 'Datei' - 'Öffnen. . . ' und Pfadwahl.

Sobald Add.vi geladen ist, kann man es vom Panel aus aufdreierlei Wegen starten: •

Durch Anklicken des in der Menüleiste ganz links stehenden pfei l artigen feons. Dann läuft das Programm genau einmal und stoppt dann.

•

Durch Anklicken von 'Ausführen' - 'Starten'. Gleiche Wirkung wie oben.

•

Durch Anklicken des zweiten feons inks l oben, das zwei verschlungene Pfeile zeigt. Jetzt

wird das Programm wiederholt ausgeführt, und zwar SO lange, bis es der Anwender mit Hilfe des dritten feons mit dem roten Stoppzeichen anhält.

Bi l d 1.15 zeigt das Programm Add.vi im Modus 'Wiederholt ausführen', wobei der Anwen­ der als Eingabedaten die Werte a = 7 und b =

-

3 eingestellt hatte. Er kann diese Werte wäh­

rend des Programmlaufs beliebig verändern. Dazu klickt man das gewünschte Eingabefens­ ter an und ändert den Variablenwert entweder mit den Aufwärts-Abwärts-Pfeilen oder man klickt direkt ins Fenster und gibt den Wert über die Tastatur ein. Solange im letzteren Fall die Eingabe noch nicht abgeschlossen ist, erscheint in der Symbol­ leiste links vom Startsymbol ein weiteres lcon mit einem kleinen Haken. Sobald man diesen Haken mit der Maus anklickt, betrachtet LabVIEW die Eingabe als beendet und rechnet von dem Moment an mit dem neuen Variablenwert. Statt den Haken anzuklicken, kann man aber einfacher mit der Maus unmittelbar neben das Eingabefenster klicken oder die Return­ taste betätigen. Auch in diesem Fall verschwindet das feon mit dem Haken. P Add ",

j :

• ,

c-.+b

�

b

•

-3

Bild 1.15 Panel im Modus 'Wiederholt ausführen'

Ausleihe: 31 .07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427d592981cf089d91b1gecaOOaO. Zenlral- u 2009.07.31 21 :42:39 +02'00'

1

30

Was istLabVIEW?

Fehlersuche In Add.vl {Debugging)

1.4.4

Die Fehlersuche wäre hier nicht nötig. Das Programm ist zu einfach. Doch lässt sich das Prinzip gut erklären: Zum Debuggen, d.h. Fehler suchen, geht man ins Diagramm und klickt

auf das Icon mit der Glühlampe (fünftes kon von links). Die Lampe färbt sich dann gelb. Ein

erneuter Mausklick macht sie wieder weiß. Im gelben Zustand verzögert die Lampe den Programmlauf, so dass man die Datenströme mit bloßem Auge verfolgen kann. Dazu zeigt Bi l d 1.16 einen während des Debuggens aufgenommenen Schnappschuss. Um den Ablauf noch genauer verfolgen zu können, klickt man auf das vierte Icon n i der Symbolleiste. Damit wird eine Pause erzwungen. Danach kann man das Programm mit der pfeiltaste zwei Käst­ chen rechts von der Glühlampe in Einzelschritten ausführen. t> Addv, Blockd,agramrn

Bild 1.16 Debuggen im Modus 'Wiederholt ausführen' während der Berechnung von c == o+b

Die zwei zusätzlichen Pfeiltasten dienen zum überspringen von Unterprogrammen bzw. zum Verlassen des VI. Im Beispiel von Bild 1.16 sieht man zwei kleine Kugeln, die an den Terminals für a und b starten und nach rechts laufen. Sie repräsentieren die Datenströme. Im Moment befinden sie sich innerhalb des Additionssymbols. Die Momentanwerte von a und

b werden ebenfalls angezeigt. Das Ergebnis c = 4.00 erscheint einen Moment später rechts vom Additionssymbol!

Ausproblerenl

IAufgabe 1.1

Schreiben Sie ein neues LabVIEW-Programm, das zwei Zahlen x und y einliest, die Er­

gebnisse u, v und w nach den Formeln

u = x +y, v =x - y

und

w = x·y

berechnet und diese auf dem Panel anzeigt. Starten Sie zur übung ganz von vorn mit dem Aufrufvon LabVIEW.

IAufgabe 1.2

Lassen Sie das Programm im Modus 'Wiederholt ausführen' laufen. Schalten Sie den Debug-Modus ein (Lampe im Diagramm ist gelb gefärbt) und beobachten Sie, wie die Werte

u, v, w der Reihe nach gebildet werden. Welche Variable wird zuerst berechnet,

weJche als zweite, weJche zuletzt?

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zentral- u 2009_07_31 21:42:39 +02'00'

1.6

Grundlegende Konzepte von LabVIEW

1 .5

31

Beispiel für eine Grafik in LabVIEW

Das bisherige Beispiel der Addition ist nicht sehr überzeugend, wenn es darum geht, die Leistungsfähigkeit von LabVIEW zu zeigen. Deshalb ein weiteres Beispiel, das erkennen ässt, l mit wie wenig Aufwand eine grafische Ausgabe programmiert werden kann. Bild 1 . 1 7 und Bild 1 . 1 8 stellen Panel und Diagramm eines VI dar, das Sinuskurven beliebiger Frequenz erzeugt und in einem 'Signalverlaufs-Graphen' anzeigt. Einzelheiten zur Programmierung werden später behandelt. " ,

Bild 1.17 Panel zur Anzeige einer $inusfunktion der Frequenz 3 Hz

Bild 1.18 Diagramm zur Bildung und Anzeige einer $inusfunktion variabler Frequenz in Bild 1.17

1 .6

Grundlegende Konzepte von LabVIEW

Die Beispielaufgaben im vorigen Abschnitt verwiesen bereits aufein wichtiges Konzept von LabVIEW, nämlich aufdas Programmieren in den zwei Fenstern (Front-)Panel und (Block-) Diagramm. Im Folgenden geben wir eine kurze übersicht über die wichtigsten Konzepte, die man beim Programmieren mit LabVIEW ist der Literatur

zu

zu

beachten hat. Eine genauere Beschreibung

entnehmen. Hier ist 'Getting Started with LabVIEW' Version 8.0 von

National Instruments zu empfehlen (siehe dazu die Literatur sowie die Links im Internet unter http://geme-labview.de).

1.6.1

Frontpanel

Aufdem Frontpane1, kürzer Panel, sind vor allem zu platzieren: •

(Bedien-)Elemente zur Simulation von Knöpfen, Schaltern, Tastaturen,

•

(Anzeige-)Elemente zur Simulation von Manometern, grafischen Anzeigen und dgl.,

•

Elemente zur Kommentierung und Dekoration.

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zentral- u 2009.07.31 21:42:39 +02'00'

1

32

1.6.2 Das

Was ist LabVIEW?

Blockdiagramm

Blockdiagramm, kürzer Diagramm, enthält den Quellcode eines LabVIEW­

Programms n i grafischer Form, niedergelegt in der Programmiersprache G. Die folgenden Begriffe sind wichtig: •

Knoten,

•

Anschlüsse (auch Terminals genannt),

•

Verbindungslinien oder 'Drähte'.

Knoten Sie sind ausführende Elemente eines LabVIEW-Programms, vergleichbar den Operatoren, Anweisungen, Funktionen in herkömmlichen Programmiersprachen wie C und C++. BeispieJ: der Additionsoperator in LabVIEW. Dargestellt wird er durch ein Dreieck mit zwei Eingängen und einem Ausgang, das ein '+'-Symbol zeigt, siehe Bild 1.14. Anschlüsse (Terminals) Anschlüsse sind als Dateneingänge und -ausgänge den Bedien- und Anzeigeelementen auf dem PaneJ zugeordnet. Wenn man sie löscht, zerstört man folglich gleichzeitig das zugehöri­ ge Element auf dem Panel und umgekehrt. Entsprechend entsteht automatisch ein An­ schluss, wenn man ein Bedien- oder Anzeigeelement auf dem PaneJ platziert. Allgemeiner gi l t: Anschlüsse sind Punkte m i Diagramm, an die man Verbindungslinien oder 'Drähte' anheften kann. In diesem Sinne kann auch eine Konstante als Anschluss interpre­ tiert werden. Daher gi l t der Merksatz: Anschlüsse dienen zur Versorgung von Knoten mit Daten und zur Weiterleitung der Ergebnisse der Knoten. Verbindungslinien Verbindungslinien sind Datenpfade, die von einer 'Quelle' kommen (z.B. Eingabeterminal, verbunden mit einem Bedienelement) und mit einer oder mehreren 'Senken' (z.B. Ausgabe­ terminal, verknüpft mit einem Anzeigeelement) verbunden sind. Abhängig vom Datentyp haben die Verbindungslinien n i LabVIEW verschiedene Farben und Stärken. Ein Knoten wird genau dann ausgeführt, wenn alle verdrahteten Eingangsanschlüsse mit Daten versorgt sind. Danach versorgt er alle seine Ausgangsanschlüsse mit Daten. Letzteres hat eine Konsequenz, die n i konventionellen Programmiersprachen unbekannt ist. Achtung: Sofern keine Datenabhängigkeit besteht, werden alle Knoten in einem Lab­

VIEW-Programm quasisimu1tan ausgeführt, es sei denn, der Programmierer trifft spe­ zielle Vorkehrungen dagegen.

Der Abschluss der Ausführung verschiedener Knoten ist dem Anwender in der Regel nicht bekannt. Er hängt von der Reihenfolge der Konstruktion des LabVIEW-Programms ab. Man

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zentral- u 2009.07.31 21:42:39 +02'00'

1.7

Rezepte

33

kann daher bei Aufgabe 1.2 beobachten, dass je nach Konstruktionsreihenfolge des VI manchmal zuerst die Addition ausgeführt wird, dann die Subtraktion und dann die Multi­ plikation. Bei anderer Entstehungsgeschichte des Programms wird zuerst multipliziert, dann

addiert usw. Beim Debugging kann man das gut beobachten. Versuchen Sie es selbst!

1 .7

Rezepte

LabVIEW starten, VI holen, programmieren und speichern I. Startmenü öffnen

LabVIEW-lcon auf Desktop mit linker Maustaste zweimal anklicken oder aufrufen mit: 'Programme' - 'National Instruments LabVIEW. . . '

2. Neues VI anlegen

Im Startfenster nach Bild 1.3 (zweites Startfenster, das dem ersten automatisch folgt) 'Neu' - 'Leeres VI' anklicken. Man erhält ein leeres Panel und ein leeres Diagramm.

3. Vorhandenes VI holen

Wenn Startfenstervon LabVIEW bereits vorhanden; 'öff­ nen', das VI suchen und Doppdklick mit linker Maustaste aufdasgewünschte VI. Wenn LabVIEW noch nicht geöffnet, vom Datei-manager aus 'Datei' - 'Öffnen' und weiter wie oben.

4. VI speichern

a) Wenn das VI unbenannt ist: im Frontpanel oder Block­ diagramm 'Datei' - 'Speichern', geeigneten Ordner suchen, Namen eintragen und speichern.

b) Wenn das VI schon einen Namen hat (z.B. Add.vi); im Panel oder Diagramm 'Datei' - 'Speichern'.

5. Bedienelement oder Anzeige­

element aufdas Panel bringen

a) Beim ersten Mal: Mit rechter Maus r i gendwo aufdie freie Fliehe des Panels klicken. Man erhält die Palette 'Elemente' (Bild 1.7). Dort geeignetes Element aussuchen. Mit ge­ drückter linker Maustaste auf das Panel ziehen. b) Später. Nur noch rechts auffreie Panelßäche klicken. Die zuletzt verwendete Palette erscheint dann automatisch. Weiter wie oben.

Im Diagramm wird automatisch jeweils das entsprechende

Terminal gebildet.

6.

Knoten auf das Diagramm brin­

gen (OperalOren wie '+', '-' usw.)

7. Element aufPanel oder Diagramm löschen

Sinngemäß wie unter Punkt 5. Nur ist hier mit der rechten

Maustaste auf eine leere Stelle im Diagramm zu klicken. Man erhält die Palette 'Funktionen' (Bild

1.8).

Werkzeugpa.lette auf'Automatische Werkzeugwabl' (Anzei­ ge grün) stellen, zu löschendes EJement rechteckfönnig umfahren und mit löschen. Siehe auch 'Allgemeine Editieroperationen', Punkt 14, auf der nächsten Seite!

8.

Tenninals und Knoten verbinden

Mit linkerMaustaste an die 'Fühler' oder 'Tip strips' der zu verbindenden EJemente fahren. Der Mauszeiger erhält die Fonn einer kleinen Drahtrolle. Linksklick heftet die gestri­ chelte Verbindungslinie an.

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zenlral- u 2009_07_31 21:42:39 +02'00'

1

34

1 .8

Was istLabVIEW?

Shortcuts

Die Rezepte in Abschnitt 1.7 bezogen sich alle auf die Verwendung der Maus, mit der Menüs geöffnet und Objekte aufs Panel oder Diagramm gezogen wurden. Manche Benutzer ziehen die Verwendung von so genannten Shortcuts vor. Darunter ver­ steht man das gleichzeitige Drücken von zwei, manchmal auch drei Tasten. Einige häufig benutzte Shortcuts und ihre Wirkung werden nachstehend zusammengestellt. Dabei bedeu­ tet Betätigung der Steuerungstaste mit der Aufschrift 'Strg', die Betätigung der Taste mit der Aufschrift 'E' usw. Das '+'-Zeichen bedeutet: Tasten gleichzeitig drücken. Die Klammerzeichen und das '+' werden nicht mit eingegeben.

Manipulation von Fenstern I. +

2. +

m Wechsel zwischen Panel und Diagram

öffnet ein Suchfenster, in dem man nach Objekten (z.B.

Plusoperator) oder nach Texten suchen kann 3. +

Sucht im VI nach dem nächsten Auftreten eines mit +

gefundenen Objektes. Hat ein VI z.B. an 10 verschiedenen Stellen einen Plusope:rator, kann man diese einen nach dem anderen aufsuchen

4. +

Schaltet Kontext-Hilfe an oder aus

5. +

öffnet Fehlerliste

6. +

Ordnet Panel und Diagramm nebeneinander an

Dateioperationen 7. +

öffnet ein neues leeres VI

8. +

Schließt ein VI

9. +

Speichert ein VI aufFestplatte (häufig anwenden!)

Allgemeine Edltleroperatlonen 10. + 11. ++ 12. +

Nimmt letzten Schritt beim Programmieren zurück Hebt das letzte + auf

Schneidet ein selektiertes Objekt aus (und speichert es intern)

13. +

Kopiert das selektierte Objekt

14. +

Ausgeschnittenes oder kopiertes Objekt einfilgen

14. +

Entfernt alle gestrichelten, d.h. ungUltigen Verbindungsli­ nien im Diagramm

Eine vollständige übersicht findet man im LabVIEW-Startfenster oder von jedem VI aus unter 'Werkzeuge' -'Optionen' - 'Menü-Verknüpfungen'. Dort kann man auch die Vorein­ stellungen ändern und sich Shortcuts nach eigenem Geschmack zulegen.

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zenlral- u 2009_07_31 21:42:39 +02'00'

2

Einstellungen, Sprachenwahl, Paletten

Lernziele 1. Einige wichtige Voreinstellungen für die Gestaltung von Panel und Diagramm kennen und nach persönlichem Bedarfverändern können.

2. Sich auch in englischsprachigen Versionen von LabVIEW zurechtfinden. 3. Mehr Details über Werkzeug-, Funktionen- und Elemente-Palette kennen. 4. Palettenansicht an Benutzerwünsche anpassen können. Die Abschnitte 2.1 und 2.2 können von eiligen Lesern übersprungen werden.

2.1

Einstellungen

Das Beispiel in Kapitel 1 wurde unter einer Reihe von Bedingungen entwickelt, die dem Anwendet zunächst vermutlich unbewusst geblieben sind. Sie betreffen das Erscheinungs­ bild der Tenninals als quadratische Symbole oder 'Icons' im Diagramm, das Raster auf dem Panel während der Erstellung der Bedienoberfläche und vieles andere mehr. Die Parameter dafür sind voreingestellt ('Defaultwerte'), doch kann der Anwender sie verändern. Dazu gibt es zwei Wahlmöglichkeiten:

1. 'Werkzeuge' - 'Optionen. . .' (Einstellungen von LabVIEW) 2. 'Datei' - 'VI-Einstellungen. . . ' (Einstellungen des aktuellen VI) Wir befassen uns hier mit der ersten Wahlmöglichkeit. Öffnet man vom Panel oder vom Diagramm aus das Optionsangebot, erhält man (voreingestellt) eine Ansicht, wie sie Bild 2.1 zeigt. Der Titel lautet:

2.1.1

'Neu und geändert in 8.x'

Wählt man hier in der linken Spalte per Mausklick z.B. die Option 'Blockdiagramm', erhält man rechts eine übersicht der Optionen zur Einstellung des Blockdiagramms, siehe Bild

2.3. Dort sieht man rechts n i der Mitte einen Haken vor der Eintragung 'Frontpanel­ Elemente als Symbole darstellen'. Mit Symbol ist hier das kleine quadratische lcon gemeint, das wir schon aus dem Diagramm in Bi l d 1.10 vom letzten Kapitel her kennen. Man kann diese Symbole in kleinere Rechtecke umwandeln, indem man individuell für jedes Symbol mit Rechtsmausklick das Kontextmenü aufruft und in der vorletzten Zeile 'Als Symbol an­ zeigen' den Haken entfernt. So geschah es zum Beispiel in Bi l d 1.20 bei den Tenninals für 'Frequenz' und 'Signalverlaufs-Graph'. Will man sich diesen Aufwand für jedes einzelne lcon ersparen, entfernt man einfach generell den Haken für 'Werkzeuge' - 'Optionen. . .' - 'Neu

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zenlral- u 2009_07_31 21:42:39 +02'00'

2

36

Einstellungen, Sprachenwahl, Paletten

und geändert in 8.x' - 'Blockdiagramm' - 'Frontpanel-Elemente als Symbole darstellen'. Das

kann nützlich sein, wenn der Platz im Diagramm eng wird. Bereits gesetzte Terminals sind von der generellen Umstellung nicht betroffen. Sie behalten ihr ursprüngliches Aussehen. I>

Optlon�n

Fron'�

�-�

A"",""'''''9bnsVef�ollXlg FeIlIef>:Oe

..,..,

5c",n

",�

Vef�",ie Mern-Vekcoietffi b« EIemed«1 on '''�>t''«1 Posborlffi e;n r Be5cr.ttlSJ9ffi >tioridarOp-Yerte Besc"'ttlX"lQSl� 17 Front�e oIs Syrrbole dat-stelef1

17 Atrix .. ,

liste & Tobele

�

R..... &Erun

""�

� � � �

-"

�isch

Ccrl_

� lIfJ '" � � '""

str.... &f'fod

"'"

'tc

DD v",,,,,,,, lXld KI", C>e+o.Ctem

• K�>isch • Ex>USwi!hletre-., 0-=00.... Ff..o=""."

I

�

[n'_'''�

o""m."on. ..

Bild 2,11 Unterpalette 'Datei-VO' in der Funktionenpalette (Zeile 2 Mitte), Rubrik 'Programmierung'

-_.

""•. ,m",... __""

-"","",... ""0' ood"... '�,,""on

� � !2l [l[l em �

-,""""... D""9ö/1or, -",-

,--

"O�.O '.§

""0''''' Sequenz Ze,tverbrauchOv, Blockd",gramm "

1illM--t[ J8l0kl-------r, kl� -'----' J

�

Bild 3.1 Erster Schritt zur Pro­

grammentwicklung für die Mes­ sung des Zeitbedarfs bei der Berechnung einer Reihe aus fünf Summanden

Die Konstante 1,00 erhält man aus 'Funktionen' - 'Programmierung' - 'Numerisch' als 'Nu­ merische Konstante' links in der vorletzten Zeile. Das ist eine Integerzahl, die man wegen der zu berechnenden Brüche der Einheitlichkeit halber n i DBL umwandeln sollte. Dazu ist das Kontextmenü mit der rechten Maustaste aufzurufen und im Untermenü 'Darstellung' auf 'DBL' zu klicken. Ferner wurden im Kontextmenü 'Format & Genauigkeit...' auf 'Fließ­

komma' und 2 KommasteIlen umgestellt sowie der Haken vor 'Abschießende l Nullen unter­ drücken' entfernt. Die 5 Summanden werden mit der Funktion für Mehrfacharithmetik (zweite Zeile von 'Numerisch', zweites Element von rechts) addiert. Diese ist hier auf 5 Käst­ chen aufzuziehen. Anschließend folgen ein Rechtsmausklick auf den Ausgang dieses Opera­ tors und die Auswahl von 'Erstellen' - 'Anzeigeelement'. Das Label des so gebildeten Ele­ ments wurde in 'Summe' umbenannt. Für die Zeitberechnung nutzt man eine Funktion, welche die Millisekunden zählt, die seit dem Einschalten des Rechners vergangen sind. Sie steht unter 'Funktionen' - 'Programmie­ rung' - 'Timing' rechts n i der dritte Zeile und dort ganz links oben. Bezeichnung: 'Timerwert auslesen (ms)'. Die Programmierung der Zeitmessung nach dem Muster von Bi l d 3.2 schlägt fehl! Wegen der Parallelverarbeitung in LabVIEW könnte z.8. zuerst die Endzeit ennittelt

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zenlral- u 2009.07.31 21:42:39 +02'00'

3

52

Programmstrukturen

werden, dann die Anfangszeit und erst danach die Summe. Auch eine andere Abfolge wäre möglich. Sie hängt von der Reihenfolge der Programmierschriue ab, die das fertige Lab­ VIEW-Programm bilden, und ist dem Anwender in der Regel nicht bekannt.

Bild 3.2 Falsche Behandlung der Aufgabe, die Zeit zur Berechnung und Anzeige einer Summe zu ermitteln l d 3.2 ist zwar lauffahig, zeigt aber dieselben Werte für Anfangszeit und Das Programm in Bi Endzeit, wie man Bi l d 3.3 entnimmt.

"""'" 1'.283

1 + 1/2 + 1/3 + 114 + 115

ArI_

'14548180

(lehn i'l 1I15)

Bild 3.3 Anfangszeit und Endzeit sind infolge fehlerhafter Programmierung identisch

Den richtigen Ansatz zeigt das Diagramm in Bild 3.4. Der dreigeteilte Rahmen ist eine Se­ quenz, die man unter 'Funktionen' - 'Programmierung' - 'Strukturen' und dort in der dritten Zeile links als 'Flache Sequenzstruktur' findet. Sie besteht zunächst aus einem einzelnen Rahmen und wird in diesem Fall mit Hilfe des Kontextmenüs und 'Rahmen danach einfügen' auf drei Rahmen erweitert. Diese Rahmen werden zur Laufzeit des Programms stets von links nach rechts abgearbeitet.

Bild 3.4 Richtiger Ansatz zur Zeitmessung: Verwendung einer flachen Sequenz Der Ansatz ist jetzt zwar richtig, doch liest man bedauerlicherweise auf dem Panel nach dem Start des Programms immer noch die gleichen Millisekundenwerte für Anfangszeit und

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zenlral- u 2009_07_31 21:42:39 +02'00'

3.2

Sequenz

53

Endzeit ab, Das ist kein Programmierfehler, sondern liegt einfach an der hohen Leistungsfa­ higkeit von LabVIEW und modernen PCS. Innerhalb einer Millisekunde kann die Reihenbe­ rechnung mehrfach durchgeführt werden. Deshalb erweitern wir das Programm im Vorgriff aufAbschnitt 3.4 um eine For-Schleife, die n-mal durchlaufen wird, siehe Bi l d 3.5.

Bild 3.5 Korrektes Programm zur Zeitmessung Folgende Änderungen wurden vorgenommen: •

Um die Summenberechnung wurde eine For-Schleife gelegt und an das Kästchen links oben mit der Inschrift 'N' ein Bedienelement 'n' per Kontextmenü (mit 'Bedienelement erzeugen') angeschlossen. Man findet die For-Schleife bei 'Funktionen' - 'Programmie­ rung' - 'Strukturen', links oben.

•

Anfangszeit und Endzeit werden nicht mehr angezeigt. Dazu links in der Sequenz einen Rechtsmausklick auf das Tenninal 'Anfangszeit' ausführen und im Kontextmenü 'Anzei­ geelement verbergen' wählen. Entsprechend im Rahmen 2 mit 'Endzeit' verfahren. Natür­ lich hätte man in diesem Beispiel auch gleich die entsprechenden Anzeigeelemente löschen können. Die interessierende Rechenzeit wird als Differenz von Endzeit minus Anfangszeit gebildet.

Man

kann

diese Zeitmessungsaufgabe auch mit Hilfe der platzsparenden gestapelten

Sequenz lösen (LabVIEW-Gurus rümpfen hier allerdings die Nase wegen der 'Verdeckung von Code', siehe dazu Abschnitt 17.1). Das VI dazu ist in Bild 3.6 bis Bild 3.8 dargestellt. Dazu sind folgende weitere Änderungen nötig: •

Die flache Sequenz wird durch eine gestapelte Sequenz ersetzt. Dazu am Rahmen der flachen Sequenz mit Rechtsmausklick Kontextmenü aufrufen und anklicken: 'Durch gestapelte Sequenz ersetzen'. Die drei Rahmen der ursprünglichen Sequenz liegen jetzt Platz sparend übereinander und können über die Selektorbeschriftung am oberen Rand, welche die Nummern 0, I oder 2 anzeigt, mit Hi l fe der kleinen Pfeile rechts und links durchgeblättert werden.

•

Mit Hilfe einer 'Lokalen Sequenzvariablen', die man ebenfalls im Kontextmenü zum Rahmen der Sequenz findet, wird die Anfangszeit im Rahmen 0 in den Rahmen 2 durch­ geschleift (siehe dazu Bild 3.6 und Bild 3.8).

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zenlral- u 2009.07.31 21:42:39 +02'00'

3

54

Programmstrukturen

Bild 3.6 Rahmen 0 der Sequenz: Ermittlung der Anfangszeit und deren Weiter­ leitung Ober eine lokale $equenzvariable (kleines Quadrat unten am Rand) 1 0.. 2

;"" N_ I!� 13

[j]

0-�

�

0-� 0-�0-� ,��

�

Bild 3.7 Rahmen 1 der Sequenz: n-fache Berechnung der fünfgliedrigen Summe und Anzeige der Ergebnisse. Der Anwender muss den Zahlen­ wert von n auf dem Panel einstellen, wie Bild 3.9 zeigt

Bild 3.8 Rahmen 2 der Sequenz: Ermittlung der End­ zeit und Bildung der Differenz­ zeit Ober die im Rahmen 0 festgelegte lokale Sequenz­ variable Bild 3.9 verdeutlicht das Ergebnis nach Ausführung der Rechnung. J>

Sequen2_"e.tvetbtauchZ VI front pan,,1

'"

Bild 3.9 Das Programm braucht für die einmillionen­ fache Berechnung und Ergeb­ nisanzeige der fünfgliedrigen Reihe nur 134 ms

Bild 3.9 zeigt unmittelbar nach dem Laden die Parameter Rechenzeit = Summe = 0 sowie

n = I Mio. Diese Werte wurden nach der Erstellung des Programms zusammen mit diesem gespeichert. Dazu muss man zunächst die Werte n i den drei Feldern eintragen und dann 'Bearbeiten' - 'AktueUe Werte als Standard' wählen. Zuletzt ist das so modifizierte Programm zu speichern. Der Vorteil: Beim späteren Laden des VI von der Festplatte müssen diese Daten nicht erneut eingegeben werden.

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zentral- u 2009_07_31 21:42:39 +02'00'

55

3.2 Sequenz

Merke: In einer Sequenz läuft zuerst Rahmen 0 ab (der Rahmen ganz links in der flachen Sequenz), dann Rahmen I usw. Rahmen 0 übergibt die Steuerung erst dann an Rahmen I, wenn er alle seine Funktionen, die ihrerseits quasiparallel ablaufen, beendet hat. Sinngemäß das Gleiche gilt für die anderen Rahmen.

Merke: Die Datenübergabe zwischen verschiedenen Rahmen einer gestapelten Se­ quenz kann über lokale Sequenzvariablen erfolgen, die man im Kontextmenü des Sequenzrahmens erzeugen kann.

Merke: In Bedien- oder Anzeigeelementen eingetragene Daten kann man zusammen mit dem VI auf Festplatte speichern. Dazu vor dem Speichern 'Bearbeiten' -

'Aktuelle Werte als Standard' klicken (oder selektiv für jedes Element einzeln).

Lokale Variablen Eine weitere Möglichkeit, Daten zwischen den verschiedenen Rahmen einer gestapelten Sequenz auszutauschen, ist die Verwendung von lokalen Variablen. Bild 3.10 zeigt das Dia­

gramm des nochmals modifizierten Zeitmessungsprogramms während seiner Entstehung. 2 0 . .2 ..

'I

-

*" '$@+

1Ies

Addl.Y, Frontpanel

ö

� �

•

7

b

·3

c-a+b •

Bild 3.23 Panel des modifizierten VI aus Bild 3.22 Im übrigen kann man die While-S

ODER (Afray. • .

Iill

"..

IV IV

-." "'"

ZaN nach bo. . •

(Y!J

Bild 4.6 Verschiedene logische Funktionen zur Verknüp­ fung boolescherVariablen. Ferner gibt es in den zwei letzten Zeilen die booleschen Konstanten TRUE und FALSE

FAl.5E D.";j= �lr:... � Bild 5.s

•

•

•

TRUE·Teil des Unterprogramms: Winkel- und Seitenberechnung

Zur Berechnung des Sinus wird eine eingebaute LabVIEW-Funktion verwendet, die unter 'Punktionen' - 'Mathematik' - 'Grund- und Spezialfunktionen' - 'Trigonometrische Funktionen' links oben zu finden ist. Sie benötigt den Winkel im Bogenmaß, deshalb auch die Division 1t!180 m i Diagramm von Bi l d 5.5. Die Berechnung von r ergibt sich aus der Beziehung r= 180-(a+ß), die Berechnung von a und b aus dem Sinussatz für Dreiecke: a

sma

b

Sillb

c

smr

c

smr

Bild 5.6

FAL$E-Teil des Unterprogramms: Fehlermeldung, wenn Winkelsumme a+� lBO"

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427d592981cf089d91b1gecaOOaO, Zentral- u 2009.07.31 21 :42:39 +02'00'

5

96

Unterprogramme

Vorgehen bei der Entwicklung des Drelecks-Unterprogramms 1. Programmieren wie ein gewöhnliches VI, 2. Verknüpfen der Bedien- und Anzeigeelemente auf dem Panel mit dem Anschlussfeld (siehe nachfolgende Bemerkung), 3. Gestaltung des VI-Symbols. Hier: Dreieck.

4. Speichern. Anschließend im Diagramm des aufrufenden Programms platzieren mit

'Funktionen' - 'VI auswählen' (unterste Zeile) und Öffnen des gewünschten VI n i dem Verzeichnis, in dem es zuvor gespeichert wurde. Bemerkungen zu Punkt 2 Klickt man mit der rechten Maustaste aufdas Symbol in der rechten oberen Panel-Ecke eines VI, das so genannte Anschlussfeld. erhält man zunächst das Menü links n i Bild 5.7. _ I:I �

�= " I - :l=I

'

i.OJ

,

,

' A

Bild 5.7 Kantextmenüs für die Festlegung der Anschlüsse

Wählt man dort 'Anschluss anzeigen', bi l det sich eine Unterteilung des Anschlussfelds wie in der rechten Hälfte von Bild 5.7 angedeutet. Die Aufteilung hängt von der Zahl der Bedien­ und Anzeigeelemente ab, die sich auf dem Panel befinden. In unserem Beispie1 mit dem Dreiecks-SubVI erhält man eine Unterteilung gemäß Bi l d 5.8 .

Bild S.8 Anschluss·Symbol, geeignet für drei Bedien-und vier Anzeigeelemente

Die Bediene1emente aufdem Pane1 sind nun eins nach dem anderen mit den anfangs weißen Kästchen des Anschlussfelds zu verbinden. Dazu das Werkzeug 'Verbinden' (Drahtrolle) wählen. Nicht verbundene Anschlüsse bleiben weiß. Verbundene Anschlüsse werden entsprechend ihrem Datentyp farblich dargestellt. Die Anschlussbelegung kann auch nach­ träglich bearbeitet werden. Bemerkungen zu Punkt 3 Im Kontextmenü des Anschlussfeldes 'Symbol bearbeiten .. .' wählen. Man erhält das Stan­ dardsymbol gemäß Bild 5.9, das man mit Hilfe der links davon angebrachten Werkzeuge ändern kann.

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zentral- u 2009_07_31 21 :42:39 +02'00'

5.2 Erstellen von Unterprogrammen

97

eJ 'lW

o

'001«'"

""l:

-,- I

'" ,..ben

..,,,,*,'00""'_"

�.

Bild 5.9 Editor zum Verändern des

Standardsymbols

IAufgabe 5.1 Bauen Sie das in Bild 5.4 bis Bild 5.6 dargestellte Programm von Anfang an neu auf, ebenso das aufrufende Programm von Bild 5.2 und Bild 5.3.

IAufgabe 5.2 Versuchen Sie, das Symbol für das Unterprogramm als kleines Dreieck oder in anderer sinnfaIliger Weise darzustellen.

Merke:

In der Regel kann jedes VI sowohl als Hauptprogramm als auch als Unterpro­ gramm (SubVI) verwendet werden (Ausnahmen bei Referenzen als Eingangs­ variablen, siehe Kapitel 7).

Merke:

Das SubVI unterscheidet sich vom �ewöhnlichen VI im Regelfall durch die

Merke:

Ein SubVI wird im Diagramm des aufrufenden VI platziert mit

Fesdegung von Anschlüssen für Eingabe- und Ausgabedaten im Ansch1ussfeld.

'Funktionen' - 'VI auswählen' (letzte Zeile) und Öffnen unter seinem Namen.

Merke:

Das Symbol eines VI zeigt zunächst das Standardbild (Gerät, Pluszeichen und fortlaufende Nummer). Der Anwender kann es nach eigenen Wünschen um­

gestalten.

5.2.2

Weitere Hinweise für die Erstellung eines Unterprogramms

Das Anschlussfeld kann - unabhängig von der automatischen Systemvorgabe - für jedes Unterprogramm individuell angelegt werden. Die Anzahl der Anschlüsse sollte bereits vor der Verwendung des Unterprogramms ausreichend überlegt werden, denn Änderungen an der Anordnung der Anschlüsse ziehen das Neueinbinden der betroffenen Vb an jeder ver­ wendeten Stelle nach sich. Dies kann man umgehen, n i dem man einige Dummy-Anschlüsse vorsieht, die nicht be1egt sind. Verwendet man diese nachträglich, entfallt das Neueinbinden. LabVIEW bietet eine große Auswahl an vordefinierten Mustern für die Anordnung und

Anzahl der Anschlüsse, siehe Bild 5.10. In der Praxis hat sich das dick umrandete Muster für die meisten Fälle als ausreichend erwiesen. Man wählt es per Kontextmenü mit 'Muster' aus. Ab LabVIEW 8.0 ist es übrigens das Standardanschlussfe1d.

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427d592981cf089d91b1gecaOOaO, Zentral- u 2009.07.31 21 :42:39 +02'00'

5

98

Unterprogramme

Man kann den gewählten Anschluss per Kontextmenü auch nachträglich noch an eigene Bedürfnisse anpassen. Zum Beispiel lassen sich die Anschluss-Symbole n i 90-Grad-Schritten drehen oder horizontal und vertikal kippen. Außerdem kann man zusätzliche Anschlüsse einfügen oder bestehende entfernen.

Bild 5.10 Vordefinierte Auswahl 'Anordnung der AnschlOsse' Mit dem Werkzeug 'Verbinden' (DrahtroUe) wählt man einen freien Anschluss aus und

verknüpft ihn durch einfachen Mausklick mit einem Bedien- oder Anzeigeelement des

Frontpanels. Die umgekehrte Reihenfolge ist auch möglich. Hat man bereits mehrere An­ schlüsse verknüpft, kann die übersicht verloren gehen, weil die Verknüpfung nicht durch Linien markiert wird. Man kann aber durch Anklicken eines bereits eingefärbten Kästchens m i AnschlussfeJd das Panel-Element finden, mit dem es verbunden ist. Dieses Element wird mit einem gestrichelten Rahmen markiert. Will man einen Anschluss anders belegen, muss man vorher die bestehende Verknüpfung trennen. Dazu m i Kontextmenü den Punkt 'Diesen Anschluss trennen' oder 'Alle Anschlüsse trennen' auswählen. Ausgänge werden zur Unter­ scheidung von den Eingängen mit einem dickeren Rahmen im Anschlussfeld dargestellt. Bei der Verknüpfung sollte darauf geachtet werden, dass Eingänge den linken/oberen und Aus­ gänge den rechten/unteren Anschlüssen zugeordnet werden. Dies ist zwar nicht notwendig, verbessert aber die Lesbarkeit des Programms. Im Kontextmenü zu einem Kästchen m i Anschlussfeld findet man bei 'Diese Verbindung ist' drei Kategorien: •

Erforderlich

•

Empfohlen

•

Optional

Erklärt man eine Verbindung für erforderlich, erzwingt man später im aufrufenden Pro­ gramm die Verdrahtung des betreffenden Eingangs. Dies erleichtert die Fehlersuche, da die fehlende Verdrahtung des Eingangs sofort als Fehler angezeigt wird. Jeder Eingang, der für das ordnungsgemäße Funktionieren des Unterprogramms notwendig ist, sollte als 'Erforder­ lich' definiert werden. Das machen z.B. alle LabVIEW-Arrayfunktionen so, die ein Arrar als Eingang benötigen. Für Ausgänge steht diese Einstellung nicht zur Verfügung. Erklärt man eine Verbindung für empfohlen oder optional, kann das aufrufende Programm arbeiten, auch wenn die Anschlüsse fehlen. In diesem Fall werden keine Fehlenneldungen ausgegeben. Für das Bedien- bzw. AnzeigeeJement wird ein vom System festgeJegter Stan­ dardwert eingesetzt. Anzeigeelementen kann man nur eine dieser beiden Möglichkeiten zuordnen.

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427d592981cf089d91b1gecaOOaO, Zentral- u 2009_07_31 21 :42:39 +02'00'

5.2 Erstellen von Unterprogrammen

99

Im Frontpanel kann ein Standardwert für Bedien- und Anzeigeelemente eingegeben und über 'Datenoperationen' - 'Aktuellen Wert als Standard' aus dem Kontextmenü des entspre­ chenden Elements dauerhaft festgelegt werden. Bei 'Empfohlen' und 'Optional' sollte der Standardwert zusätzlich n i der Beschriftung angegeben werden, damit der Anwender des SubVIs informiert ist. Unterprogramme lassen sich auch direkt aus Teilen eines bestehenden LabVIEW­ Programms erstellen. Mit der Maus wird der Teil, der als Unterprogramm gespeichert wer­ den soll, markiert und aus dem Menü des Diagramms die Funktion 'Bearbeiten' - 'SubVI erstellen' aufgerufen. LabVIEW erzeugt automatisch ein neues VI und ersetzt damit den markierten Bereich. Alle Eingänge und Ausgänge werden selbständig ermittelt, als Bedien­

bzw. Anzeigeelemente m i neu erstellten Unterprogramm eingetragen und mit entsprechen­

den Anschlüssen verknüpft. Das Frontpanel lässt sich durch einen Doppelklick anzeigen.

Der Benutzer kann jetzt die Ein- und Ausgänge nach Wunsch beschriften und die Verbind­ ichkeit l (erforderlich, empfohlen, optional) der einzelnen Anschlüsse angeben.

Einstellungen für Programme und Unterprogramme

5.2.3

Für jedes VI lassen sich unterschiedliche Einstellungen wählen. Wir besprechen hier die für die Art der Ausführung und die Darstellung des Frontpanels wichtigsten. Der Dialog wird über 'Datei' - 'VI-Einstellungen.. .' aus dem Menü oder aus dem Kontextmenü des An­ schluss-Symbols des VI mit 'Eigenschaften für VI' geöffnet. In die interessierende Ansicht kann über 'Kategorie' gewechselt werden. Die folgenden Bilder zeigen die Standardeinstel­ lungen für ein neues VI. Diese Einstellungen gelten nur für statische Bindungen. Wird ein SubVI dynamisch einge­ bunden, muss

man

diese Angaben mit Hilfe von Eigenschafts- oder Methodenknoten für

jedes VI einzeln machen.

cp; ':i:= , ---------" ",,"," "'6

C _·POhtrutffiSt'"

J; .1i4'im Ii""",.....-..."

r locd,..""I_' Arpoo ...... ..

8 p" """ 111.......

t,='. v,.v

"'� I"'�I

I

�

I

Bild $.11 Dialog für die Einstellungen des

Frontpanel-Erscheinungsbilds

Bild 5.11 zeigt den Dialog zum Einstellen des Erscheinungsbi l ds des Frontpanels bei der Ausführung des VI. Hier kann zunächst der Fenstertitel eingegeben werden. Alles andere ist voreingestellt. Außer 'Voreinstellung' kann man 'Haupt-Applikationsfenster', 'Dialog' und 'Benutzerdefiniert' wählen. Nur über die Schaltfläche 'Anpassen...' lässt sich das Erschei­ nungsbild nach eigenen Vorstellungen gestalten. Bild 5.12 zeigt die Auswahl, die sich bietet, wenn man von 'Benutzerdefiniert' aus 'Anpassen. . . ' aufruft.

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427d592981cf089d91b1gecaOOaO, Zentral- u 2009.07.31 21 :42:39 +02'00'

100 I>

5 -

F.,n�tere �ubYl flnst�lIung"n

r Frontpanel bern l4>def, eIf-.

r Frontpanel bNn I>drol � r,...

ort.

...

r BfoI l>drol ........ ... u;

I

chIi

Abbrechen

I

...

Bild 5.11 Frontpanel anzeigen fOr lokale

Instanzen

Globale Einstellungen wurden bereits n i Abschnitt 5,2.3 beschrieben. Die Anzeige des Front­ pands lässt sich aber für jedes SubVI auch lokal einstellen, was über das Kontextmenü des im aufrufenden Programm platzierten SubVI-Symbols mit 'SubVI-Einstellungen...' erreicht wird. Diese Option öffnet einen Dialog zur Festlegung der Anzeige des Unterprogramm­ Panels während der Laufzeit. Bild 5.21 zeigt das. Die Wahlmöglichkeiten dort gelten für jeden Aufruf eines statisch gebundenen VIs. Sie überschreiben bei der Aktivierung dessen globale Einstellungen. Frontpanel beim Laden öffnen: Zeigt das SubVI-Frontpanel, sobald dasjenige Programm geladen wird, das es direkt (als Unterprogramm) oder indirekt (als Unter-Unterprogramm) enthält. Das passiert auch, wenn der Programmfluss noch nicht an dieser Stelle angekommen

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zentral- u 2009.07.31 21 :42:39 +02'00'

5

106

Unterprogramme

ist. Haben mehrere Instanzen desseJben VIs diese Option, wird das FrontpaneJ nur einmal geöffnet. Frontpanel beim Aufruf anzeigen: Zeigt das Frontpanel des SubVIs erst an, wenn der Pro­ grammfluss beim Ablauf des aufrufenden Programms an der Stelle angelangt ist, an der das SubVI eingebunden wurde. Ist diese Option aktiviert, lässt sich zusätzlich auswählen, ob das Frontpanel nach Beendigung wieder geschlossen wird. Beide Optionen müssen gesetzt wer­ den, wenn man die Frontpanels von VIs sehen möchte, die als reentrant deklariert wurden, siehe Abschnitt 5.2.3. Bei Aufruf anhalten: Verhindert die Ausführung des Unterprogramms. Der Benutzer muss es manuell starten. Ändert man das Anschlussfeld eines Unterprogramms, kann es sein, dass die Symbole im Diagramm des aufrufenden Programms aufgehellt erscheinen und ein Fehler angezeigt wird. Das ist ein Indiz dafür, dass das Anschlussfeld des Unterprogramms geändert wurde, so dass es nicht mehr zum aufrufenden Programm passt. Das Unterprogramm muss überall, wo es aufgerufen wird, neu eingebunden werden. Dazu kann im Kontextmenü die Aktion 'Mit SubVI neu verbinden' gewählt werden. Tipp: Man kann das umgehen, wenn man vorher ausreichend viele Anschlüsse für eventuelle Erweiterungenvorgesehen hat. Dynamische Bindung

5.3.2

Die dynamische Bindung ist flexibler als die statische. Sie bietet dem Benutzer vor allem die Möglichkeit, ein Unterprogramm erst dann von der Festplatte in den Hauptspeicher zu ho­ len, wenn es gebraucht wird. Das aufrufende Programm wird dadurch schlanker und benö­ tigt weniger Speicherplatz. Unter 'Funktionen' - 'Programmierung' - 'Anwendungssteue­ rung' (vierte Zeile rechts) findet man eine Reihe von Funktionen. Für die dynamische Bindung von VIs sind die Funktionen in Tabelle 5.1 besonders wichtig.

�.

Tabelle 5.1

t" '1ll �" 'I�v�r :

Dynamischer Aufrufvon Unterprogrammen: wichtige Funktionen

Palette 'Anwendungssteuerung' Funktion 'VI-Referenz öffnen'

c�

Funktion 'Referenz schließen'

m '. • [H[J

�

5.3.2.1

Funktion 'Aufruf über Referenz'

VI-Referenz öffnen und schließen

Eine VI-Referenz ist eine Zahl, die das LabVIEW-System einem VI zuordnet, sobald man den Operator 'Funktionen' - 'Programmierung' - 'Anwendungssteuerung' - 'VI-Referenz öffnen' aufruft. Bild 5.22 zeigt die Kontexthilfe zu dieser Funktion.

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zentral- u 2009.07.31 21 :42:39 +02'00'

5.3 Aufrufvon Unterprogrammen Typenbezeichner-VI-ReFnum ("

,

Applik.M:ionsreFerenz (1ok.!1) VI-prad

Fehler (Eingang, kein Fehler)

Passwort ("")

� -- 1'13

-

o�

107

VI-Referenz Fehler (Ausgang)

Bild 5.22 Kontexthilfe zu 'VI-Referenz öffnen' Man kann diese Zahl, die so genannte 'Refnum', auch sichtbar machen, indem man den Ausgang 'VI-Referenz' des Operators auf dem PaneJ ausgibt. Zwar erhält man zunächst nur ein Symbol, doch lässt sich dieses gemäß Bild 5.23 auch n i eine Zahl verwandeJn.

IAufgabe 5.5 Rufen Sie das VI n i Bild 5.23 mehrfach auf. Sie werden sehen, dass bei jedem Aufruf eine andere Referenz-Nummer angezeigt wird. Achtung: Die Funktion 'Aktueller Pfad des VI' kann erst aufgerufen werden, wenn das VI bereits auf Festplatte gespeichert ist! egt den Wert vcn RefI\um I e�sprect.ender Erutelu"lQ

He;c-Zo!hI51

Bild 5.23 VI, das die Referenz-Nummer (RefNum), die ihm selbstvom System zugewiesen wird, auf dem Panel als Hex-Zahl ausgibt

Hinweise •

Das Symbol für den Pfad zum eigenen VI findet sich unter 'Funktionen' - 'Datei-IIO' 'Dateikonstanten' (fünfte Zei l e rechts) unter der Bezeichnung 'Aktueller Pfad des VI' (Mitte zweite Zeile).

•

Das Symbol zur Umwandlung der Referenz-Nummer n i einen Zahlenstring steht unter 'Funktionen' - 'Programmierung' - 'Numerisch' - 'Cluster & Variant '(erste Zei l e rechts) unter der Bezeichnung 'Variant nach String' (fünfte Zei l e links).

•

Die Stringvariable 'Daten-String' auf dem Panel wird zunächst mit 'Normale Anzeige' wiedergegeben, wobei man keine Zahlen erkennen kann. Stellen Sie deshalb bitte im Kontextmenü auf'Hexadezimalanzeige' um.

Lässt man das Programm im Modus 'Wiederholt ausführen' laufen, sieht man, dass in großer Geschwindigkeit ständig Referenz-Nummern produziert werden. Sie sind alle verschieden und werden auch nicht gelöscht, damit immer eine eindeutige Zuordnung zum VI und sei­ nem jeweiligen Aufruf existiert. Das ist bei heutigen pes mit ihrem großen Hauptspeicher kein Problem, wenn man das Programm nur einige Minuten laufen lässt. Bei n i dustriellen Einsätzen mit Laufzeiten von Stunden oder Tagen wird sich jedoch der Rechner 'aufhängen', sobald ihm der Speicherplatz ausgeht. Solche Fehler sind später nur schwer zu finden. Des­ halb muss man jede geöffnete Referenz so bald wie möglich wieder schließen. Dazu verwen­ det man die Funktion n i Bild 5.24.

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zentral- u 2009.07.31 21 :42:39 +02'00'

108 Rererenz Fehler (Eingang, kein Fehler) Bild Sol4

===-rn

5

Unterprogramme

/ru

,." � C

�

Fehler (Ausgang)

Kontexthilfe zu 'Referenz schließen'

Merke: Jede Referenz aufein Objekt ist so bald wie möglichwieder zu schließen, damit bei länger laufenden Programmen ein SpeicherUberlaufdes Rechners vermie­

denwird. Ab LabVIEW 85 können über diese Funktion gleichzeitig mehrere Referenzen geschlossen werden. Sobald man eine Referenz auf ein VI erzeugt hat, kann man mit dieser in vielf aItiger Weise aufdas VI einwirken. Man kann seine Eigenschaften abfragen oder sie ändern. Man kann das VI starten oder stoppen usw. In dieser Einführung müssen wir uns auf einige wenige Mög­ lichkeiten beschränken, die im Folgenden mehr oder weniger rezeptartig dargesteUt werden.

5.3.2.2

Aufruf eines VI über seine Referenz

Eine elegante Methode des dynamischen Aufrufs ist in Bild 5.25 dargestellt. Damit kann man nicht nur ein ganz bestimmtes SubVI aufrufen, sondern jedes beliebige kompatible Unter­ programm. 'KompatibeJ' heißt n i diesem Zusammenhang, dass zwei SubVIs das gleiche Anschlussfeld, die gleiche Zahl, die gleiche Anordnung und den gleichen Typ der Eingabe­ und Ausgabe-Variablen haben. Der Wechsel von einem solchen SubVI zum anderen kann sogar noch während der Laufzeit des aufrufenden VI erfolgen. Die Programmstruktur nach Bild 5.25 wird in folgenden Schritten erstellt:

1. VI-Referenz öffnen und am oberen Eingang 'Typenbezeichner VI-RefNum (nur für Typ)' im Kontextmenü mit 'Erstellen' - 'Konstante' das LabVIEW-Standardsymbol zu­ ordnen. Links am Eingang 'VI-Pfad' nach derselben Methode einen leeren Pfad erzeugen, in den man den Namen des SubVIs schreibt, das aufgerufen werden soll (hier: 'AddString.vi').

2.

Typ der VI-Referenz anpassen, indem man im Kontextmenü zum oben erstellten Lab­ VIEW-Standardsymbol 'VI-Server-Klasse auswählen' - 'Durchsuchen . . . ' aktiviert. Dann wird ein Verzeichnisbaum angezeigt, n i dem man das gewünschte Muster-SubVI sucht und öffnet. Im Beispiel wurde AddString.vi gewählt. Man könnte aber auch SubString.vi nutzen oder jedes andere VI kompatibler Struktur: Ein solches VI hat zwei Eingangsvari­ ablen und eine Ausgangsvariable, alle vom Typ 'String'. Im Symbol, das jetzt erscheint, ist das grafisch angedeutet. Die Farbe entspricht der für den Typ String.

3.

Symbol 'Aufruf über Referenz' im Diagramm setzen und den Ausgang 'VI-Referenz' des links stehenden Symbols mit dem Eingang des neuen Symbols 'Typenbezeichner VI­ RefNum (nur für Typ)' verbinden. Diese Verbindungsinie l ist grün.

4. Eingänge (hier 'a', 'b' und 'c') am Symbol der Funktion 'Aufruf über Referenz' anbringen,

am einfachsten ebenfalls über das Kontextmenü.

5.

'Referenz schließen'-Operator setzen und verbinden.

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zentral- u 2009_07_31 21 :42:39 +02'00'

5.3 Aufrufvon Unterprogrammen

109

6. Die Fehlereingänge und -ausgänge gemäß Bild 5.25 verbinden. Das ist zwar nicht unbe­ dingt notwendig, gehört aber zum guten Programmierstil. Rechts per Kontextmenü ein Symbol für den Fehlerausgang setzen. Auf diese Weise werden Fehler, die irgendwo auf­ treten können, durchgeJeitet und dem Anwender mit einer Nummer angezeigt. 11.D)!m!ische Referenz öffnenl

@. At:lni Cber Referenzl

13. Referenz sdiessenI

Bild 5.25 Beispiel zum dynamischen Aufruf übereine VI-Referenz

Bemerkungen •

Während der Ausführung können Fehler auftreten. Häufig kommt es vor, dass das An­ schlussfeJd des geöffneten Vls nicht mit dem des Typ-Bezeichners übereinstimmt. Das kann geschehen, auch wenn scheinbar beide Anschlussfelder gleich sind. Sie sind aber n i Wirklichkeit nicht identisch, z.B. wenn Gleitkommazahlen unterschiedlicher Genauig­ keit angeschlossen sind. Sie werden nicht automatisch konvertiert, wie das sonst bei der statischen Bindung geschieht.

•

Die kurze relative Pfadangabe 'AddString.vi' genügt nur, wenn das VI im selben Ver­ zeichnis gespeichert ist wie das aufrufende VI. Andernfalls braucht man die vollständige absolute Pfadangabe.

•

Statt einer Konstanten als VI-Namen (hier: 'AddString.vi') kann man für die Funktion 'VI-Referenz öffnen' auch ein Bedienelement verwenden. Damit erhält man die schon erwähnte Möglichkeit, noch während des Programmlaufs das SubVI auszutauschen.

5.3.2.3

Beispiel für den SubVI-Austausch während der Laufzeit

Im Beispiel von Bild 5.25 wurde der Name 'AddString.vi' verwendet. Auf der Festplatte ste­ hen noch drei Unterprogramme mit gleichem Anschlussfeld. Sie heißen 'SubString.vi', 'MuIString.vi' und 'DivString.vi'. Ihre Funktion ergibt sich aus den Namen. Ersetzt man nun in Bild 5.25 den konstanten Namen 'AddString.vi' durch ein Bedienelement, kommt man zu einem Panel etwa wie n i Bild 5.26 und einem Diagramm gemäß Bild 5.27.

..I

--

Bild 5.26 Beispiel für dynamische Bindung: Panel eines Programms, bei dem man noch während der Laufzeitzwischen vier verschie­ denen $ubVls wählen kann, die sich auf der Festplatte befinden. Derzeit ist die Division aktiv

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427d592981cf089d91b1gecaOOaO, Zentral- u 2009.07.31 21 :42:39 +02'00'

5 Unterprogramme

llO

Bild 5.27 Diagramm zum Panel von

[j]

Bild 5.26

IAufgabe 5.6

Entwickeln Sie drei weitere Programme nach dem Muster von AddString.vi, welche die drei anderen Grundrechnungsarten mit Zahlenstrings durchführen. Testen Sie damit, ob Sie wirklich während der Laufzeit des Programms von Bild 5.26 bzw. Bild 5.27 die Rechenoperation wechseln können.

5.3.2.4

Rekursiver Aufruf von Unterprogrammen

Unterprogramme können bei statischer Bindung nicht rekursiv aufgerufen werden. Ver­ sucht man, ein VI in sich selbst einzufügen, meldet LabVIEW einen Fehler. Jedoch lässt sich mit Hilfe der dynamischen Bindung zusammen mit der Eigenschaft 'ablaufinvariant' ('reentrant') ein rekursiver Aufruf realisieren. In Abschnitt 5.2.3 wurde gezeigt, wie man ein SubVI ablaufinvariant macht. Bild 5.28 und Bild 5.29 geben ein BeispieJ, das Informatikern geläufig ist: die rekursive Berechnung von nL

�,�Rofef=l E'WnJlberRefOfeflZ, BerflZeiQffi

17 ActorMtische SkaoIeflXlg

r,"

r lnve< / .. '"

soo 600 100 8C()

!:.�,05 _�3,M _!:.3,36

I"·v� _ le,73111 117,�5m

126, 16111 1)4,9I)n 1999,96m j999,85m 1999,6611\ Im,39m

Bild 6.22 Panel eines VI, das drei verschiedene Kurven in einem Graphen darstellt: Sinus, Kosi­ nus und den natürlichen Logarithmus.. Achtung: Die X-Achse zeigt nur Indizes, keine x-Werte oder Zeitwerte! Die Vektoren im Array sind zeilen­ weise angeordnet. vgl.. Bild 6..24

Bild 6.23 Dia­ gramm für das VI in Bild 6.22

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zentral- u 2009.07.31 21:42:39 +02'00'

6.3 GrafischeAusgabe

�

127

Cl

Pioto

W

0,00

r· ',.

',00

0,00

�,.

�·

X

·1.00

·1.5()

fi

·2.00 , 0

I',D 1o,'

'00 = = � SOO 600 700 800 ,.

1.0,'" I�,� I",,'" I-,'�

Bild 6.24 Panel eines VI, das drei verschiedene Kur­ ven in einem Graphen darstellt: Sinus, Kosinus und den natürlichen Logarithmus. Achtung: Die X-Achse zeigt nur Indizes. keine x-Werte oder Zeitwerte! Hier sind die Vektoren im Array spaltenweise angeordnet. vgl. Bild 6.ll

Bild 6.25 Dia­ gramm zum Erzeugen der in Bild 624 gezeig­ ten Ausgabe Die Funktion zum Transponieren findet man unter 'Funktionen'

'Programmierung'

'Array' n i der Mitte der siebten Zeile unter der Bezeic.hnung '2D-Array transponieren'.

IAufgabe 6,9 Was geschieht, wenn Sie im Diagramm von Bild 6.25 die Funktion zum Transponieren weg­ lassen? Verändern Sie das Programm entsprechend und beobachten Sie die entstehenden Kurven. Haben Sie eine Erklärung für das seltsame Ergebnis?

6.3.2.3

Skallerung der Abszisse In einem Graphen

Voreingestellt sind die Beschriftung 'Zeit' und eine automatische Skalierung ('Autom. Skalie­ rung X', siehe Bild 6.26), wie man das Z.B. in Bild 6.15 sehen kann. Dort wurde eine Histo­ rienlänge von 26 vorgegeben. Das heißt, man sieht zu Beginn die Zahlen 0 bis 25 als Ac.hsen­ beschriftung. Das sind die Indizes der ersten 26 Bildpunkte. Danach springt die Beschriftung auf 25 bis 50, dann auf 50 bis 75 usw. Bild 6.15 zeigt die Beschriftung 75 bis 100 nach drei Bi l dwechseln. Will man die Zeit anzeigen und nicht die Indizes der auszugebenden Bild­ punkte, muss man im Kontextmenü zum Graphen auf 'x-Achse' - 'Formatieren . . .' gehen (Bild 6.26) und 'Formatieren. . .' anklicken. Damit öffnet sich das Fenster von Bild 6.27.

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zentral- u 2009.07.31 21:42:39 +02'00'

6 Prozessvisualisierung

128 -­ ....... """'" irl Bedoo.... , . . t�

,

E'..,..... Ersetzen

� • •

lIesd"O'eltng ....t TIPP. ,.

Dltemperalionen

��""�� � .... Fensterbetedl ..,.assen

.

•

-....

.

• •

,/ I>d:om. � X

� FctIMi:..-.:I � t

Pb,

J GIIInnIete ArpasRng

Bild 6.26

,f Sicl'd:>are �brIQ

Graphen

I�IC

.. for

r

.""....,.

"""04'

2 Groph EIgenschaften Er>c�

I

Fcnr"" lX1d �

I

Plot,

�

Z� (X·Achse)

_

I ClXse< I �

"Iz�:;------

'" AchseIIverIatI ••.

�

�5q1 ..

DiQitoief 5q1 ..

DoteH!O (5io '"o"",�....n .on "'on'" ,""','..... l _""'., "on"".....]

I"""'"

3

"'-I"od)

... ... .."'�)

110"

-�

r

O�� -...cq,n

Iö ' " '" "� Iö

,. " �".__'

,­

.I.bt"''''9"'' "",s.w-.o.l,""j

lI(m

1,00

r. Rebt� "'" stoot ..,, _......

(" TlrlroJfrx"'f..""" ....n..

'"' ...."""' . ':)

-IF68 ;F21 COJA 5761 7120 6973 H:l' COJA

-

. ..

Bild 8.1 VI zum Testen verschiedener EOL-Darstellungen und Lesemodi

Das Diagramm dazu findet sich in Bild 8.2 und wird später erklärt. Vorerst muss man nur wissen, dass die unter 'Text' eingegebenen ASCII-Zeichen n i eine Datei auf der Festplatte geschrieben und anschießend l von dort auf verschiedene Weise gelesen und dargestellt wer­ den. Wird EOF nicht beachtet, erhält man eine Fehlermeldung.

Bild 8.2 Diagramm zum VI von Bild B.l, wird später erklärt

IAufgabe 8.1

Testen Sie die verschiedenen Möglichkeiten von 'EOL_EOF_Test.vi' Sie werden erken­ nen, dass Sie bei ungünstiger Parameterwahl (z.B. von 'Offset n i Bytes') Fehlermeldungen erhalten. Das geschieht immer, wenn Sie versuchen, über die EOF-Grenze des Daten­ satzes hinaus Zeichen von der Festplatte zu holen.

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zentral- u 2009.07.31 21:42:39 +02'00'

8

150

Dattntransfer von und zur Festplatte

Die Dateifunktionen von LabVIEW nutzen beim Lesen einen Lesezeiger. Die Funktion 'Dateiposition festlegen' in der Mitte von Bi l d 8.2 setzt ihn mit Hi l fe des Offsets und des Bezugswerts 'start' oder 'rurrent' oder 'end'. Das Lesen beginnt an der durch den Lesezeiger gegebenen Stelle und erkennt von dort an 'Bytezahl' Zeichen. Bi l d 8.3 zeigt das Prinzip. Setzt man etwa in 'EOL_EOF_Test.vi' die Parameter 'Bezüglich' ='start', 'Offset in bytes' = 6 und 'Bytezahl' = 2 ein, so werden ab 'start' + 6 =1 + 6 = 7 die zwei Zeichen 'Wa' gelesen. Dasselbe Ergebnis erzielt man, wenn man sich auf die Marke 'end' bezieht und 'Offset in bytes' = -8 setzt CBytezahl' = 2 wie bisher). Denn das setzt den Lesezeiger auch auf7 = 15 - 8 ='end' - 8.

Oho ! Was i s t ? I 2 3 4 5 6 /7 8 9 10 11 12 13 14 lS

\ �

8.1.2

._-,_.. ,

t

,"d

Lesezeiser - start + 6 - end - 8

Bild 8.3 Speicherung von ASCII-Zeichen auf der Festplatte. EOL nicht konvertiert. daher zwei Zeichen

Menüs

i1

LabVIEW ermöglicht alle Dateioperationen, die man von anderen Programmiersprachen (z_R C) her kennt Bild 8A und Bi l d 85 zeigen die entsprechenden Menüs. , ""

�

.

§� � ""'� �" � .� _ f.f .

_.

� �,' ,�

,,-

� � ' iil � �' .

_... ru

W llil l1ll ilIl ,-I

'�"d

�1"'''''''', '"1"'�,,,",

........,"'"

w__'"

""' •• " ... InT",' ''''� -�-, _.l!O ""_��l!O d _''' .• ' �..""",," ....''''"''' �

--

''

[Illl [In b'l � il

"�_,� n "

,...��....

�-,,,,,"

.... ,,� "".

� "'�""�

�.. ""''''"

"_��,.�

... . . . do
Oi>v,exe nmxs,exe "cho"d,e,e ,,&.o",e,e

esm,exe msvc32,e,e =,","" et,ex.

0

WI'O":

+6

-, -,

00

00

-, -,

SVSTfM

00 00

"srEM

00 00

S\'5TfM SVSltM

00 00

-, -,

00 00

,"STEM

00

S\'5TtM

00

lOKAlER DIE�T

SVSTtM ""TZW!:RKDIEN;ST S\'5TtM SVSTtM

""

""

S\'5TtM

�: l"'o

00 00

00

00 00

00

00

, ,,'"

62.2% r

" ". 37.5OO K 30.68'1 K lQ.,," < 0.]7" K 6.2% K

S,g'ln

5,1OH 5,0'18 K '1.972 K ',,"8K '1,688 K '1.\32 K ',,,,,," K '1,360 K

U20K

U 16K � P=ese"""" I ','00 K

k,. \90 sicheftef� hef: 3� "

WiBi(aimulsndgTad1eows4fOsk.h7-MrtTaansakg-zMeurar'nPZeraogzieterwesuner'tdegeernnanTat)sks 2000,

46

Eine Anwendung lässt sich nun ihrerseits in kleinere Einheiten zerlegen, die ebenfalls quasi­ parallel verarbeitet werden. In diesem Fall sprechen wir von

Multlthreadlng Das Programm wird hier n i einzelne 'Fäden' (Threads) aufgeteilt, denen der Prozessor zuge­ wiesen wird. Bei Vls übernimmt nicht das Betriebssystem diese Unterteilung, sondern Lab­ VIEW selbst.

Dies geschieht unter Berücksichtigung der Datenabhängigkeiten im

Diagramm des VI. Die zwei While-Schleifen in Bi l d 14.3 oder Bild 14.5 laufen z.B. als ver­ schiedene Threads innerhalb einer einzigen Anwendung, nämlich der Anwendung Lab­ VIEW.

14.2.2

Synchronisation von Prozessen

Parallel laufende Prozesse müssen oft synchronisiert werden. Man denke etwa an die Daten­ erfassung von Messwerten, die anschließend einer Fouriertransformation unterzogen wer­ den. Am einfachsten macht man das mit der alten sequenziellen Methode: Das Programm stößt eine Datenerfassungskarte an, 1024 Messwerte zu erfassen. Dann wartet es, bis die 1024 Messwerte aufgezeichnet und in einen Speicherbereich geschrieben sind. Anschließend führt das Programm die Fourieranalyse durch und stellt das Ergebnis auf dem Bi l dschirm dar. Damit ist ein Zyklus durchlaufen und der Prozess kann wiederholt werden. Allerdings nutzt diese Methode den Prozessor nicht optimal. Während die Datenerfassungskarte Daten sam­ melt, wartet der Prozessor untätig. Das muss nicht sein. Er kann parallel die Fourieranalyse durchführen. Doch erfordert das eine Synchronisation beider Prozesse. Die Fourieranalyse kann erst beginnen, wenn 1024 Messwerte eingelesen sind und in einem Speicherbereich bereitstehen. Die Datenerfassungskarte darfauch nicht in diesen Speicherbereich schreiben,

Ausleihe: 31.07.2009 00:00:00 -08.08.2009 00:0 :00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zenlral- 2009.07.31 21:42:39 +02'0 ' u

14.3 Parallelverarbeitung unter LabVJEW

247

während die Fourieranalyse läuft. Sie benötigt einen anderen Bereich. Am Ende muss sie dem Prozess zur Fourieranalyse mitteilen, dass neue Daten bereitstehen. Umgekehrt muss der Prozess der Fourieranalyse dem Datenerfassungs-Prozess mittei l en, wenn die Analyse des einen Bereichs abgeschlossen und der Speicher dort wieder frei zur Aufnahme neuer Daten ist. Man kann dieses Problem allgemein so formuieren, l dass mehrere Prozesse sich einen Spei­ cherbereich tei l en, der stets nur von einem Prozess genutzt werden darf. Die Standardlösung für dieses Problem sind die von dem Holländer Edsger Wybe Dijkstra 1965 eingeführten Semaphoren, die man mit den Verkehrszeichen am Anfang und Ende eines wegen Bauarbei­ ten einspurig geführten Straßenabschnitts vergleichen kann.

Verwendung von Semaphoren Semaphor bedeutet Zeichen oder Zeichenträger. Zwei parallel laufende Programme, die sich beim Zugriff auf eine Ressource, z.B. einen Speicherbereich oder ein Peripheriegerät,

wechselseitig ausschließen sollen, können dies durch Zugriff auf einen Semaphor tun, ein

kleines Stück Code, wie es unten stehend skizziert ist: P (Semaphor s) wait until 5

·1 I'atomar, war

;. Prozess kann er5t weiterlaufen,

> 0,

sobald 5

brochen werden!

V (Semaphor {

s

:= s+l;

5)

I·

)

5

:= v;

I

•

> 0

: = s-l;

erkannt,

I·

ProzeS5 sperrt andere Prozesse,

d.h.:

falls 5 = 1

s : =5-1 darf durch keinen Proze5S unter­

ProzeS5 gibt den ;,ugriff für andere Proze55e frei .;

;. muS5 atomar 5ein

Init(Semaphor s,

{

then 5

wenn s > 0 ist .;

Integer v)

I·

·1

Initiali5ierung des Bemaphor5

;. v i5t eine positive Integerzahl,

·1

im einfach5ten Fall gleich 1

·1

Eine Befehlsfolge kann man auf verschiedene Weise 'atomar' machen, z.B. durch Sperrung von Interrupts oder durch Verwendung spezieller Befehle im Instruktionssatz des Prozes­ sors. Der Wert 'v' des Semaphors ist die Zahl der Benutzer, denen man gleichzeitig Zugriff auf die Ressource erlaubt. Ist es z.B. nur ein Benutzer, der drucken darf, verwendet man einen 'binären Semaphor'. Dieser kann nur den Wert 0 (Drucker belegt) oder 1 (Drucker verfügbar) haben. Von diesem Begriffdes Semaphors ausgehend hat LabVIEW verschiedene Möglichkeiten zur Prozess-Synchronisation entwickelt.

1 4.3

Parallelverarbeitung unter LabVIEW

LabVIEW kennt verschiedene Funktionen zur Prozess-Synchronisation. Man unterscheidet zwischen der reinen Synchronisation der Abläufe von Threads und der Synchronisation mit zusätzlicher Datenübertragung. 'Semaphor' und 'Rendezvous' (auch 'Occurrences', aber veraltet) dienen der reinen Synchronisation. Sie werden n i Abschnitt 14.4 behandelt. Zur zweiten Kategorie gehören 'Melder' (Notifications) und 'Queues', siehe Abschnitt 14.5. Nutzt man diese Funktionen, hat man generell wie folgt vorzugehen:

Ausleihe: 31.07.2009 00:00:00 -08.08.2009 00:0 :00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zenlral- 2009.07.31 21:42:39 +02'0 ' u

14

248

Parallelverarbeitung, Ereignis-, Zeitsteuerung

•

Erzeugen des Betriebsmittels (auch 'Ressource' genannt), z.B. eines Semaphors,

•

Nutzen der Ressource (synchronisieren, Daten übertragen, Status abfragen usw.) und

•

Freigeben oder Schließen.

Erzeugen und Schließen sind in aUen Fällen recht ähnich. l Sie werden deshalb zuerst in Ab­ schnitt 14.3.1 und 14.3.2 behandelt. Die Nutzung der Ressourcen ist vielfältiger. Diese wird in Abschnitt 14.4 und 14.5 besprochen. Unter 'Funktionen' - 'Datenkommunikation' - 'Synchronisierung' findet man folgende Elemente, die in nachstehender Tabelle zusam­ mengefasst sind: Tabelle 14.1

+-.. a>

:

'

r" � �'I +-..

.++

IB• • •

Synchronisation von Prozes en:velWendete Palet en Palet e 'Synchronisierung' Palet e 'Melder-()perationen' Palet e 'Queue-Operationen' Palet e'Semaphor' Palet e 'Rendezvous' Palet e 'Oc ur ences'

In der Palette 'Synchronisation' von Tabelle 14.1 findet man fünf Unterpaletten, die alle auf bestimmte spezielle Zwecke hin ausgerichtet sind. Die Grenzen sind fließend. Man kann manche Probleme auf die eine oder andere Art lösen, aber bestimmte typische Aufgaben wird man zweckmäßigerweise mit den Funktionen der Unterpalette bearbeiten, die dafür besonders geeignet sind. Schauen wir uns die Unterpaletten von unten nach oben an, so können wir sie vereinfachend wie folgt beschreiben: Synchronisation 0 h n e Datenübertragung zwischen den Threads: Occurrences:

(Occurrence = Ereignis) Methode zur Synchronisation zweier Threads.

Merke: Ab LabVIEW 7.0 wird empfohlen, diese Funktion durch Melder zu ersetzen.

Semaphor:

Schützt gemeinsam genutzte Daten vor zu früher Verwendung. Semaphor bedeutet griechisch 'Zeichenträger'. Man denke an eine Baustelle, bei der eine Fahrbahn gesperrt ist und die andere jeweils nur auf ein Zeichen hin freigegeben wird.

Rendezvous:

Synchronisation der Ausführungszeitpunkte verschiedener Threads (Ren­ dezvous = Verabredung, Zusammentreffen).

Synchronisation m i t Datenübertragung zwischen den Threads: Melder:

(Notification) Wirkt wie Occurrences, aber mit zusätzlicher Datenübertra­ gung zwischen den Threads.

Queues:

Warteschlange für mehrere Datenpakete nach dem FIFO-Prinzip (First In, First Out). Im Gegensatz zum Melder, der nur ein Datenpaket übermittelt,

Ausleihe: 31_07_2009 00:00:00 -08_08_2009 00:0 :00. ID:7ac0427dS92981cf089d91b1gecaOOaO, Zenlral- 2009_07_31 21:42:39 +02'0 ' u

14.3 Parallelverarbeitung unter LabVJEW

249

das auch überschrieben werden kann, puffert die Warteschlange beliebig viele Datenpakete. Ist der Puffer voU, kann erst wieder geschrieben werden, wenn das älteste Datenpaket (First In) ausge1esen wurde. überschreiben ist hier nicht möglich. Alle diese Unterpaletten enthalten verschiedene Funktionen. Bi l d 14.8 zeigt dies für die Un­ terpalette 'Occurrences' mit den Funktionen 'Occurrence erzeugen', 'AufOccurrence warten' und 'Occurrence setzen'. Die Auswahl bei den anderen Unterpaletten ist reichhaltiger, ent­ hält aber auch stets eine Funktion, die mit 'Erzeugen', 'Erstellen' oder ähnlich bezeichnet wird. Sie dient der Erzeugung und Freigabe der Ressourcen für die Prozesskommunikation.

Occ.... enc ee

14.3.1

I>J Oco.nlln.. . Oco.nence s...

(von links nFaucnhktrieocnhetns)'EinrzdeeurgUnent',eWarpalretetne''uOncdu'Sreetznecne's' Bild 14.8

Erzeugen von Ressourcen für die Prozesskommunikation

In Tabelle 14.2 sind die Funktionspaleuen aufgelistet, mit denen man Ressourcen für die Prozesskommunikation erste1lt. Sie haben, abgesehen von 'Occurrences', hinsichtlich der Funktion identische Ein- und Ausgänge, die aber teilweise verschieden beschriftet sind. Sie werden deshalb gemeinsam beschrieben. Abweichungen sind m i entsprechenden Unter­ kapitel erklärt. Das Erzeugen von Ressourcen wird im Symbol der zuständigen Funktion mit einem Stern angedeutet. Die Eingänge und Ausgänge in TabeUe 14.2 haben folgende Bedeu­ tung: 'Name (unbenannt)' Ober diesen Eingang kann man der Ressource (dem reservierten Speicherplatz) einen Na­ men geben. Wird an verschiedenen Stellen innerhalb derselben Anwendung derselbe Name verwendet, erhält man Referenzen aufdieselbe Ressource (vereinfacht: Adressen auf densel­ ben Speicherplatz). Allerdings kann man n i nerhalb einer Anwendung den gleichen Namen für Elemente von verschiedenem Ressourcentyp verwenden. Das heißt, man kann Z.B. ei­ nem Semaphor und einem Rendezvous den gleichen Namen 'Fritz' geben. Lässt man den Eingang für den Namen unverdrahtet oder übergibt man einen leeren String, erste11t Lab­ VIEW bei jedem Aufruf eine andere Ressource. Intern bedeutet das Erzeugen einer Ressource die Festlegung einer eindeutigen Speicher­ adresse und die Reservierung des betroffenen Speicherplatzes. Das Prinzip wurde schon in Abschnitt 7.1.2 im Zusammenhang mit Referenzen beschrieben. Das VI in Bild 14.9 und Bi l d 14.10 zeigt diese1be Vorgehensweise am Beispie1 eines Semaphors. Das VI enthält eine Schleife. Wird dem Semaphor kein Name zugeordnet, werden ständig neue Referenzen erzeugt, Speicherplätze reserviert und zusätzlich nummeriert. Gibt man dagegen einen Na­

men vor, m i Beispiel 'Emil', erzeugt die Schleife nur eine einzige Referenz und reserviert auch nur Speicherplatz für einen Semaphor namens 'Emil'. Das Erste1len einer Ressource mit Namen hat also den Vorteil, dass die Referenz auf die Ressource nicht jedem VI oder SubVI als Parameter übergeben werden muss. Das SubVI kann sich die Ressource selbsterzeugen, sofern es nur den Namen kennt.

Ausleihe: 31.07.2009 00:00:00 -08.08.2009 00:0 :00, ID:7ac0427d592981cf089d91b1gecaOOaO. Zentral- 2009.07.31 21:42:39 +02'0 ' u

14

250 für

Parallelverarbeitung, Ereignis-. Zeitsteuerung

Funktionen das Erzeugen von Res ourcen die Prozes kommunikation Ereignis ��J-� (Engang,

Tabelle 14,2

für

[§I-

Name (..-benan>') GrOße (l) vortwldenes ausgeben (F) ...., km FI!I*r) ,

r- �IM

Semapho< Neu erstelt Lfelier (Aus9ang)

Weitere Eingänge und Ausgänge sind: 'Vorhandenes ausgeben (F)' bzw. 'Erzeugen, wenn nicht gefunden? (T)' Dieser Eingang muss für unbenannte Ressourcen auf jeden Fall auf den entsprechenden Standardwert gesetzt werden oder unverdrahtet bleiben, anderenfalls tritt ein Laufzeitfehler auf. Allgemein gibt man hier an, ob eine bereits existierende Ressource verwendet oder eine neue erstellt werden soll. 'Neu erstellt' bzw. 'Neu erzeugt?' Liefert TRUE, wenn eine Ressource neu erzeugt wurde, sonst FALSE. Semaphor, Rendezvous usw. Alle Funktionen liefern hier die Referenz auf die jeweilige Ressource, die für nachfolgende Aufrufe von Funktionen verwendet wird. 'Fehler (Ausgang)' Sollte aufjeden Fall überprüft werden.

IAufgabe 14.2

Starten Sie das Programm SemaphocBeispieC1.vi mit und ohne Namensgebung und beobachten Sie das Verhalten in beiden Fällen. Kopieren Sie das VI unter dem Namen Semaphor_Beispiel_2.vi und lassen Sie beide VIs paralleJ laufen. Was geschieht, wenn Sie n i beiden Programmen denselben Namen 'Emil' für den Semaphor vergeben?

Ausleihe: 31_07_2009 00:00:00 -08_08_2009 00:0 :00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zenlral- 2009_07_31 21:42:39 +02'0 ' u

14.3 Parallelverarbeitung unter LabVJEW

251

Bild 14.9

Semaphor_Beispiel_1.vi, Panel

Iä§" m�1 � �

I!lirl lfj

[j]

Bild 14.10

14.3.2

DiagrammzuBild14.9

Freigabe von Ressourcen der Prozesskommunikation

Generell gilt, dass alle Ressourcen einer Anwendung auch wieder freigegeben werden müssen. Für jede Ressourcenart existiert eine eigene Funktion, siehe Tabelle 14.3. Nur die 'Occurrences' müssen nicht vom Programmierer freigegeben werden. Sie verschwinden automatisch bei Beendigung des VI. Das Freigeben von Ressourcen wird m i Symbol der zuständigen Funktion mit einem Kreuz angedeutet. Tabelle 14.3

Funktionenfürdas Freigeben von Res ourcen für die Prozes kommunikation Semaphor

�

Gfl

Rendezvous ---j

-...........

,- (..."..".l

Rend

ezvous

-Name

li LJ. - F�er (Ausgang) ,_ hoo" bei. . • Sema!>hoo" Ire...

[;0]

FunktionenPalet enansicht: 'Semaphor'­

�-$I..

Bild 14.12

Bi l d 14.12 zeigt die Semaphor-Funktionen. Sie arbeiten im Prinzip wie folgt: Mit 'Semaphor belegen' und 'Semaphor freigeben' (erste Zeile, zweites Element von links) entnimmt man eine Marke aus einem Topf, der beim 'Semaphor erzeugen' (siehe Tabelle 14.2) standard­ mäßig mit einer Marke gefüllt wird. Man kann durch Eingabe eines Wertes größer I für den Parameter 'Größe

(I)'

anfangs auch mehrere Marken in diesen Topf geben. Jeder Pro­

grammteil, der auf einen schützenswerten Datenbereich zugreifen will, muss nun mit 'Sema­ phor belegen' eine Marke entnehmen. Isl keine Marke im Topf, wird dieser Programmteil nicht ausgeführt, weil ein anderer Programmteil im Besitz der Marke ist. Am Ende eines solchen Programmteils müssen die Marken mit 'Semaphor freigeben' (erste Zeile, drittes Element von inks) l zurückgelegt werden. Eine einzige Marke (Standardwert für 'Größe

(I)') genügt, um das in der

Informatik wohl

bekannte Beispiel vom Produzenten und Konsumenten und zu behandeln. � �p",� " ,

,

l �· i:!L "

�

Cl Fm"..".,.1..

ITl

. -m

=t.'-.J

�

0----{]] � ..,.....,

�OL I '

� . M. ,

,

11:5

"

'..rlAt· lod %

r::::::

C.

E300 00 00 E9 020000 E200 00 00 E8 020000

on "',",,"n. !>iI>

,..... "'*"""" "'-61 ""'-"'" . . ''' ''''"''

IbO�''''''

","""", QDOdt. ( ZtJIiri.

Vi.... )

0 �

1

I,

IiIJ

AbbMich der Tas!< AusfChl.\"lg de, VI, DAQmx . Tas!< ,;ti>ftffi ode< DAQmx . 5c"� befand. der E...... Auto.ta,t de, VI, eJ: TRLl' 9"setzt ....de. ..

3

4

beSÜlme 1DWfm

...:",iIo NS......

[TI

�

-"

o.!...J '�OooI ..�

�,

l.�

� • "',,,,.,,"',, 00."'",,""

:n1O.lOO3

�

,

.

2O.IO.J:Oj '"

"" ""',

2O, lO,i'OClI

Bild 16.46 Auslesen des USB-6251-Pufferspeichers in den RAM des Laptop erfordert durchschnittlich 5 ms o h n e Anzeige im Signalverlaufsgraph und 7 ms mit Anzeige. Das Diagramm dazu findet sich in Bild 16.47

Bild 16.47 Diagramm zu Bild 16.46: Zeitbestimmung für Puffer lesen und Anzeigen in einem Graph.Die Verzögerung von 1000 ms links dient dazu, dass das Gerät USB-6251 erst seinen Pufferspeicher füllen kann, ohne dass der Laptop daraufwarten muss

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zentral- u 2009.07.31 21:42:39 +02'00'

328

16

MesscL1ten-Eingabel-Ausgabe

Auch das Speichern der zunächst in das RAM des pe übertragenen Daten auf die Festplatte benötigt Zeit. Bei 100000 Analogwerten wie in Bi l d 16.46 sind es 13 bis 14 ms, bei 1 Million Analogwerten wächst die Zeit überproportional auf ungefähr 280 ms an. Das liegt daran, dass das Windows-Betriebssystem diese Datenmenge stückweise, d.h. ebenfalls gepuffert, übertragen muss, worauf der Anwendet keinen Einfluss hat.

IAufgabe 16.7

Schreiben Sie ein VI, etwa nach dem Muster von Bild 16.47, das die Zeit rur die Umspei­

cheruog der Daten aus dem RAM des pe aufdie Festplatte ermittelt.

Die Frage ist nun, ob man bei Verwendung einer Schleife die Daten rechtzeitig zum pe transferieren und dort auch auf Festplatte speichern kann. Zunächst zeigt Bild 16.48 ein VI, das Auskunft über den Stand des Ringpuffers im USB-6251

gibt. Denn während die Datenübertragung zum pe erfolgt, wird m i Modus 'Kontinuierlich' weiter in den Ringpuffer geschrieben. Der Eigenschaftsknoten 'VerfügbSampProKanal' (siehe Bild 16.48) gibt darüber Auskunft.

rnt

mt-�I

...... i-j, �

"'� chonne.

• /'I '� �

I�

S

..

s..-.pe·Tekt �

I

�10 DEI.

1 --e> �,t.oJ yY1 �

I KionOI�,

.1

oO DIIQm ·les.1

--

_.•

-'• ---

Bild 16.52 Die 'Anzeige Fourier' stehtjetzt auf aus. Die Fouriertransformation von 5 Datensätzen (von anfangs 12) wurde bereits angezeigt 7 weitere Elemente in der Queue sind noch abzuarbeiten

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS929S1cf089d91b1gecaOOaO. Zenlral- u 2009.07.31 21:42:39 +02'00'

16.4 Altere NI-Karte PCI-MIO-16E-4 Qot�

, � �iiil(L ';'�mft...

..- _

"'_ "',,.u

." """

. :."

.... :1:.

•

�

�

•

-

�,[;

-

.� . 9"'

,

J' � •

___ (0te,,,,,10 >lO",6--.d.·".,

i L

��

�

,-"

Bild 16.79

Suchen des hardwaremäßig angeschlossenen TED$-Sensors, hier an Kanal 0

Der MAX bringt jetzt eine Anzeige gemäß Bi l d 16.80. Nun muss ein Task erstellt werden. Dazu im Kontextmenü von 'NI PCI-4474' anklicken 'Task erstellen. . .' - 'Signale erfassen. . .' - 'TEDS'. Wählen 'AI: Beschleunigung', dann einen Task-Namen eintragen und beenden. Im MAX werden N Sampies, 2k Sampies und 20k Rate vorgeschlagen. Im Beispiel wurden diese Werte übernommen, siehe Bild 16.81.

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zenlral- u 2009.07.31 21:42:39 +02'00'

342

MesscL1ten-Eingabel-Ausgabe

16

Bi l d 16.82 und Bi l d 16.83 zeigen ein sehr einfaches VI, das n i der Lage ist, ein simuliertes Erdbeben (Tritt an den Labortisch) mit dem Brüel & Kjaer-Sensor aufzunehmen und n i einem Diagramm darzustellen. , ,-; ,, = ,.",: ,: . : :. c :c: x_ = � � � � � � � � -

", 0 ",n""' ffi Wi lil """ �

"-

ii "' ''''ot,,,,,scr-r.tt;,",..,

E]c___,cr."" E]C___LO

iii � NI-C"q., - Gote "" '" KI-MD-'''''', '"",,'

-"

El c___"""",__

'" "" 'HG·tI": 'De,,'

"'teStrnoI

•

m

mJ --II!

Bild 17.10 Zustand S3 mit Folgezu­ stand SO des Zählers nach Bild 17.4

Die Farbe des AnschlussfeJdes passt sich dann der Stringfarbe an. Nun versieht man jeden Zustand mit einer Stringkonstanten, wobei man auf eine möglichsl verständliche Beschrei­ bung des Zustandes achten sollte. Bild 17.7 bis Bild 17.9 verdeutlichen die Realisierung des Zustandsdiagramms aus Bild 17.4 mit Hilfe von Strings. Bild 17.11 zeigt das FrontpaneJ. l·fij"Nii sa " l ,$1 1 ,

�,,� �"beoten �,oq,n E"joIt �"Chen �ffiqeuoe 00."'"' tfle

--

Bild 17.11 Frontpanel des mit Strings arbeitenden Zustandsautomaten 'Zäh­ lerString.vi'

Ferner sollte man noch folgende Punkte beachten: Es kann passieren, dass man sich bei der Eingabe der Zustandsbezeichnung vertippt. Besonders Leerzeichen am Anfang und am Ende sind FehlerqueJlen, die nur schwer zu finden sind. Ändern sich die Zustände, müssen die Stringkonstanten angepasst werden. Wird eine Konstante vergessen, führt das zum Fehlver­ halten des Zustandsautomaten. Abhilfe kann man durch folgende Maßnahmen schaffen: •

•

•

Verwendet man für die Auswahl einer Case-Struktur den Datentyp String, kann man im Kontextmenü über den Punkt 'Groß/Kleinschreibung ignorieren' die Unterscheidung zwischen Klein- und Großschreibung aufheben, siehe Bild 17.12. Dann sind die Bezeich­ nungen 'ZUSTAND' oder 'Zustand' oder auch 'ZuStand' usw. gleichbedeutend. Die Vor­ einstellung der Gase-Struktur dagegen ist 'Gase sensitive', d.h., es wird die genaue Schreibweise beachtet. Eine weitere AJternative besteht darin, die Funktionen 'In Großbuchstaben' bzw. 'In Kleinbuchstaben' aus der Stringpalette zu verwenden und n i der Case-Struktur die Be­ zeichnungen ausschließlich groß- bzw. kleinzuschreiben. Will man Leerzeichen am Ende und Anfang der Zeichenkette ignorieren, kann man diese über die Stringfunktion 'Nicht darstellbare Zeichen trimmen' entfernen.

Mit diesen Vorkehrungen lassen sich bereits vieJe Programmierfehler vermeiden. Weiter sollte man zur Venneidung von Fehlern bei jedem Zustandsautomaten einen Rahmen 'Voreinstellung' gemäß Bild 17.12 vorsehen. Damit wird schon während der Programmentwicklung ein Dialog angezeigt, falls ein Zustand abgearbeitet werden soll, der nicht existiert.

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zentral- u 2009_07_31 21:42:39 +02'00'

354

17

r-"�r.. �" '"" � ·=, >r · r, .n �

.. "*," .... ..... aesdub."II 1

r � W""e "', .. "

�.

"m

,

IO �

10

��

�

��

�

.on

,

, ,�

'00

,,�

�

Bild 17.25 Münzwerte in Eurocent

IAufgabe 17.2

Verfolgen Sie im Debug-Modus unter Verwendung einer geeigneten Probe, wie die Clusterkonstante 'Daten' schrittweise mit den Münzwerten gefüllt wird.

Erläuterungen zum Programm Wenn der erste Rahmen der Case-Struktur 'Initiaisiere l Münzwerte' ausgeführt wird, liest die FüR-Schleife im Inneren alle Münzwerte der Variablen 'Münzauswahl' mit Hi l fe des Eigen­ schaftsknotens 'StringsUndWerte[]', der m i Kontextmenü des Text- und Grafikrings zu

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zenlral- u 2009_07_31 21:42:39 +02'00'

17.3 Milnzautomat

361

erzeugen ist. Er liefert ein Array von Clustern mit String und Wert (Value). Innerhalb der FüR-Schleife holt man sich die Werte mit der Clusterfunktion 'Nach Namen aufschlüsseln'. Diese Werte werden rechts unten mit der zweiten Clusterfunktion 'Nach Namen bündeln' in die Konstante 'Daten' eingefügt. Der Automat springt danach n i den Zustand 'Initialisiere Produktauswahl/Preise', in dem er die Bezeichnungen der Produkte und ihre Preise einliest, siehe Bild 17.26.

Bild 17.26 Übertragen der Preise in die Konstante 'Daten' und derWarennamen in den Menü-Ring 'Produktauswahl'

Diese sind in einer Arraykonstante von Clusterkonstanten gespeichert. Der Aufbau dieser Konstanten geschieht in folgenden Schritten: •

•

•

•

•

•

•

Clusterkonstante mit einem leeren String und einer Integerzahl (z.B. 9999) füllen. Stringrahmen etwas in die Breite ziehen, so dass dort später Worte wie 'Schokoriegel' Platz haben. Im Kontextmenü des Clusters 'Autom. Skaierung' l - 'Größe anpassen' wählen. Arraykonstante ins Blockdiagramm ziehen und die Clusterkonstante dort hineinziehen. Die Eintragungen sind anfangs angegraut, wei l die Arraykonstante noch leer ist. Mit dem Werkzeug 'Hand mit Zeigefinger' n i den leeren String gehen und mit 'Getränk' überschreiben. Entsprechend für die Integerzahl 'ISO' eintragen. Der Index der Array­ konstante muss dabei auf0 stehen. Index der Arraykonstante auf 1 stellen und entsprechend die Werte 'Schokoriegel' und '60' eintragen. Sinngemäß das Gleiche für die Indizes 2 und 3. Array der besseren übersichtlichkeit auf vier Felder aufziehen, siehe Bild 17.26.

i Rahmen 'Initialisiere Münzwerte' werden hier die Münzwerte in die Cluster­ Ähnlich wie m Konstante 'Daten' übertragen. Zusätzlich hat man die Warennamen 'Getränk', 'Schokoriegel' usw. mit dem Eigenschaftsknoten 'Strings(l' im Eingabeelement 'Produktauswahl' gespei­ chert. Dieses wurde als zunächst leerer 'Menü-Ring' auf dem Panel erzeugt (zu finden unter 'Elemente' - 'Modem' -'Ring & Enum').

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zentral- u 2009.07.31 21:42:39 +02'00'

362

17

Professionelle Programmentwicklung

Alternativ wäre hier auch die Verwendung von Konfigurationsdateien denkbar, siehe Ab­ schnitt 8.5.3. In diesem Fall könnte die Produkdiste angepasst werden, ohne die Anwendung selbst zu ändern.

IAufgabe 17.3

Versuchen Sie, das Programm 'Statemachine.vi' alternativ mit Konfigurationsdateien gemäß Abschnitt 8.5.3 zu gestalten.

Anschließend wird automatisch in den Zustand 'Zeige Produktauswahl' gewechselt. Hier werden die Elemente 'Produktauswahl' und 'Produkt kaufen' auf dem Panel sichtbar ge­ macht, dagegen 'Münzauswahl', 'Einwerfen', 'Rest' und 'Abbruch' unsichtbar, siehe dazu Bild 17.27. Außerdem ist 'Münz Rückgabe' zurückgesetzt. Das ist wichtig in dem Fall, dass vorher bereits eine Kaufaktion durchgeführt wurde.

".."",t.-.j

1'1"";01;"", ,,,,,,,," ,', ·1 liD

"'ooJnm 15,6 62,S 15,6 i6,9 lial,", 15,6

0,0

0,0

0,0

0,0

0.0

0.0

0.0

0

0,0 0,0 0,0

0,0 0,0 0,0 x"","

15,6 0,0 0,0

O 15,6 0,0 0,0 �,

.ti!

Bild 17.50 Statistik für 'SinusGraph_Besser.vi', Laufzeit von etwa 100 s, die Prozessorzeit ist viel kürzer

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zenlral- u 2009.07.31 21:42:39 +02'00'

17.5

Programmierhiifen

373

In 'SinusGraph_Gut.vi' erfolgt eine Berechnung nur noch bei Parameteränderungen. Der Schalter 'Signal zurücksetzen' in Bi l d 17.45 wird dabei allerdings wirkungslos, weil das Wan­ dern der Sinuskurve im Falle des Nichtzurücksetzens hier nicht mehr sichtbar wird.

l��=:::::::::�������

Bild 17.51 Prozessor noch stärker entiastende Programmierung in 'SinusGraph_Gut.vi' durch Nutzung der Event-Struktur

..

I> Prof,1

l ....tung

und Spe",he'

\1·Z,,",

5i>e W...,.e .'e W...,.efOfm ,'Gr�_W."; ""'_T,op Fgen P.,._er Error• . 'peO:Oet rn AnschUss on die"" Dot_ 9!'>peicheft

" KM;e1.ctl

:' Y �ffi "i:; Buid-5peztMt�

18.2.2

--

I

"

I

Bild 18.5 Hinweis auf ungespeicherte Elemente innerhalb des Projekts

Private Eigenschaften der Klasse

Jede Klasse kann mehrere private Eigenschaften besitzen, die in einem Cluster zusammen­ gefasst werden müssen. Der Versuch, das Cluster durch ein anderes Bedienelement zu erset­ zen oder mehr als ein Cluster zu erzeugen, führt zu einem Fehler. Man bildet dieses Cluster durch Doppelkliek auf'Addition.ctl' und erhält ein Frontpanel gemäß Bi l d 18.6.

1]1 ' '

Bild 18.6 Cluster zur Definition privater Daten in einer Klasse

i das Cluster ein, ferner die konvertierten Wir fügen nun zwei 5tringelemente 'xs' und ys n DBL-Daten 'x', 'y' als Zwischenergebnisse und zuletzt das Ergebnis 'x+y'. 50 erhalten wir ein Kontrollelement entsprechend Bild 18.7.

Bild 18.7 Private Daten von Addition.lvdass. Später wird sich zeigen, dass dieVariablen 'x', 'y' und 'x + y' an dieser Stelle nicht notwendig sind

Während der Laufzeit sind hier die Funktionsparameter gespeichert. Auf sie können alle Methoden derselben Klasse zugreifen. Werden mehrere Instanzen der Klasse m i Programm erzeugt, können diese auch unterschiedliche Daten enthalten.

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zentral- u 2009.07.31 21:42:39 +02'00'

18.2

Erstes Beispiel zur objektorientierten Programmierung

18.2.3

379

Methoden der Klasse

Methoden definieren die (öffentlichen) Schnittstellen der Klasse. Mit ihnen können Daten gelesen und geschrieben werden. I>

P,oJekt EHplo,., Test Ivp,o)*

Dotei rwctCqffi... Or

e

�

•

x

Pfojokt: Test,""'oj

B' . _c�.. • Adn.t.OO.

.. AddI;ion.o;tl

r Ol �_, ,

[� _tier"".,.;

L I!i llIllm'II il TestAdd."; y... 8J1k1.5pe>f� 0

Bild 18.15 Projekt-Explorer mit der Klasse 'Addition.lvclass' und ihren verschiedenen Methoden. Auch das Programm 'TestAdd.vi' ist bereits eingetragen

Mit 'Mein Computer' - 'Neu' - 'VI' im Projekt-Explorer öffnet man ein leeres VI m i Projekt, das man anschließend gemäß Bild 18.16 und Bi l d 18.17 als 'TestAdd.vi' programmiert.

Bild 18.16 Verwendung von Klassen­ methoden zur Programmierung einer Summe von Zahlenstrings als DBL-Wert. Diagramm I> TeslAdd.vl

------

Bild 18.17 Verwendung von Klassen­ methoden zur Programmierung einer Summe von Zahlenstrings als DBL-Wert. Frontpanel mit dem Beispiel einer Addition

IAufgabe 18.1

Programmieren Sie analog zu dem oben beschriebenen BeispieJ für die Addition die Subtraktion von zwei Zahlenstrings mittels OOP.

IAufgabe 18.2

Programmieren Sie das Additionsbeispiel ohne OOP. Vergleichen Sie Ihren Aufwand und den Speicherbedarffür die Software bei beiden Methoden.

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427d592981cf089d91b1gecaOOaO. Zenlral- u 2009.07.31 21:42:39 +02'00'

18.3

Weitere Beispiele zur OOP

Merke:

383

Die ob;ektorientierte Programmierung (OOP) beruht auf der Bildung von

Klassen. Sie entha1ten Methoden (dynamisches VI in LabVIEW), mit denen allein man auf die privaten Daten der Klassen zugreifen kann.

1 8.3

Weitere Beispiele zur OOP

18.3.1

Vererbung

Das Beispiel von Abschnitt 18.2 sowie Aufgabe 18.1 und Aufgabe 18.2 zeigen, dass es recht mühsam ist, mit den bisher benutzten OOP-Methoden alle vier Grundrechenarten zu behandeln. Auch ist das Ergebnis eher mager. Von den oben genannten Vortei l en der OOP ist hier nur das Prinzip der Kapselung zu erkennen: In Bild 18.16 sind die Eingabevariablen 'x-String' und 'y-String' sowie die Ausgabevariable 'x + y (Double)' zu sehen. Dagegen laufen die privaten Daten, für den Anwender nicht sichtbar, n i den Verbindungsdrähten von 'Setzen.vi' und 'Addieren.vi'. Weitere Vorteile von OOP werden erst deutlich, wenn man das Prinzip der Vererbung nutzt. In unserem neuen Beispiel werden wir damit die vier Grundrechenarten bearbeiten, nämlich

z = x + y,2 = x -y, z = x·y und z = xly.

Dazu benutzen wir eine übergeordnete Klasse mit dem Namen 'AbstrakteFunktion.lvelass'. Sie heißt so, weil wir von ihr keine Instanz bilden werden, wie wir das beispielsweise mit 'Addition.lvelass' in 'TestAdd.vi' getan haben. Sie dient lediglich als eine Art von 'Bauplan' für 'Addition.lvelass', 'Subtraktion.lvelass', 'Division.lvelass' und 'Multiplikation.lvelass', die

wir von ihr ableiten. Das wird eine gewisse Arbeitserleichterung mit sich bringen. Wir bilden ein neues Projekt 'Testl.lvproj' und dort zuerst 'AbstrakteFunktion.lvelass'. Das geschieht, wie in Abschnitt 18.2.1 beschrieben, einschließlich der Programmierung von Setzen.vi und Konvertieren.vi. Anschließend erzeugen wir jeweils neue Klassen für Addition, Subtraktion, Multiplikation und Division. Wir beginnen mit der Addition. Unter 'Mein Computer' im Kontextmenü 'Neu' - 'Klasse' wählen, in 'Addition.lvelass' umbenennen und speichern. Im Kontextmenü dieser Klasse kann man nun unter 'Eigenschaften' die Vererbung festlegen.

Bild 18.18 Eigenschaftsfenster für 'Vererbung'

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zenlral- u 2009.07.31 21:42:39 +02'00'

384

18

Objektorientiertf Programmierung

Dazu wählt man die Kategorie 'Vererbung' gemäß Bild 18.18. Auf der rechten Seite ist die Klassenhierarchie der gewählten Klasse 'Addition' angezeigt. Jede benutzerdefinierte Klasse wird zuerst automatisch von 'LabVIEW-Objekt' abgeleitet und kann über die Schaltfläche 'Vererbung ändern. . . ' angepasst werden.

D:\l.I..!lW EW_�. I

3.

Atrooktoo.O--d", .. 5ct>troktoo.ctl � 5ct>trohiefffi.'; il Te>t.,; Y �ffi •borlffi . .i:; Bulj·SpezU

Bild 18..21 Zwischenstand nach dem

_

Einrichten einer abstrakten und zweier ge­ wöhnlicher Klassen für Addition und Subtrak­ tion. Auch das Testprogramm Test.vi wurde bereits eingefOgt

Die Klassen für Addition und Subtraktion enthalten weder die Methode 'Setzen.vi' noch 'Konvertieren.vi'. Sie erben sie einfach von 'AbstrakteFunktion.lvclass'. Dagegen sind die Methoden für 'Addieren.vi' und 'Subtrahieren.vi' individuell für die jeweilige Klasse bestimmt. Sie wurden nach dem Muster von Bi l d 18.14 geschrieben.

SUJtrolge\�\""\Gecon

--� -

P , o"lt

,-

-- -

" "

-- Fon"",

�

a ,

"

r

0-; .

10>11."",0'- cow..te< ,

",

Bild 18.30 'AbstrakteFunktion.ctl' benötigt nur die zwei privaten Variablen 'xs' und 'ys'

4. Man kann ziemlich einfach n i einem nach Abschnitt 18.3.2 strukturierten Programm

einzelne Module austauschen. Das wird in Abschnitt 18.3.3 gezeigt. 5. Die Hierarchie der bisher erstellten Klassen kann man sich anzeigen lassen, n i dem man

Projekt-Explorer m i Kontextmenü von 'AbstrakteFunktion.lvdass' m i 'Klassenhierarchie anzeigen', siehe Bild 18.31.

o 18.3.3

aufruft:

Bild 18.31 Klassenhierarchie im Projekt 'Test2.lvproj'. Man erhält dieses Fenster, wenn man im KontextmenO von 'AbstrakteFunktion.lvclass' aufruft: 'Klassenhierarchie anzeigen'. Der obersteWOrfel stellt die LabVIEW-Klasse dar, darunter kommt 'AbstrakteFunktion.lvclass' und wiederum eine Stufe tiefer folgen diezwei Klassen für die Grundrechenarten Addieren und Subtrahieren

Modulaustausch

Die Methode 'Konvertieren.vi' wandeJt Strings in Zahlen um, genauer: Sie wandelt, aus­ gehend von in arabischer Notation gebildeten Zahlenstrings, diese um n i DBL-Gleitkomma­ zahlen. Was kann man tun, wenn man n i römischer Notation geschriebene Zahlenstrings in DBL umwandeln will? Zunächst braucht man ein Umwandlungsprogramm etwa nach Bi l d 18.32. Es ist der Funkti­ on 'Bruch-/Exponential-String nach Zahl' in der Palette 'Funktionen' - 'Programmierung' 'String' - 'StringlZahI-Konvertierung' - 'Bruch-/Exponential-String nach Zahl' nachempfun­ den und besitzt dieselbe Schnittstelle. Römische Zahlen werden im so genannten Additions­ system dargestellt. Dabei wird die Wertigkeit einer Ziffer nicht durch h i re Stellung innerhalb

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zenlral- u 2009.07.31 21:42:39 +02'00'

18.3

Weitere Beispiele zur OOP

391

der Zahl festgelegt, sondern in rec.ht komplizierter Weise durch verschiedene Buchstaben. Wir wollen hier daraufnicht näher eingehen und verweisen auf alte Schulkenntnisse. Das VI n i Bild 18.32 ist eine einfache Umsetzung dieser Schulkenntnisse, wobei fehlerhafte Angaben nicht vollständig abgefangen werden. Die Regeln heißen:

• • • • • •

'I' steht für I, 'V' für 5, 'X' für 10, 'L' für 50, 'e' für 100, '0' für 500 und 'M' für 1000 Zwei oder mehr Zeichen in Folge bedeutet die Addition ihrer Zahlenwerte Ein 'I' vor 'V' oder 'X' bedeutet Subtraktion 5 - 1 oder 10 - I, wobei weiter gilt

I steht nur vor X steht nur vor C steht nur vor

V L

X C oder M oder

oder

0

Im VI wird nun zuerst die römische Zahl (Zeichenkette) in ihre 'Ziffern' zerlegt. Ziffern können Grundzeichen (GZ: I, X, C, M), Hilfszeichen (HZ: V, L, 0) oder eine subtraktive

Kombination von GZ und HZ entsprechend den oben genannten Regeln sein. Die Zerlegung erfolgt schrittweise über einen regulären Ausdruck im oberen Bereich des Diagramms und

11 "'

11 •

1

I '" JiEl!Lt: @] �[g � ", ,

''''-J

,

�

-""

I

r

D�

)V ii

"

[I]

�I

1111 1

--lXldzei , cheQ iQnor;"r�n n

MOft"

,

R I

-A

Bild 18,32 Umwandlung einer römischen Zahl in eine Fließkommazahl

iefert als Ergebnis ein Array mit den römischen Ziffern. Die Zerlegung wird vorzeitig been­ l

det, wenn die Eingabe ein ungültiges Zeichen enthält. Dies wird erkannt, wenn der Ausgang 'vor übereinstimmung' der Funktion 'Regulären Ausdruck suchen' keine leere Zeichenkette

iefert l

.

Dann muss das letzte Element aus dem Ausgangsarray entfernt werden, da es bereits

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zentral- u 2009.07.31 21:42:39 +02'00'

392

18

Objektorientiertf Programmierung

die Ziffer nach einem ungültigen Zeichen ist. Liefert die Schleife ein leeres Array aus, war 'String' keine römische Zahl und das VI gibt 'Standard (0 DBL)' als 'Wert' zurück. Wurde eine römische Ziffer im Sinne der oben genannten Definition erkannt, erfolgt das Aufaddie­ ren. Dazu wird die Ziffer in ihre einzelnen Zeichen aufgespalten, wobei bei einem GZ oder HZ kein zweites Zeichen existiert, so dass die Funktion 'Teilstring' eine leere Zeichenkette iefert. l Auf diese Weise erhalten wir die dezimalen Werte für alle römischen Ziffern. ,,-otei �",tdffi •

[To;,+1

"

�

1 _'''''''''

&nzeiQfCh!!Xflz� r.. Qol. ��r . (;>

-."'.'_ "...0 ....

-

"

0,," �....

I

•

"....,,"'

,

�.

� '" '''''' �_ftort .

' 0'

rm ..•

..t()( �lm "'torl

�.-

.

;.,.

-."'.,_ ....

" ..

r'.i..

.

�

..",, "itün "

..

III

Bild 18AS Diagramm des Test-Vls für Berechnungen mit römischen und arabischen Strings

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zentral- u 2009.07.31 21:42:39 +02'00'

398

18

Objektorientiertf Programmierung

IAufgabe 18.5

Bauen Sie das oben beschriebene Projekt 'FvonX_Y.lvproj' von Anfang an auf.

IAufgabe 18.6

Schreiben Sie eine Rechenmethode für

Programm nach Aufgabe 18.5 ein.

F(x,y) = Jx1 + y2

und binden Sie diese in das

Merke: Die objektorientierte Programmierung (OOP) erlaubt in bestimmten Fällen eine sehr einfache Änderung bereits bestehender Prowamme zur Erweite­ rung ihres Funktionsumfangs.

Man kann sich die Hierarchie der verschiedenen Klassen anzeigen lassen, indem man im Kontextmenü von 'AbstrakteFunktion.lvelass' aufruft: 'Klassenhierarchie anzeigen'. Im Falle des Projekts 'FvonX_Y.lproj' erhält man eine Darstellung nach Bi l d 18.46.

1,"@ i ti W ii§..!i§fiii.!iJ

o

_

o1text

D x

e i>UI

Bild 18.46 Klassenhierarchie im Projekt 'FvonX_Y.lvproj'. Man erhält dieses Fenster, wenn man im Kontextmenü von 'AbstrakteFunktion.lvclass' aufruft: 'Klassenhierarchie anzeigen'. Der oberste Würfel stellt die LabVIEW-K1asse dar, darunter kommt 'AbstrakteFunktion.lvclass', dann die Klassen für die arabischen Grundrechenoperationen und ganz unten die für das Rechnen mit römischen Zahlen

1 8.4

Schutz einer Klassenbibliothek

In größeren Softwareprojekten wird oft auf bestehende Komponenten zurückgegriffen, die entweder selbst entwickelt oder von einem Drittanbieter zugekauft werden. Ein Drittanbieter wird seine Quellen dem Käufer nicht zugänglich machen, sondern sie vor unerlaubter VervielfaItigung schützen. Der Softwareentwickler kann aber anhand der bereitgestellten öffentlichen Methoden die Komponenten der im übrigen unbekannten Software nutzen und damit eigene Programme entwickeln. Das Erstellen von geeigneten Schnittstellen in der OOP, die eine einfache Nutzung erlauben, benötigt viel Erfahrung.

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zentral- u 2009.07.31 21:42:39 +02'00'

18.4 Schutz einer Klassenbibliothek

399

In LabVIEW kann man die Quellen vor unerlaubtem Einblick schützen, indem man ein Passwort verwendet. Dazu im Projekt-Explorer unter 'Build-Spezifikationen' den Punkt 'Neu' - 'Quelleodepaket' m i Kontextmenü auswählen. Man erhält Bi l d 18.47.

Ph!:cpIion {! Ern""', Zo'N''''''''"",, r �",oho. z""..,""frio _ _." r.;. �"'''' p 6ennercel....'..

__oehoo

r

HiF.

Bild 18.47 EigenschaftsfensterfOr 'Quellcodepaket'

Dieses Bild zeigt das Eigenschaftsfenster für das neu erzeugte 'Quelleodepaket' mit seinen Standardeinstellungen. Im Eingabefeld 'Name der Build-Spezifikation' wird der Name des Quellcodepakets eingegeben. Die LabVlEW-Voreinstellung 'Einzelnes Zielverzeichnis' der 'Paketoption' muss unbedingt nach 'Einzelnes Zielverzeichnis - Hierarchie bewahren' geändert werden,

lobVlEW: Dieses dynonosche s..tNI km rm 0U0Q0f0.nt _den, da.., benötigtes VI dot,� V_ffi

("Irrne< i>JS>C_ (" EnbeziefoeH

, 0

:e-

,

-

•

,

1�

• �

,

"' 'tJ. · � i � , � �- "."", ,..

".�

- ,

". �

>

" �-

�:t�:t-,e

oe-

,

•

,

+

-

-

'00

�

•

" "

-=

w

-

0

-

+

'w

-

"

2;1-,

+

QUldrotzahl.n

=

F E J.!J

,

" " "

H

"

. o.

,

--+-

--'-

" " "

06 1 ""

��

� ,

,

0

,

� ,

,

/

I R..,·,I

/" °

,

0

w

,

Bild 19.34 Grafik zur Reihe der Quadratzahlen in Spalte Ades Excel·Blatts

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zenlral- u 2009_07_31 21:42:39 +02'00'

19.3

Beispiele zurAnwendungaufExcel

419

7. Es folgen 'Extras' - 'Makro' -'Aufzeichnung beenden'. Damit ist ein Visual-Basic­

Programm erzeugt worden, das man sich mit 'Extras' - 'Makro' - 'Makros. . .' - 'Bearbei­ ten' anschauen kann, siehe Bi l d 19.35. Mit 'Extras' - 'Makro' -'Makros . . .' - 'Schritt' lässt sich das Makro debuggen. Über 'Extras' ­ 'Makro' -'Makros . . .' - 'Ausführen' kann man die Grafik auch dann neu erzeugen, wenn man vorher die manuell erstellte Grafik gelöscht hat. Natürlich ist es auch möglich, das Visual-Basic-Programm von Hand zu verändern, zu er­ weitern und umzuschreiben. In den Programmiermodus gelangt man mit 'Extras' - 'Makro' -'Makros. . .' - 'Bearbeiten'. Doch benötigt man dann einige Kenntnisse über Visual Basic, aufdie hier nicht näher eingegangen werden kann. �

.,.., . .

S"" 1 '' ' r' 01 1 ) JOo."'ol JOo.rro

"0«0

""

" . � ' . "'DI

von '1'"0rq1 .u'q" " o'.�t

.

Chorto >.dd >.ctinCho.rt.CMrtTypo - xHino >.cti....Cho.rt . SotSouoo.hto Souoo. , _Shoot. I "T_ Uo' ") , �onq. 1 "H, HO") .

,·.1C01,..,,,,, �ti...OC""rt.LocotiDn

_hon ,_xHoc.tia"" ""lo"t,

P10tBy

..... ,_"Tabo 1101"

U

ChorlOn" 1. , ChOr""",,", ,Tox" - "w""r�uah1.n" ".,(,lCat.""'T, ,lP"�a'T I . "',Titl� Tr,.,

-

.

bo, Ix1Vd1=, .lPri>'"ry) hi,Tit 10 ,Chonctoro. Toxt _ "x',,, 'r.d Uith te< L,tei ßei>ftd«1

I>

Projekt EHplorer T[P IvproJ

�E!Ii1

E:roie+1 I\ldlhffi

x B ra Pro,.... : TCP,�OI s. . Mffi COOV-tOl B f:) EmD : il clont,,; ii O""Uornecl.';

'\!llii E

,,-.tei �",tdffi AnzeiQffi Pro;e+1 AusfChen

:'.. [tl CIe

in

Projekt EHPIoo� T[P Ivproj --- --

s e 5emf_��1eC1ern il ""'vO!'_�Clbn",v;

L.. [U 5\01)

DiQltoi POft IrvJ: ond CVp\01) .. DI07:-I (NI '>\01) e E) Ar'J.>Iog IrvJ: B E) NI9215 .. AIO (NI 9215) � "'0 � C>robo.Yd Oxk L il AU>:),'; .. NI 9215 (Siot 1)

' � ==�

: .i:; Buid-5peztMtünef1 "l �lffi , .i:; Buid-5peztMtünef1

Bild 21..28 Projekt-Explorer nach Abschluss der Vorbereitungen für die Programmierung

8. Nun sind 'AufruCFPGA.vi' und 'AI_DO.vi' zu erstellen. Bild 21.29 und Bild 21.30 zeigen Diagramm und FrontpaneJ von 'AufruCFPGA.vi'. Man erkennt, dass dieses Programm Daten an 'AI_DO.vi' überträgt, und zwar 'AI Scan Rate (uSec)', 'Schwelle', 'Signal' und 'FPGA Stop'. Dazu braucht man Funktionen, die unter 'Functions' - 'FPGA Interface' (letzte Zeile) zu finden sind, nämlich: 'Open FPGA VI Reference', 'ReadIWrite Control' und 'Close FPGA VI Reference'. Im Kontextmenü des zunächst noch leeren Symbols für das Eröffnen der Referenz wählt man 'SeJect VI'. Dann erhält man ein Fenster, das alle im Projekt unter 'FPGA Target...' verfügbaren Vls anzeigt. In unserem Fall ist das lediglich 'ACDO.vi'. Man markiert es und quittiert mit 'OK'. Man bekommt nun ein Symbol wie

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zentral- u 2009_07_31 21:42:39 +02'00'

476

21

Compacl RIO-System und FPGA

n i Bild 21.29. Entsprechend verf ahrt man mit der Schreib-/Lesefunktion n i der Mitte des Diagramms. 'ReadlWrite Control' holen und zuerst mit 'Open FPGA VI Reference' ver­ binden, dann aufziehen auf vier Kästchen mit der Inschrift 'Unselected'. Dort m i jeweili­ gen Kontextmenü 'Controls' sowie die gewünschte Variable wählen. Angezeigt werden alle existierenden Bedien- und Anzeigeelemente von 'AI_DO.vi'. Das Programm 'Auf­

ruCFPGA.vi' kann 'AI_DO.vi' starten und stoppen. Der Start erfolgt im TRUE-Rahmen der Case-Struktur. Wird der Schalter 'FPGA' auf'AUS' gestellt, durchläuft das VI den na­ hezu leeren FALSE-Rahmen. In ihm ist lediglich eine lokale Variable von 'Stopp' zu fin­ den, damit man das Programm auch stoppen kann, wenn 'ACDO.vi' gerade nicht läuft.

Bild :n.29 Diagramm von 'AufrufJPGA.vi'

"'''- ''-1-)

." ., .... ,- , �

iAooo "'_

-

E3

.-

� - �

.= .�

i ::-: -

"

,,,..

Bild21.30 Frontpanel von 'AufrufJPGA.vi', zeigt Sinuskurve des Funktionsgenerators von knapp 300 Hz an. Die Kurve ist unregelmäßig, weil die Übertragung per Internet nicht schnell genug ist 9. Bild 21.32 zeigt das Diagramm von 'AI_DO.vi'. Bei der Entwicklung dieses Programms ist zunächst zu beachten, dass beim Erstellen des VI nur eine eingeschränkte Funktions­ palette nach Bi l d 21.23 erscheint. Dort hat man n i 'FPGA 1/0' eine Auswahl nach Bild 21.31.

Ausleihe: 31_07_2009 00:00:00 - 08_08_2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO, Zenlral- u 2009_07_31 21:42:39 +02'00'

21.3

Programmierbeispiele

477

FPGA l/ONode FPGAl/OPro• . • FPGAl/OMot.••

Bild 21.31 Auswahl für FPGA-Programme unter 'Functions' -' Programming' - 'FPGA 1/0'

Man zieht nun einen 'FPGA 1/0 Node' ins Diagramm und findet n i dessen Kontextmenü unter 'SeJect FPGA 1/0' - 'Analog Input' - '9215' den Analogeingang 'AIQ'. Bestätigt man dies, erhält man ein Symbol für den Analogeingang wie in der Mitte von Bild 21.32

zu

sehen. Entsprechend findet man '0100' als Ausgang. Das Setzen der Datenrichtungen der digitalen Leitungen 0 bis 7 ganz links m i Diagramm bewirkt man mit dem Methoden­

knoten 'FPGA 1/0 Method Node'. Im Kontextmenü wählt man 'SeJect Item' - 'NI 9401' und dann 'Select Method' und 'Set Line Direction'. Wir hatten die Leitungen 0 bis 3 als Ausgänge und die restlichen Leitungen als Eingänge vorgesehen. Das ist willkürlich, doch kann nicht jede Leitung individuell gesetzt werden. Die Gruppierung n i Vierer-Blöcke ist von der Hardware vorgeschrieben, wie man dem Bedienungsheftchen entnehmen kann. Zu erwähnen ist noch, dass man das Metronom im linken Teil der Sequenz in Bild 21.32 unter 'Functions' - 'Programming' -'Timing' findet.

[��::�:::�!��!:�[�:;,]

m

�

�

.�

"

Bild 21.32 Diagramm von 'AI_DO.vi' 10. Nun schreibt man 'ACDO.vi' in das FPGA, indem man es wie ein normales VI startet. Damit setzt kommt ein übersetzungsprozess in Gang, der auch den Xilinx'"-Kompiler aufruft. Wie schon eingangs erwähnt, dauert diese Software-Hardware-Transformation auch bei einem einfachen VI wie dem unseren fünf Minuten oder mehr. Zwei Fenster er­ scheinen, die über den Fortschritt des Prozesses informieren (Bild 21.33 und Bild 21.34). I>

[ompol.,g VI fo, FPGA

Bild 21.33 Erstes Fenster, das sich beim Start eines noch nicht übersetzten FPGA-Vls öffnet Bei erfolgreicher Kompilierung öffnet sich ein drittes Fenster mit dem n i Bild 21.35 dar­ gestellten Schlussprotokoll. Mit 'OK' schließt man dieses Fenster. Einige Sekunden da­ nach verschwindet automatisch Fenster 1. Gleichzeitig wird das Programm 'AI_DO.vi' gestartet. Auf dem Oszilloskop sieht man nun die eingelesene Sinusspannung und die erzeugte Rechteckspannung, die von 000 über Pin 14 des Steckers des 940 1 auf Kanal 1 dieses Geräts gelangt, siehe Bild 21.36.

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zentral- u 2009.07.31 21:42:39 +02'00'

478

21

Compacl RIO-System und FPGA

I> lob."," 'PGA (o"'.�o S.."", 0.2 -----SI.." ...

11\.os 2001 G9:53:'II l", �ote Tne

1\.(15 2001 09:55:01 00'...

Fa'

Ili'!ztJg E,Uy

"'" do r

Hl f -7,2011

Bild 21.38 Frequenz der ein­ gelesenen $inusfunktion zu hoch. Bei 50 kHz funktioniert die Trigge­ rung nicht mehr korrekt

IAufgabe 21.2 'ACDO_ParalleJ.vi' von Anfang an programmieren, ebenso das aufrufende Programm zum Starten dieses FPGA-VIs. Beide Programme starten und Ergebnis am Oszi l loskop beobachten.

Merke: FPGA-Programme für das cRIO-9012-System zeigen eine eingeschränkte Funktionspalette. Es gibt z.B. keine Umgebungsvanablen. Auch die Gleit­ kommaarithmetik existiert nicht. Dafür gibt es spezielle ElWeiterungen, z.B. für sehr schnell arbeitende echtzeitgesteuerte Schleifen oder für anaJoge und digitale Ein-'Ausgabe. Diese Funktionen fehlen in der Funktionspalette �ewöhnlicher VIs, auch

wenn sie aufdem cRIO-9012 Iaufen. Nur unter 'Functions' - 'FPGA Interface'

(und unter 'Functions' - 'Real-Time') findet man Funktionen zum Aufruf der FPGA-Routinen (und zur Zeitsteuerung).

Merke: Bei der Übersetzung eines FPGA-Programms für das cRIO-9012-System legt der Kompiler unterhalb des aktuellen Verzeichnisses ein Unterverzeichnis 'FPGA Bitfiles' an, in dem er den bei der Übersetzung erzeugten Binärcode als so genanntes Bitfile mit der Erweiterung 'lvbit' ablegt.

21.3.3

FPGA-Anwendung auf dem cRI0-9012 ohne LaptopunterstOtzung

Wir woUen nun die Anwendung aus dem vorigen Abschnitt autonom auf dem cRIO-9012 laufen lassen, d.h. auch nach Lösen der TCP/IP-Verbindung zum Laptop. Außerdem soll diese Anwendung automatisch starten, wenn wir das RIO-System mit Spannung versorgen. Folgende Schritte sind zu gehen: 1. Am einfachsten kopieren wir das Projekt 'RIO_FPGA.lvproj' unter dem neuen Namen 'RIO_FPGA_Autonom.lvproj', siehe Bi l d 21 .39.

Ausleihe: 31.07.2009 00:00:00 - 08.08.2009 00:00:00, ID:7ac0427dS92981cf089d91b1gecaOOaO. Zenlral- u 2009.07.31 21:42:39 +02'00'

21.3

Programmierbeispiele

481

AIO(N1921S)

-1Q""'�d doc'

Al..ooy........,; NI9215(SIotl)

NI 91(11 (Slot 2)

-� fIoAd.5pe�

Bild 21.39 Projekt für ein autonom auf dem cRI0-9012 arbeitendes FPGA­ VI. Beginn der Entwicklung

2. Wir benötigen nun das Bitfile von 'ACDO_ParaUe1.vi'. Am besten noch einmal über­ setzen und dann das BitfIle direkt hinter 'AufruCFPGA_Parallel.vi' m i Projekt-Explorer platzieren. Der Projekt-Explorer verändert sich damit entsprechend Bild 21 .40.

�"" �·"" " n... .. "" , "

Do;ll�lhelrw mOl1W DQt� PE/» /"0'

'''0' .0 ,0. ."" 0"0'

Bild 21.47 Nutzung von FTP im Windows lnternet Explorer.Man sieht dann die Struktur aufder Fest­ platte des cRIQ-9012

Besser arbeitet man allerdings mit dem Windows-Explorer, da man hier die Dateien wie n i einem gewöhnlichen Verzeichnis behandeln kann, also lesen, schreiben, löschen, verschie­ ben. Dazu geht man in der Symbolleiste des Internet Explorers auf 'Seite' und wählt m i Pull­ down-Menü 'FTP-Site in Windows-Explorer öffnen'. Man kommt so zu einer Darstellung nach Bild 21.48. a nu

1