LabVIEW 3 (Leseprobe) by Elektor

Nachdem in den Bänden LabVIEW 1: Einstieg in die Praxis und LabVIEW 2: Arrays und serielle Daten zur Einführung in LabVIEW ein breit gefächertes und solides Grundlagenwissen vermittelt wurde, stehen mit LabVIEW 3: Für den Praktiker fortgeschrittene Programmiertechniken auf dem Programm.

LabVIEW 3

LabVIEW

Die Entwicklung eigener Sub-VIs (Unterprogramme), das Arbeiten mit Schieberegistern und Zustandsautomaten und die Ereignisgesteuerte Programmierung stellen die Schwerpunkte des dritten Bandes dar.

●

• Die Erweiterung der LabVIEW-Funktionalitäten durch die Entwicklung eigener Sub-VIs Prof. Dr.-Ing. Bernd vom Berg und Dipl. Ing. Peter Groppe von der Technischen Hochschule Georg Agricola zu Bochum sind seit mehr als 20 Jahren auf dem Gebiet der technischen Lehre und Fortbildung tätig. Sie sind ebenfalls die Autoren des bekannten und erfolgreichen Elektor-Fernlehrgangs „Mikrocontroller leicht gemacht“.

• Der Einsatz von Schieberegistern leistungsfähiger Zustandsautomaten Ablaufstrukturen durch • Optimierte Ereignisgesteuerten Programmierung

zur

Erstellung

Anwendung

der

• Verwendung anspruchsvoller graphische Frontpanelelemente wie Signalverlaufsdiagramme, Signalverlaufsgraphen und XY-Graphen

FÜR DEN PRAKTIKER

LabVIEW

VOM BERG & GROPPE

Bernd vom Berg und Peter Groppe

FÜR DEN PRAKTIKER

• Die verschiedenen Methoden zur Datenspeicherung in Dateien mit Hilfe der vorhandenen Datei-I/O-Funktionen und -VIs

Abgerundet wird der Inhalt dieses Bandes durch Betrachtungen zu globalen Variablen. Alle im Buch entwickelten VIs sind frei vom Elektor-Server downloadbar. Ebenso steht dort ein Bonuskapitel zum freien Download zur Verfügung, in dem es um die komplette Steuerung von VIs über das Internet geht.

Elektor-Verlag GmbH 52072 Aachen www.elektor.de

• Die Synchronisierung von unabhängig parallel ablaufenden Prozessen durch Semaphoren, Melder oder Queues

DESIGN

ISBN 978-3-89576-320-5

Bernd vom Berg & Peter Groppe LEARN

DESIGN

LEARN

LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHA ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● GN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SH ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ● LEARN ● DESIGN ● SHARE ●

LabVIEW 3 Für den Praktiker

● Bernd vom Berg, Peter Groppe

an Elektor Publication LEARN

Labview3 DE 160517.indd 3

DESIGN

02-08-16 12:14

●

1. Auflage 2016

Die in diesem Buch veröffentlichten Beiträge, insbesondere alle Aufsätze und Artikel sowie alle Entwürfe, Pläne, Zeichnungen und Illustrationen sind urheberrechtlich geschützt. Ihre auch auszugsweise Vervielfältigung und Verbreitung ist grundsätzlich nur mit vorheriger schriftlicher Zustimmung des Herausgebers gestattet. Die Informationen im vorliegenden Buch werden ohne Rücksicht auf einen eventuellen Patentschutz veröffentlicht. Die in diesem Buch erwähnten Soft- und Hardwarebezeichnungen können auch dann eingetragene Warenzeichen sein, wenn darauf nicht besonders hingewiesen wird. Sie gehören dem jeweiligen Warenzeicheninhaber und unterliegen gesetzlichen Bestimmungen. Bei der Zusammenstellung von Texten und Abbildungen wurde mit größter Sorgfalt vorgegangen. Trotzdem können Fehler nicht vollständig ausgeschlossen werden. Verlag, Herausgeber und Autor können für fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung noch irgendeine Haftung übernehmen. Für die Mitteilung eventueller Fehler sind Verlag und Autor dankbar. Umschlaggestaltung: Elektor, Aachen Satz und Aufmachung: D-Vision, Julian van den Berg | Oss (NL) Druck: WILCO, Amersfoort (NL) Printed in the Netherlands

●

ISBN 978-3-89576-320-5

Elektor-Verlag GmbH, Aachen www.elektor.de

Elektor ist Teil der Unternehmensgruppe Elektor International Media (EIM), der weltweit wichtigsten Quelle für technische Informationen und Elektronik-Produkte für Ingenieure und Elektronik-Entwickler und für Firmen, die diese Fachleute beschäftigen. Das internationale Team von Elektor entwickelt Tag für Tag hochwertige Inhalte für Entwickler und DIYElektroniker, die über verschiedene Medien (Magazine, Videos, digitale Medien sowie Social Media) in zahlreichen Sprachen verbreitet werden. www.elektor.com

LEARN

Labview3 DE 160517.indd 4

DESIGN

02-08-16 12:14

Inhalt

Inhalt Kapitel 1 • Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 Kapitel 2 • Die VIs unter LabVIEW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 2.1 SubVIs (LabVIEW-Unterprogramme) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 2.1.1 Die direkte Neuerstellung von SubVIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 2.1.2 Einbinden eines SubVIs in ein anderes VI . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 2.1.3 Die Erstellung eines SubVIs aus Teilen eines bereits bestehenden VIs . . . . . . . . 25 2.1.4 SubVI-Feinheiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 2.1.4.1 Die Anzeige des Frontpanels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 2.1.4.2 Der Datenaustausch zwischen Haupt-VI und SubVI . . . . . . . . . . . . . . . . . . . . 50 2.2 Express-VIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 2.3 Assistenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 Kapitel 3 • Globale Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 3.1 Grundsätzliches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 3.2 Definition und Anwendung von globalen Variablen . . . . . . . . . . . . . . . . . . . . . . . 60 Kapitel 4 • Graphische Frontpanel-Elemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 4.1 Grundsätzliches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 4.2 Das Signalverlaufsdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 4.2.1 Grundlagen: Race Conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 4.2.2 Die Einspeisung von Daten und die Historienlänge . . . . . . . . . . . . . . . . . . . . . . 78 4.2.3 Die Ploteigenschaften und Beschriftungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 4.2.4 Die X-Achse als Zeitachse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 4.2.5 Die drei Aktualisierungsmodi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 4.2.6 Der Zufallszahlengenerator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 4.2.7 Die Darstellung mehrerer Plots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 4.2.8 Der Export von Plots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 4.3 Der Signalverlaufsgraph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 4.4 Der XY-Graph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 Kapitel 5 • Datei-I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 5.1 Grundsätzliches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 5.2 Details und erste Schritte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

●5

Labview3 DE 160517.indd 5

02-08-16 12:14

LabVIEW 3: Für den Praktiker 5.3 Praktische Beispiele: Einfache ASCII-Textdateien . . . . . . . . . . . . . . . . . . . . . . . 141 5.3.1 Daten schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 5.3.2 Daten lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 5.4 Praktische Beispiele: Tabellenkalkulationsdateien . . . . . . . . . . . . . . . . . . . . . . . 185 5.4.1 Daten schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185 5.4.2 Daten lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195 5.5 Praktische Beispiele: Binärdateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202 5.5.1 Daten schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202 5.5.2 Daten lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214 5.6 Das Arbeiten mit LVM-, TDMS- und ZIP-Dateien . . . . . . . . . . . . . . . . . . . . . . . . 218 5.7 Pfadakrobatik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218 Kapitel 6 • Einige Programmiertricks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224 6.1 Das Blinken von LEDs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224 6.2 Das Ausgrauen von Schaltflächen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228 6.3 Die Erstellung selbstdefinierter Anzeige- und Bedienelemente . . . . . . . . . . . . . . 230 Kapitel 7 • Neue Programmstruktur: Schieberegister . . . . . . . . . . . . . . . . . . . . . . . 244 7.1 Grundsätzliches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244 7.2 Schieberegister in LabVIEW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246 7.3 Das gestapelte Schieberegister . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253 7.4 Schieberegister und Rückkopplungsknoten . . . . . . . . . . . . . . . . . . . . . . . . . . . 255 7.5 Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258 Kapitel 8 • Fortgeschrittene Programmentwicklung - Der Zustandsautomat . . . . . . 263 8.1 Entwurfsmuster in LabVIEW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263 8.2 Zustand, Übergang, Zustandsdiagramm, Zustandsautomat . . . . . . . . . . . . . . . . 266 8.3 Der Zustandsautomat unter LabVIEW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274 8.4 Praktische Realisierungen - Beispiel 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278 8.4.1 Das Zustandsdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279 8.4.2 Das typdefinierte Enum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281 8.4.3 Die While-Schleife und die Case-Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . 282 8.4.4 Die Case-Unterdiagramme für die einzelnen Zustände . . . . . . . . . . . . . . . . . . 284 8.5 Beispiel 2: 4er-Übergang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290

●6

Labview3 DE 160517.indd 6

02-08-16 12:14

Inhalt 8.6 Beispiel 3: 10er-Übergang (10er-Tastatur) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296 8.7 Beispiel 4: Übergangsarray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305 8.8 Übung: Die Multifunktionsuhr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315 8.8.1 Die Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319 Kapitel 9 • Ereignisgesteuerte Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . 333 9.1 Grundsätzliches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333 9.2 Die Ereignisstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336 9.3 Meldeereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338 9.3.1 Ereignis ´Timeout´ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338 9.3.2 Ereignis ´Wertänderung´ - Klicken auf Schaltfläche . . . . . . . . . . . . . . . . . . . . 340 9.3.3 Ereignis ´Maustaste gedrückt´ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351 9.3.4 Ereignis ´Wertänderung´ - num. Eingabeelement (Schieber) . . . . . . . . . . . . . 354 9.3.5 Ereignis ´Taste gedrückt´ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355 9.3.6 Verarbeitung mehrerer Ereignisse in einem Case . . . . . . . . . . . . . . . . . . . . . . 357 9.4 Verarbeitung von Ereignissen im Haupt-VI . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359 9.5 Filterereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363 Kapitel 10 • Methoden zur Prozesssynchronisierung . . . . . . . . . . . . . . . . . . . . . . . . 371 10.1 Grundsätzliches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 10.2 Prozesssynchronisation ohne Datenaustausch . . . . . . . . . . . . . . . . . . . . . . . . 372 10.2.1 Semaphoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372 10.3 Prozesssynchronisation mit Datenaustausch . . . . . . . . . . . . . . . . . . . . . . . . . . 387 10.3.1 Melder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387 10.3.2 Queues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398 Kapitel 11 • VIs im Netz (Intranet/Internet) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403 Kapitel 12 • Literatur und Bezugsquellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404 Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405

●7

Labview3 DE 160517.indd 7

02-08-16 12:14

Kapitel 1 • Einleitung

Kapitel 1 • Einleitung In unseren ersten beiden Bänden zur Einführung in LabVIEW haben wir ein breites und solides Grundlagenwissen vermittelt, auf dem wir jetzt weiter aufbauen werden. Fortgeschrittene Programmiertechniken stehen jetzt auf dem Programm: Die Entwicklung eigener SubVIs, das Arbeiten mit Schieberegistern und Zustandsautomaten und die ereignisgesteuerte Programmierung werden ausführlich behandelt. Auch die Erstellung anspruchsvoller graphischer Frontpanelelemente, die Behandlung der Datenspeicherung mittels Datei-I/O-Funktionen und die Methoden zur Prozesssynchronisierung durch Semaphore, Melder und Queues kommen selbstverständlich nicht zu kurz. Abgerundet wird der Inhalt dieses Bandes durch Betrachtungen zu globalen Variablen. Alle hier entwickelten VIs stehen selbstverständlich kostenfrei auf dem Elektor-Server zum Download bereit, und als ´dickes Bonbon´ für unsere treuen Leser haben wir dort noch ein zusätzliches hochinteressantes Kapitel platziert, in dem die komplette Steuerung von VIs über das Intranet bzw. Internet behandelt wird. Bleiben Sie also gespannt!

Bernd vom Berg Peter Groppe Herne, Kettwig – im Mai 2016

●9

Labview3 DE 160517.indd 9

02-08-16 12:14

LabVIEW 3: Für den Praktiker

Kapitel 2 • Die VIs unter LabVIEW In diesem ersten Kapitel beschäftigen wir uns etwas genauer und ausführlicher mit dem ´VI-Begriff´ unter LabVIEW. Sie werden sehen, dass es nicht nur die eigenen selbstgeschrieben VIs gibt, sondern sich hinter dem VI-Begriff noch Einiges mehr verbirgt. 2.1 SubVIs (LabVIEW-Unterprogramme)

SubVIs (Unter-VIs von LabVIEW) sind nun nichts anderes als Unterprogramme, wie man sie von den klassischen Programmiersprachen her kennt. Und damit steht der Verwendungszweck solcher SubVIs schon fest. SubVIs werden eingesetzt: • für Programm- bzw. VI-Teile, die in größeren VIs an mehreren Stellen in gleicher Art und Weise benutzt werden, z.B. komplexe Berechnungen, graphische Aufbereitung von Daten etc., • für Programm- bzw. VI-Teile, die in verschiedenen unterschiedlichen VIs immer gleich eingesetzt werden sollen, z.B. einheitliche Schnittstelleninitialisierungen, Betrieb von externen Messgeräten, Messwerterfassung, -verarbeitung, -abspeicherung etc., • und wenn Teile von größeren VIs zu einzelnen Blöcken zusammengefasst (komprimiert) werden sollen, um die Darstellung auf dem Blockdiagramm zu verbessern. All dies erhöht unter LabVIEW die Übersichtlichkeit des Gesamt-VIs und ermöglicht letztendlich die Entwicklung sehr kompakter, leistungsfähiger VIs. Merke: LabVIEW-SubVIs Solch ein neues SubVI kann dann, wie gewohnt, ganz normal als Funktion aus einer Funktionspalette in das Blockdiagramm eines anderen VIs eingefügt, verdrahtet und somit beliebig oft weiterverwendet werden. In den bisher entwickelten VIs haben Sie schon vielfach unbewusst SubVIs eingesetzt, denn jeder LabVIEW-Knoten (LabVIEW-Funktionsblock) ist im Prinzip ein SubVI (Unterprogramm), Abbildung 2.1.1:

● 10

Labview3 DE 160517.indd 10

02-08-16 12:14

Kapitel 2 • Die VIs unter LabVIEW

Abbildung 2.1.1: Die Addition als LabVIEW-SubVI Beispiel: Die (einfache) Addition ist nichts anderes als ein bereits fertig vorliegendes, systemeigenes LabVIEW-SubVI. Solch ein SubVI besitzt nun immer drei grundlegende Elemente: 1. die (interne) Funktion des SubVIs (Was tut das SubVI eigentlich? Hier addiert es zunächst zwei Zahlen.) 2. die Ein- und Ausgänge des SubVIs 3. das passende, aussagekräftige und ansprechende graphische Symbol für das SubVI (Dieses Symbol erscheint dann im Blockdiagramm, wenn mit dem SubVI bzw. mit der LabVIEW-Funktion gearbeitet werden soll.) LabVIEW ermöglicht dem Anwender nun, nach seinen Vorstellungen eigene neue SubVIs zu entwickeln und einzusetzen. Dazu sind dann lediglich drei (einfache) Entwurfsschritte notwendig: 1. Festlegung der gewünschten Funktion des SubVIs 2. Festlegung der Ein- und Ausgänge des SubVIs 3. Kreation eines ´schönen, passenden´ Symbols für das SubVIs Alternativ kann man als zweite Methode für den Entwurf eines SubVIs einen Teil aus einem bereits bestehenden VI ´herausschneiden´ und diesen dann als neues eigenständiges SubVI definieren. Darüber hinaus haben die Entwickler von LabVIEW selber bereits schon eine ganze Menge fertiger, sehr leistungsstarker SubVIs beigesteuert, mit denen sich die Leistungsfähigkeit eines VIs schlagartig erhöhen lässt. Diese in LabVIEW in verschiedenen Paletten enthalten SubVIs haben besondere Namen

● 11

Labview3 DE 160517.indd 11

02-08-16 12:14

Kapitel 3 • Globale Variablen

Kapitel 3 • Globale Variablen 3.1 Grundsätzliches

Beginnen wir mit einer kleinen Wiederholung: Lokale Variablen Die sogenannten ´lokalen Variablen´ haben Sie bereits in unserem LabVIEW-Band 1 ab der Seite 160 kennengelernt: • Mit lokalen Variablen werden Daten von einer Stelle zu einer anderen Stelle innerhalb des Blockdiagramms eines VIs übertragen, ohne das hierzu irgendwelche Verbindungsleitungen gezogen werden müssen. Das Blockdiagramm wird dadurch oft übersichtlicher. • Es gilt unbedingt zu beachten, dass nur zu bereits vorhandenen Frontpanel-Elementen, also bereits vorhandenen Anzeige- und Bedienelementen auf dem Frontpanel, lokale Variablen definiert werden können. • Wenn man z.B. zu Zwischenwerten, die gar nicht auf dem Frontpanel angezeigt werden sollen, lokale Variablen definieren möchte, besteht ein hilfreicher Trick darin, für diese Zwischenwerte zunächst Anzeige- bzw. Bedienelemente zu erstellen und dann dazu die zugehörigen lokalen Variablen zu definieren. Auf dem Blockdiagramm ruft man dann das Kontextmenü zu diesem eigentlich ´unerwünschten´ Anzeige- bzw. Bedienelement auf und wählt dort ´Bedienelement ausblenden´ bzw. ´Anzeigeelement ausblenden´. Auf diese Weise ´verschwinden´ dann die reinen Darstellungen dieser Elemente auf dem Frontpanel und man kann trotzdem mit den lokalen Variablen im Blockdiagramm arbeiten. • Weitere Informationen zu lokalen Variablen und deren Verwendung finden Sie in Band 1 unserer LabVIEW-Lehrbuchreihe (ISBN 978-3895762536) ab Seite 160ff. Globale Variablen Demgegenüber ist das Einsatz- und Verwendungsgebiet von ´globalen Variablen´ wesentlich weiter gesteckt: zwischen unterschiedlichen Rechner ausgeführt werden.

*0 S ie dienen dem Austausch von Daten VIs, die aber auf ein und demselben

*1 M it ihnen lassen sich auf geschickte Weise problemfrei Daten zwischen HauptVI und SubVI (das im selben Haupt-VI aufgerufen wurde) austauschen. (Hier erfolgt die Verwendung von globalen Variablen wie in einer höheren Programmiersprache, z.B. in ´C´, wo mit globalen Variablen Daten zwischen der ´main´-Funktion und den anderen Funktionen bzw. zwischen allen anderen C-Programmteilen ausgetauscht werden können.)

● 57

Labview3 DE 160517.indd 57

02-08-16 12:14

LabVIEW 3: Für den Praktiker

Das Grundprinzip beim Arbeiten mit globalen Variablen unter LabVIEW zeigt die Abbildung 3.1.1: Eigene Datei bzw.

eigenes, spezielles VI, das alle globalen Variablen enthält

VI-1

VI-2

…..

VI-n

Abbildung 3.1.1: Das Grundprinzip des Arbeitens mit globalen Variablen Alle globalen Variablen werden in einer eigenen, separaten Datei abgelegt. Auf diese Datei, und somit auf alle dort hinterlegten globalen Variablen, können nun alle VIs lesend bzw. schreiben zugreifen. Auf diese Weise wird ein einfacher Datenaustausch zwischen den VIs realisiert und zwar ganz ohne Datenflussabhängigkeit bei allen Beteiligten! Unter LabVIEW handelt es sich bei der gerade erwähnten Datei mit den globalen Variablen nicht um eine Datei im eigentlichen Sinnen, sondern um ein eigenes, spezielles VI, das die von Anwender definierten globalen Variablen quasi als Container aufnimmt. Man erkennt hier aber schon sofort das gravierende Problem dieses Konzeptes: Was geschieht eigentlich, wenn mehrere dieser unabhängig voneinander ablaufenden VIs gleichzeitig lesend und/oder schreibend auf die gleiche globale Variable zugreifen ? Welchen Wert hat die globale Variable nach allen Zugriffen ? Solche Situationen müssen also entweder auf jeden Fall vermieden werden oder es muss ein geregelter Zugriff auf solche gemeinsam genutzten Variablen erfolgen. Mit der zweiten Möglichkeit der Zugriffssteuerung beschäftigen wir uns später im Kapitel 9. In den nachfolgenden Betrachtungen gehen wir davon aus, dass kein gleichzeitiger Zugriff von mehreren Seiten auf globale Variablen erfolgt, d.h., es wird als sicher angenommen bzw. so programmiert, das zu jeden Zeitpunkt immer nur ein VI eindeutig eine globale Variable beschreibt bzw. deren Wert ausliest. Im Detail Die Abbildung 3.1.2 zeigt nun etwas detaillierter das Arbeiten mit globalen Variablen aus LabVIEW-Sicht:

● 58

Labview3 DE 160517.indd 58

02-08-16 12:14

LabVIEW 3: Für den Praktiker

Kapitel 4 • Graphische Frontpanel-Elemente 4.1 Grundsätzliches

Ein Frontpanel wird erst dann zu einem leistungsfähigen und aussagekräftigen Frontpanel, wenn erfasste Daten (Messwerte, Zustandswerte, andere Prozessdaten) auch graphisch-farbig aufbereitet und dargestellt werden. Und LabVIEW wäre nicht LabVIEW, wenn es nicht auch hier eine Fülle von Möglichkeiten gäbe, um Daten graphisch in Form von Diagrammen und Kurven (Plots) darzustellen. In der Unterpalette: FP\Modern\Graph sind diese Möglichkeiten der graphischen Visualisierung von Daten aufgeführt, Abbildung 4.1.1:

Abbildung 4.1.1: Die Möglichkeiten zur graphischen Visualisierung von Daten Aus der Menge dieser Darstellungsarten werden wir nachfolgend die drei am häufigsten verwendeten Möglichkeiten näher betrachten: 1. Signalverlaufsdiagramm (´Diagramm´) mit den drei Unterarten: - Streifendiagramm - Oszilloskopdiagramm - Laufdiagramm 2. Signalverlaufsgraph (´Graph´) 3. XY-Graph Die Funktionsweisen der restlichen Darstellungen lassen sich mit der LabVIEW-Hilfe und durch ´reichliches Rumprobieren´ ermitteln.

● 70

Labview3 DE 160517.indd 70

02-08-16 12:14

Kapitel 4 • Graphische Frontpanel-Elemente

4.2 Das Signalverlaufsdiagramm

Merke: Das Signalverlaufsdiagramm 1. Beim Signalverlaufsdiagramm werden fortlaufend (kontinuierlich) erfasste Daten sofort in einem Diagramm dargestellt. Sie werden dabei immer von links nach rechts geschrieben, d.h., die jeweils neuen Datenpunkte werden an die bereits vorhandenen Datenpunkte fortlaufend angehängt. 2. Die Daten selber werden hierbei mit einer konstanten Erfassungs- bzw. Abtastrate erfasst. 3. Auf der Y-Achse des Diagramms werden die Daten (z.B. die Messwerte) eingetragen. 4. Die Werte auf der X-Achse beginnen automatisch immer bei ´0´ und werden bei jedem neuen Wert einfach um ´1´ erhöht (z.B. beim Durchzählen der Messwerte). Alternativ kann man auch einen Anfangswert und ein Δx zur automatischen Erhöhung vorgeben. 5. Dabei können sowohl nur eine Kurve (Plot) als auch mehrere Kurven (Plots) gleichzeitig dargestellt werden. Fazit: Ein Diagramm übernimmt sofort einzelne Werte und gibt diese der Reihe nach, Punkt für Punkt hintereinander, dynamisch aus (≡ fortlaufende, kontinuierliche Signaldarstellung der Y-Werte von links nach rechts). Die zugehörigen Werte auf der X-Achse werden dabei gleichverteilt, d.h. mit gleichen Abständen zwischen den Punkten versehen, wie z.B. bei zeitabhängigen Signalen, die zu gleichen Zeitabständen abgetastet (erfasst) werden. Beispiele: für den Einsatz von Diagrammen: - Darstellung von Messwerten, die alle 100 ms erfasst werden: Y-Achse: Messwerte X-Achse: Zeiteinteilung - Hierbei wird der gerade aktuell erfasste Messwert an die bereits erfassten Messwerte rechts angefügt und der neue Messwert so direkt im Zusammenhang mit den früheren Messwerten dargestellt.

-G anz allgemein die Darstellung einer Größe (Y) als Funktion bzw. in Abhängigkeit von einer anderen Größe (X). Hinweis: Unter LabVIEW werden alle Diagramme standardmäßig mit schwarzem Hintergrund und weißer Plotlinienfarbe dargestellt. Dies ist für die optimale Darstellung auf dem Monitor geeignet, für den Ausdruck dieser

● 71

Labview3 DE 160517.indd 71

02-08-16 12:14

LabVIEW 3: Für den Praktiker

Kapitel 5 • Datei-I/O 5.1 Grundsätzliches

Nachdem wir uns in allen vorhergehenden LabVIEW-Kapiteln schwerpunktmäßig mit der Erzeugung bzw. der Erfassung und der (graphischen) Darstellung von Daten beschäftigt haben, kommen wir nun zum dritten großen Aspekt der Datenverarbeitung: dem Abspeichern von Daten in Dateien auf verschiedenen Speichermedien und dem bedarfsgerechten Wiederauslesen der Daten. Dazu zunächst einige grundlegende Ausführungen: Der Vorgang: ´Daten abspeichern bzw. Daten auslesen´ Es gibt grundsätzlich zwei verschiedene Abläufe, auch Datei-I/O (In/Out) genannt, um Daten in Dateien zu speichern bzw. Daten aus Dateien wieder herauszulesen: Standard-Datei-I/O Hierbei werden folgende Schritte durchgeführt: 1. Eine Datei wird neu erstellt bzw. eine schon vorhandene Datei wird geöffnet. 2. Es wird immer nur ein Datum in die Datei geschrieben bzw. ein Datum aus der Datei ausgelesen. 3. Die Datei wird geschlossen. Nach jedem Schreiben bzw. Lesen eines Datums folgt also immer wieder der Vorgang des Schließens der betreffenden Datei. 4. Es wird überprüft, ob während des Datei-Handlings Fehler aufgetreten sind. Wenn also z.B. 100 Daten (100 Datensätze) in dieser Art und Weise in eine Datei abgespeichert werden sollen, sind diese Schritte 100 Mal hintereinander durchzuführen, d.h., die Datei wird 100 Mal geöffnet, jedes Datum wird einzeln hineingeschrieben, die Datei wird 100 Mal wieder geschlossen und 100 Mal wird auf Fehler überprüft. Das kostest unter Umständen (sehr) viel Zeit. Durch die zweite Möglichkeit der Datei-I/O lässt sich ein Großteil dieser Zeit einsparen … Streaming-Datei-I/O Hierbei ist der Ablauf folgender: • Eine Datei wird neu erstellt bzw. eine schon vorhandene Datei wird geöffnet. • Alle gewünschten Daten werden fortlaufend, hintereinander als kontinuierlicher Datenstrom (≡ Stream) in die Datei geschrieben bzw. aus der Datei ausgelesen. Während dieses fortlaufenden Schreibens bzw. Lesens der Daten bleibt die Datei also immer geöffnet.

● 122

Labview3 DE 160517.indd 122

02-08-16 12:15

Kapitel 5 • Datei-I/O

• Dann wird die Datei geschlossen. • Und abschließend wird überprüft, ob Fehler aufgetreten sind. Mit anderen Worten: Das Öffnen der Datei, das Schließen der Datei und die Fehlerüberprüfung wird nur jeweils einmalig durchgeführt, und das spart erheblich Zeit. Welche Möglichkeit der Datei-I/O genutzt wird, ist abhängig von der jeweiligen Anwendung: • Wenn Daten sehr schnell hintereinander erfasst und abgespeichert werden sollen, bietet sich das Streaming-Verfahren an, da keine Zeiten für das wiederholte Öffnen bzw. Schließen der Datei aufgewendet werden müssen. Das gilt entsprechend auch für das kontinuierliche, sukzessive Auslesen von Daten. • Wenn Daten aber (sporadisch) in unregelmäßigen Zeiten abgespeichert bzw. ausgelesen werden sollen, ist das Standardverfahren sinnvoller, da hierbei die Datei nicht permanent geöffnet bleibt, sondern immer wieder geschlossen (gesichert) wird. • Wenn ein großer Datensatz einmalig, ´in einem ´Rutsch´, abgespeichert bzw. ausgelesen werden soll, lässt sich auch hierbei das Standardverfahren gut anwenden. LabVIEW-Funktionen zum Abspeichern bzw. Auslesen von Daten Zur Realisierung der beiden gerade erläuterten Möglichkeiten der Datenspeicherung (und des Datenauslesens) steht bei LabVIEW ein ganzer Satz von • fertigen Funktionen, • fertigen VIs und • fertigen Express-VIs zur Verfügung, die sich grundsätzlich in zwei große Gruppen aufteilen lassen, die im Folgenden erläutert werden. High-Level-Datei-I/O Diese Art von VIs und Express-VIs bieten dem Anwender einen großen Komfort, denn die vier grundlegenden Schritte des Standard-Datei-I/O-Zugriffs - Datei öffnen, Datum schreiben, Datei schließen, Fehler auswerten - werden automatisch, ´in einem Rutsch´, komplett hintereinander, im Hintergrund von LabVIEW durchgeführt. Der Anwender selbst muss sich um diese Details nicht weiter zu kümmern: • Beim Schreiben von Daten übergibt er lediglich den Pfad zur gewünschten Datei und die zu schreibenden Daten. Den Rest erledigt das High-Level-VI bzw. das High-Level-Express-VI.

● 123

Labview3 DE 160517.indd 123

02-08-16 12:15

LabVIEW 3: Für den Praktiker

Kapitel 6 • Einige Programmiertricks In diesem Kapitel machen wir Sie mit einigen weiterführenden Programmiertricks unter LabVIEW vertraut, die Sie in den nachfolgenden Kapiteln noch sehr sinnvoll einsetzen können. Im Einzelnen werden wir uns mit folgenden Themen befassen: • Blinken von LEDs • Ausgrauen von Schaltflächen • Erstellung von selbstdefinierten Anzeige- und Bedienelementen Und hierbei werden Sie erneut verstärkt mit Eigenschaftsknoten in Berührung kommen. 6.1 Das Blinken von LEDs

Zum Signalisieren von bestimmten Zuständen lässt man sehr häufig verschiedenfarbige LEDs auf dem Frontpanel blinken. Im Band 1 auf S.20 haben wir solche blinkenden LEDs mit Hilfe des sogenannten Rückkopplungsknoten realisiert. Dies ist ein wenig umständlich und vor allen Dingen lässt sich das Blinken nicht beliebig per Programm ein- und ausschalten. Nun stehen uns bessere Möglichkeiten zur Verfügung, denn es gibt einen passenden Eigenschaftsknoten für das Blinken von LEDs. Öffnen Sie ein neues VI namens ´LED-1.vi´: • Platzieren Sie auf dem Frontpanel (formatfüllend) eine runde LED. • Wählen Sie für den Zustand Éin´ die Farbe ´Blau´ und für den Zustand Áus´ die Farbe ´Rot´. • Schließen Sie an diese LED einen vertikalen Umschalter an, mit dem Sie diese LED umschalten können. • Beschriften Sie diesen Schalter mit ´LED-Zustand´, ÉIN´ und ÁUS´. • Stellen Sie den Schalter auf ÉIN´. Erstellen Sie nun zu dieser LED über das zugehörige Kontextmenü einen Eigenschaftsknoten ´Blinkend´, Abbildung 6.1.1:

● 224

Labview3 DE 160517.indd 224

02-08-16 12:15

Kapitel 6 • Einige Programmiertricks

Abbildung 6.1.1: Der Weg zur blinkenden LED Ändern Sie die Transferrichtung dieses Knotens in ´Schreiben´ und schließen Sie dort ebenfalls einen vertikalen Umschalter an. Beschriften Sie diesen Umschalter mit ´Blinkend´, ÉIN´ und ÁUS´ und stellen Sie den Schalter auf ÁUS´. Legen Sie um alle Elemente auf dem Blockdiagramm eine While-Schleife mit Stopp-Taster. Das Ergebnis sollte ungefähr so aussehen, Abbildung 6.1.2:

Abbildung 6.1.2: Die blinkende LED

(´LED-1.vi´)

Starten Sie das VI und überprüfen Sie mit dem LED-Zustandsschalter, ob die LED-Farben stimmen: ÉIN´ = blau und ÁUS´ = rot. Schalten Sie den LED-Zustandsschalter auf ÉIN´ und schalten Sie den Blinkschalter ebenfalls auf ÉIN´. Zwei ´Dinge´ fallen sofort auf: • Das Blinken ist recht langsam und • die Blinkfarben sind blau und gelb (!). Schalten Sie den LED-Zustandsschalter auf ÁUS´: Nun blinkt die LED rot und gelb (!).

● 225

Labview3 DE 160517.indd 225

02-08-16 12:15

LabVIEW 3: Für den Praktiker

Kapitel 7 • Neue Programmstruktur: Schieberegister 7.1 Grundsätzliches

Wenn in einem LabVIEW-VI For- und While-Schleifen eingesetzt werden, ergibt sich oft die Notwendigkeit, dass Werte von einem Schleifendurchlauf zum nächsten Schleifendurchlauf weiter gereicht und dann im Schleifenkörper erneut be- bzw. verarbeitet werden müssen. Ganz allgemein lässt sich eine solche Situation am Beispiel eines dreifachen Schleifendurchlaufs wie folgt darstellen, Abbildung 7.1.1:

Abbildung 7.1.1: Die allgemeine Grundsituation: Werteübergabe von einem Schleifendurchlauf an den nächsten Schleifendurchlauf Mit einem bestimmten, eindeutig festgelegtem Anfangswert (Startwert, Initialisierungswert) startet die gesamte Bearbeitung. Anschließend wird dann nach dem Grundprinzip ´links rein – rechts raus´ weiter fortgefahren, d.h., die Berechnungsergebnisse, die rechts am Ende eines Schleifendurchlauf entstehen, werden links wieder für neue Berechnungen in den nächsten Schleifendurchlauf eingespeist. Und genau dies ist die allgemeine Funktionsweise eines sogenannten ´Schieberegisters´: Ergebnisdaten werden auf der einen Seite eines Berechnungsdurchlaufes rausgeschoben und auf der anderen Seite wieder für neue Berechnungen in den nächsten Durchlauf reingeschoben. Ein solches Schieberegister ist unter LabVIEW als eigener Datentyp vorgesehen, der dazu dient, Werte zwischen jeweils zwei Schleifendurchläufen abzuspeichern. Ein etwas konkreteres Beispiel soll den entsprechenden Ablauf noch einmal weiter verdeutlichen. Beispiel: Die Zahlen von 1 bis 5 sollen aufaddiert und das Endergebnis angezeigt werden. Wir realisieren die Lösung zunächst einmal gedanklich mit Hilfe einer For-Schleife, die aus

● 244

Labview3 DE 160517.indd 244

02-08-16 12:15

Kapitel 7 • Neue Programmstruktur: Schieberegister

insgesamt fünf Durchläufen der folgenden Art besteht, Abbildung 7.1.2 (wir verwenden hier nicht den bereits im ersten Band eingeführten Rückkopplungsknoten):

Abbildung 7.1.2: Die konkrete Arbeitsweise eines Schieberegisters Man erkennt hier bereits die typischen Merkmale eines solchen Schieberegisters: • Beim allerersten Schleifendurchlauf wird ein bestimmter Wert als Anfangswert (Startwert, Initialisierungswert) eingespeist. • Der berechnete Ergebniswert (Ausgabewert) des Schleifendurchlaufs wird ´rechts´ ausgegeben und ist somit der neue Eingabewert, der ´links´ in den nächsten Schleifendurchlauf eingespeist wird. Unter LabVIEW hat ein solches Schieberegister noch weitere wesentliche Eigenschaften: • Schieberegister werden vorzugsweise in Verbindung mit For- und While-Schleifen eingesetzt. • Mit einem Schieberegister können beliebige Datentypen verarbeitet, also eingespeist und ausgegeben werden, nicht nur numerische Datentypen: - numerische Daten unterschiedlichen Typs - Strings - Arrays - Cluster - etc. Das Schieberegister erkennt jeweils automatisch den Datentyp des Anfangswertes, übernimmt diesen für die weitere Verarbeitung und erwartet auch einen solchen Datentyp als Ausgabewert. Entsprechend muss die Ermittlung dieses Ausgabewertes auch erfolgen – wenn

● 245

Labview3 DE 160517.indd 245

02-08-16 12:15

Kapitel 8 • Fortgeschrittene Programmentwicklung - Der Zustandsautomat

Kapitel 8 • F ortgeschrittene Programmentwicklung Der Zustandsautomat Mit den nachfolgenden Ausführungen werden wir ein ganz neues Kapitel der LabVIEW-Programmierung aufschlagen und Ihnen zeigen, wie man mit fortgeschrittenen Programmkonzepten professionelle VIs entwickelt. Bisher haben wir unter Verwendung der LabVIEW-Strukturen Flache Sequenz, For-Schleife, While-Schleife, Case-Unterscheidungen etc. VIs entwickelt, die grundlegend (auf der untersten Ebene) strukturiert aufgebaut waren. Bei der Entwicklung von größeren, komplexeren, industriell eingesetzten VIs reichen solche einfachen Strukturelemente jedoch bei Weitem nicht mehr aus. Immer stärker und dringlicher geraten nun andere praktische Punkte in das Blickfeld des VI-Entwicklers. Solche VIs sollten demnach zwingend • verständlich, • übersichtlich sowie • leicht erweiterbar bzw. änderbar aufgebaut sein und • Fehler müssen einfach und schnell gefunden und behoben werden können. Mit anderen Worten: Das bisherige LabVIEW-VI-Entwicklungskonzept muss um weiterführende, optimierte Strukturkonzepte ergänzt werden. Solche Erweiterungen fallen unter das Stichwort Entwurfsmuster (Entwurfsmethoden bzw. Programm-Architekturen) für ein VI´. Sie sind auch in den klassischen Programmiersprachen wie beispielsweise ´C´ bekannt und werden dort ebenfalls häufig eingesetzt. 8.1 Entwurfsmuster in LabVIEW

Beginnen wir damit, dass wir uns einmal bewusst machen, wie unsere VIs bisher entworfen wurden bzw. strukturiert waren. Dabei haben wir (ohne dass wir uns dessen bewusst waren) bereits zwei wesentliche LabVIEW-Entwurfsmuster angewendet: • die nicht-sequentielle Programmierung • die sequentielle Programmierung mit den folgenden beiden Unterfällen: - Verwendung der flachen Sequenzstruktur - entsprechende Verbindung von Funktionsblöcken (bzw. SubVIs) auf Grundlage des Datenflussprinzips Beispiel: ´Nicht sequentielle Programmierung´ Diesen einfachsten Fall der VI-Entwicklung zeigt die Abbildung 8.1.1:

● 263

Labview3 DE 160517.indd 263

02-08-16 12:15

LabVIEW 3: Für den Praktiker

Abbildung 8.1.1: Die nicht-sequentielle Abarbeitung Wenn das VI gestartet wird, kann man nicht eindeutig vorhersagen, welches Unterdiagramm zuerst ausgeführt wird. Die Reihenfolge beim Abarbeiten der Unterdiagramme ist beliebig, eine besondere Reihenfolge ist nicht festgelegt. Wenn hingegen eine bestimmte Reihenfolge bei der Abarbeitung zwingend vorgegeben werden soll, wird die flache Sequenz eingesetzt: Beispiel: ´Sequentielle Programmierung durch Verwendung der flachen Sequenz´ Die Abbildung 8.1.2 zeigt diesen Entwurfsansatz:

Abbildung 8.1.2: Durch die flache Sequenz wird die Ablaufreihenfolge eindeutig (zwingend) festgelegt Hier wird ganz eindeutig zuerst das Unterdiagramm 1 und dann das Unterdiagramm 2 abgearbeitet: Somit wird eine bestimmte Ablaufreihenfolge (Sequenz) eingehalten. Beispiel: ´Verbindung von Funktionsblöcken bzw. SubVIs auf Grundlage des Datenflussprinzips´ Dieses Entwurfsmuster haben Sie sehr ausführlich in Band 2 kennengelernt, als wir uns mit der seriellen Datenübertragung beschäftigt haben, Abbildung 8.1.3:

● 264

Labview3 DE 160517.indd 264

02-08-16 12:15

Kapitel 9 • Ereignisgesteuerte Programmierung

Kapitel 9 • Ereignisgesteuerte Programmierung 9.1 Grundsätzliches

In diesem neuen großen Kapitel beschäftigen wir uns mit einem gänzlich neuen Aspekt bei der Verarbeitung von Daten in LabVIEW, der ereignisgesteuerten Programmierung. Sie haben LabVIEW bisher als datenflussorientierte Programmiersprache kennengelernt und das bedeutet ja, dass das Abarbeiten bzw. die Ausführung von Funktionen auf dem Blockdiagramm des VIs durch den Datenfluss von einer Funktion zur nächsten festgelegt wird. Dieses Ablaufkonzept wird nun dadurch erweitert, dass ein VI jetzt in die Lage versetzt wird, auf bestimmte (externe oder interne) Ereignisse sofort zu reagieren und beim Eintritt eines solchen Ereignisses ein bestimmtes Unterdiagramm auszuführen. Beispiel: Das VI árbeitet so vor sich hin´, und wenn mit der Maus auf ein Feld des Frontpanels geklickt bzw. wenn eine bestimmte Taste auf der Tastatur gedrückt wird, soll eine ganz bestimmte Aktion ausgeführt werden. Bei der bisherigen Programmiermethode musste dazu die Maus bzw. die Tastatur in entsprechenden Schleifen permanent im Hinblick darauf abgefragt werden, ob sich etwas getan hat. Diese Methode nennt man den ´Polling-Betrieb´ (≡ permanentes Abfragen) und sie verzögert unter Umständen die Abarbeitungsgeschwindigkeit des VIs, da ja immer wieder überprüft werden muss, ob irgendwelche Änderungen aufgetreten sind, eben auch dann, wenn der Anwender gar keine Aktion durchgeführt hat. Die alternative Betriebsart besteht nun darin, dass sich das Bedienelement (Maus, Tastatur) selbständig meldet, wenn es betätigt wird, ohne das permanente Abfragen in Schleifen erforderlich sind. Das VI könnte auf diese Weise seine Hauptaufgabe fortlaufend durchführen und nur dann, wenn sich das Bedienelement bei Betätigung meldet (≡ eine Unterbrechung des normalen Programmablaufes erzeugt), muss darauf entsprechend reagiert werden. Auf diese Weise kann ein zeitoptimierter Ablauf des VIs erzielt werden, da nur dann reagiert wird, wenn auch wirklich etwas geschehen ist. In den klassischen Programmiersprachen ist dieses Konzept unter dem Begriff Ínterrupts´ (≡ Unterbrechungen) bzw. Ínterruptsteuerung´ bzw. Ínterruptverarbeitung´ bekannt. Mit solchen Interrupts kann jetzt auch in LabVIEW gearbeitet werden, allerdings stehen hier wesentlich mehr und wesentlich umfangreichere Unterbrechungsarten zur Verfügung und man spricht daher ganz allgemein auch nur von Éreignissen´, die stattfinden können und auf die dann reagiert werden kann. An dieser Stelle kommen wir dann zu den neuen Betriebsarten der éreignisgesteuerten Programmierung´, bei der die Ausführung von Funktionen auf dem Blockdiagramm durch Ereignisse beeinflusst werden kann, die regelmäßig oder völlig unregelmäßig auftreten können.

● 333

Labview3 DE 160517.indd 333

02-08-16 12:16

LabVIEW 3: Für den Praktiker

Es gilt daher ganz allgemein Folgendes: Ereignis ≡ Meldung, dass írgendetwas´ stattgefunden hat. Merke: Vorteile der ereignisgesteuerten Programmierung • Sich ändernde Zustände werden sofort erkannt bzw. ausgewertet, ohne dass in Schleifen kontinuierlich etwas abgefragt werden muss. Die CPU des Rechners wird dadurch zeitlich entlastet, das Programm läuft schneller ab. • Änderungen werden auf jeden Fall immer erkannt, es geht auch bei schnellen Änderungen nichts verloren. • Der Aufbau des Blockdiagramms wird einfacher und bleibt überschaubarer. Die Ereignisse in LabVIEW Grundsätzlich lassen sich alle möglichen Ereignisse, die bei einem bzw. in einem VI auftreten können, in drei große Gruppen einteilen: 1. Ereignisse auf der bzw. von der Benutzeroberfläche Diese Ereignisse finden auf dem Frontpanel des VIs statt und sind sicherlich die bekanntesten und häufigsten Ereignisse: • Betätigung einer Taste auf der Tastatur mit den Unterereignissen ´Taste gedrückt´, ´Taste losgelassen´, ´Taste dauerhaft gedrückt´ • Betätigung der rechten bzw. linken Maustaste beim Klicken auf ein Element (Schaltfläche) mit den Unterereignissen ´Maustaste gedrücktúnd ´Maustaste losgelassen´ • Betätigung des Mausrades rauf bzw. runter • Fahren mit dem Mauscursor über eine Schaltfläche • Verlassen einer Schaltfläche mit dem Mauscursor • Änderung des numerischen Wertes in einem Bedienelement • etc., etc. Jede noch so kleine Aktion des Benutzers auf dem Frontpanel kann solche Benutzer-Ereignisse erzeugen. 2. Ereignisse auf dem Blockdiagramm Solche Ereignisse werden durch den normalen Programmablauf auf dem Blockdiagramm erzeugt (≡ programmatische Auslösung), ohne dass Frontpanel-Aktionen stattgefunden haben: • Es wird beispielsweise eine Temperatur erfasst und dabei tritt das Ereignis ´Überschreiten des oberen Grenzwertes´ auf. Dieses Ereignis wird also ´programmatisch´ vom Blockdiagramm ausgelöst und kann dann weitergehende Reaktionen érzwingen´.

● 334

Labview3 DE 160517.indd 334

02-08-16 12:16

Kapitel 10 • Methoden zur Prozesssynchronisierung

Kapitel 10 • Methoden zur Prozesssynchronisierung 10.1 Grundsätzliches

In diesem Kapitel beschäftigen wir uns nach den Zustandsautomaten und der ereignisgesteuerten Programmierung mit dem dritten großen Bereich der fortgeschrittenen LabVIEW-Programmierung - der Prozesssynchronisierung. In unseren Ausführungen zu den globalen Variablen (Kapitel 3) wurde schon ganz kurz auf die entsprechende kritische Grundproblematik hingewiesen: • Was geschieht, wenn mehrere unabhängige Prozesse gleichzeitig auf die gleiche globale Variable schreibend/lesend zugreifen ? • Wird wirklich jedem Prozess der aktuelle und vor allen Dingen richtige Zustand bzw. Wert der globalen Variablen geliefert oder gerät alles durcheinander ? Da ein geordneter Datenfluss (auf Grundlage des Datenflussprinzips) zwischen den Prozessen nicht stattfindet, kann ja jeder Prozess zu jedem beliebigen Zeitpunkt auf die globalen Variablen zugreifen. • Mit anderen Worten: Es fehlen bisher Regeln bzw. Methoden, die einen einwandfreien, eindeutigen, zeitlich korrekten Zugriff auf globale Variablen ermöglichen. Und diese ganze Problematik tritt nicht nur beim Arbeiten mit globalen Variablen auf, sondern betrifft auch viele andere Bereiche: • Mehrere Prozesse greifen unabhängig voneinander auf eine gemeinsame Datendatei auf der Festplatte zu, und zwar lesend und schreibend. Wie lässt sich hier ein Chaos vermeiden, wenn der eine Prozess gerade etwas an einer Stelle in der Datei hineinschreibt und der andere gerade etwas von derselben Stelle ausliest? • In ein gemeinsames Signalverlaufsdiagramm zeichnen unterschiedliche Prozesse unabhängig voneinander verschiedene Verlaufskurven. Wie werden hier Zugriffsprobleme vermieden ? • etc. Aber auch hiermit sind noch nicht alle denkbaren Konfliktfälle zwischen parallel ablaufenden Prozessen abgehandelt, denn es stellt sich bei weitergehenden Überlegungen noch folgende grundsätzliche Frage: Wie werden eigentlich zwischen unabhängig ablaufenden Prozessen einzelne Daten bzw. ganze Datensätze in der richtigen zeitlichen Reihenfolge, so wie die Prozesse sie benötigen, ausgetauscht ? Auch hierzu sind ´rein globale Variablen´ nicht geeignet, da ja die zeitliche Reihenfolge des Zugriffs hier nicht berücksichtigt werden kann.

● 371

Labview3 DE 160517.indd 371

02-08-16 12:16

LabVIEW 3: Für den Praktiker

Fazit: Ganz allgemein stellen sich bei unabhängigen, parallel ablaufenden Prozessen zwei kritische Fragen: 1. Wie regelt man konfliktfrei den gleichzeitigen Zugriff auf gemeinsam genutzte Ressourcen (globale Variablen, Dateien, Diagramme etc.) ? 2. Wie werden einzelne Daten bzw. ganze Datensätze in der zeitlich korrekten Reihenfolge zwischen den Prozessen ausgetauscht ? Zur Lösung dieser Problemfälle stehen es unter LabVIEW (wie auch bei anderen höheren Programmiersprachen) mehrere leistungsfähige Methoden und Konzepte für unterschiedliche Anwendungsszenarien der Prozesssynchronisierung zur Verfügung: Prozesssynchronisierung OHNE Datenaustausch zwischen den Prozessen Hierbei wird nur der Zugriff auf gemeinsam genutzte Ressourcen geregelt, ohne dass zwischen den Prozessen selbst noch Daten ausgetauscht werden. Die dabei eingesetzten Konzepte sind folgende: • Occurrences • Semaphore • Rendezvous Prozesssynchronisierung MIT Datenaustausch zwischen den Prozessen Hier können zwischen den unabhängigen Prozessen zusätzlich noch Daten bzw. ganze Datensätze in der zeitlich korrekten Reihenfolge ausgetauscht werden. Dies wird durch folgende Konzepte ermöglicht: • Melder • Queues Wir werden Ihnen nachfolgend die am häufigsten verwendeten Methoden (Semaphore, Melder und Queues) detaillierter vorstellen. 10.2 Prozesssynchronisation ohne Datenaustausch 10.2.1 Semaphoren

Bevor wir das Semaphoren-Konzept näher erläutern, sollen zwei einfache, aber aussagekräftige Beispiele die grundlegende Problematik noch einmal veranschaulichen: Problembeispiel 1: Zwei unabhängige Tasks eines VIs greifen auf ein gemeinsames (globales) Array zu, Abbildung 10.2.1.1:

● 372

Labview3 DE 160517.indd 372

02-08-16 12:16

Index

Index Symbols

CPU-Last 363

10er-Bedientastatur 296

csv-Dateien

195, 197

(asynchroner) Datenaustausch

csv-Format

169, 185

Ctl- oder Kontroll-Elemente

230

A absoluter Dateipfad

129, 130

absolute Zeit

absoluter Dateipfad

218

Acquire Semaphor

385

Aktualisierungsmodi 92 aktuelle PC-Zeit Amplituden- und Pegelmessung Anhängen von Daten

Darstellung mehrerer Plots

56 95, 107

Darstellungssymbol 31 112

Darstellung von mehreren Plots

Dateianfang 135

Dateiformate 125

14, 30

Anzeigeelement ausblenden

DAQ (Data Acquisition) –Assistent

90 160

Anschlussfeld

134, 145

Dateimarke

Datenflussprinzip 264 129

Datentyp ´Pfad´

Anzeigeformat 91

Datumsanzeige 91

Applikationsteil 284

Diagramm

ASCII-Datei 128

Diagramm-Historienlänge 78

71, 100

ASCII-Format

125, 126

Diagramm löschen

ASCII-Steuerzeichen

136, 156

Dialogboxen 56

ASCII-Textdatei

124, 141, 145

Assistenten

12, 56

Dialogfeld mit einer Schaltfläche

341

Dialogfeld mit zwei Schaltflächen

370

Auf Melder warten

390

Auf Meldung warten

393

Aus Binärdatei lesen

215

Ausgrauen von Schaltflächen

228

Eieruhr 318

Aus Tabellenkalkulationsdatei lesen

197

Eigenschaftsknoten

Aus Textdatei lesen

174

Eigenschaftsknoten ´Tastenfokus´

Automaten 266

Dreiecksignal 52

Einbinden eines SubVIs Element

B Belastung der CPU

Element aus Queue entfernen 361

73, 90, 224 38 22 230, 231 400

Element-Editor 232

Beschriftungen 85

Element einfügen

Big-Endian 203

Empfänger 388

Binärdateien 202

End Of File

180

binärer Semaphor

End of Line

147

375

400

Binär-Format 125

Entscheidungsteil 284

Bitmap 100

Entwurfsmuster 263

224

Enum-Element 274

Blinkgeschwindigkeit 227

EOF 180

Bündeln 95

EOL

Blinken von LEDs

147, 170, 181

Ereignis-Case 337 C

Ereignis-Case hinzufügen

Case-Struktur 274

Ereignisdatenknoten

342 337, 344

● 405

Labview3 DE 160517.indd 405

02-08-16 12:16

LabVIEW 3: Für den Praktiker

Ereignisfilterknoten 365

Ereignisfilterrahmen 365

Imaginärteil 116

ereignisgesteuerte Programmierung

333

In Binärdatei schreiben

Ereignis ´Maustaste gedrückt´

351

Initialisierungswert 247

207

Ereignis-Rahmen 337

In Tabellenkalkulationsdatei schreiben

Ereignisse 333

Internet 403

Ereignisstrukturen 346

Interrupts 333

Ereignis ´Taste gedrückt´

355

Interruptsteuerung 333

Ereignis ´Timeout´

338

Interruptverarbeitung 333

Ereignistypen 335 Ereignis ´Wertänderung´

340, 354

Erzeuger

380, 388

Erzeuger-Schleife 388

128

Intranet 403 K komplexe Werte

116

Export von Datensätzen

komplexe Wechselstromrechnung

116

Export von Plots

Komplexe Zahlen

116

Excel

Express-VIs

99, 170, 195

In Textdatei schreiben

185

12, 50

Konfigurationsdialogfeld 50 Konfigurationsfenster 51

Konsument 388

Fahrstuhl-Semaphor 374

Konsumer 380

Farbfeldkonstante 87

Kreise 111

Fenstereigenschaften 45

kritische Abschnitte

Fenstererscheinungsbild 44

Kurven 70

376

Fensterkomparators 307 Festlegung der Hintergrundfarbe

FIFO-Speicher 398

Laufdiagramm 93

Filtereiereignisse 363

Laufzeitprobleme 388

369

LED-Blinkfarben 226

Filterereignisse 335

Lissajous-Figuren 121

365

Little-Endian 204

Filterereignis ´Panel schließen?´ Filterereignis ´Taste gedrückt?´

Fließkommaformat 91 Frontpanel des SubVIs

Funktionsblöcke 264 G gestapelte Schieberegister globale Fenstereinstellungen Graph

253 43

lokale Einstellungen

lokale Fenstereinstellungen

Löschen des Diagramms

Löschen des XY-Graphens

115

Löschen eines Graphen

105

Low-Level-Datei-I/O 124 LVM-Format

125, 126

70, 100 M

Master 388

Hex-Editor 204

Meldeereignisse 335

High-Level-Datei-I/O 123

Melder 387

Historienlänge 78

Melder anfordern

390, 392

Historienspeicher 79

Melder freigeben

390, 394

Melder senden

390

Meldung senden

392

● 406

Labview3 DE 160517.indd 406

02-08-16 12:16

Chapter Number ● Chapter Name

Modern Art

110, 120, 382

Multifunktionsuhr 315

Schieberegister 274

myDAQ 56

Schreibrichtung umkehren

Screenshots 97 N

Selbstdefinierte Elemente

234 , 243

nicht-initialisierte Schieberegister

250

selbstdefinierte Anzeige- und

Nicht sequentielle Programmierung

263

Bedienelemente 230

Nyquist-Diagramme 111 O Obtain Semaphor Reference Ortskurven Oszilloskopdiagramm

384 111, 116 70, 92

Semaphor belegen

377, 385

Semaphor freigeben

379, 385

Semaphorreferenz anfordern

377, 384

Semaphorreferenz freigeben

379, 385

Sender 388 Sequentielle Programmierung Signal simulieren

P Passwortabfrage

Signalverlaufsdiagramm

264 51 70, 71, 101

36, 46

Signalverlaufsgraph 100

Passwortvergleich 36

Skalen 85

Pfad-Bedienelement 130

Slave 388

Pfadermittlung 221

Standard-Datei-I/O 122

Pfad erstellen

223

Standardereignis 338

Pfadkonstante

130, 142

state 268

Pfad zerlegen

222

Pfadzerlegung 220

state diagramm state machine

271 271, 274

Ploteigenschaften 85

Stoppuhr 316

Plots 70

Stream 122

Polling-Betrieb 333

Streaming-Datei-I/O 122

Produzent

380, 388

Protokolldatei 163

Streifendiagramm strikt typdefiniertes Element SubVI

70, 92 241 12, 68

Symbol 14

Queue anfordern

400

Symbol-Editor

Queue freigeben

400

Symbols 20

Queues Queue-Status lesen

387, 398 401

R Race Conditions

20, 235, 310

T Tabellenkalkulationsdatei

124, 185

TDM/TDMS-Format

125, 127

Timeout-Ereignis 338

Realteil 116

Timer 318

Referenzen 132

transition 269

Referenzen der Semaphore

transponieren

relativen Zeit

376 87

Transponieren von Daten

110, 186 195

Relativer Dateipfad

218

Trennzeichen 189

Release Semaphor

385

typdefinierte Enum

Release Semaphore Reference

385

typdefinierten Enum-Variablen

Rückkopplungsknoten 255

typdefiniertes Element

281, 321 301 230, 236, 281

● 407

Labview3 DE 160517.indd 407

02-08-16 12:16

LabVIEW 3: Für den Praktiker U Übergang 269 Übergangsarray 305 User-Interface 340 V Verbraucher 388 Verbraucher- Schleife

388

Visualisierung 70 W Wertänderung 345 While-Schleife 274 X X-Achsen-Autoskalierung 79 x-Bildlaufleiste 81 XY-Graph

70, 111

Z Zahlensystem-Rechner 206 Zeilenende-Zeichen 146 Zeitachse

87, 107

Zoomen 82 Zufallszahlengenerator 93 Zustände

266, 268, 281

Zustandsarray 312 Zustandsautomat Zustandsdiagramm

266, 271, 274 271, 279

Zustands-Übergänge 267 Zwischenzeit 317

● 408

Labview3 DE 160517.indd 408

02-08-16 12:16

LabVIEW 3

LabVIEW

Die Entwicklung eigener Sub-VIs (Unterprogramme), das Arbeiten mit Schieberegistern und Zustandsautomaten und die Ereignisgesteuerte Programmierung stellen die Schwerpunkte des dritten Bandes dar.

●

• Der Einsatz von Schieberegistern leistungsfähiger Zustandsautomaten Ablaufstrukturen durch • Optimierte Ereignisgesteuerten Programmierung

zur

Erstellung

Anwendung

der

• Verwendung anspruchsvoller graphische Frontpanelelemente wie Signalverlaufsdiagramme, Signalverlaufsgraphen und XY-Graphen

FÜR DEN PRAKTIKER

LabVIEW

VOM BERG & GROPPE

Bernd vom Berg und Peter Groppe

FÜR DEN PRAKTIKER

• Die verschiedenen Methoden zur Datenspeicherung in Dateien mit Hilfe der vorhandenen Datei-I/O-Funktionen und -VIs

Elektor-Verlag GmbH 52072 Aachen www.elektor.de

• Die Synchronisierung von unabhängig parallel ablaufenden Prozessen durch Semaphoren, Melder oder Queues

DESIGN

ISBN 978-3-89576-320-5

Bernd vom Berg & Peter Groppe LEARN

DESIGN

LEARN