Versuch
NI-ELVIS (HVAC 2.0)
Programmierung mit LabVIEW
Prof. Dr.-Ing. D. Brück M. Sc. Jannick Morsch
M. Sc. Marc Quirin
22.03.2016
Automatisierungslabor 1
Inhaltsverzeichnis
1 Einleitung ............................................................................................................................ 3
2 Voraussetzung zur Durchführung des Praktikums ............................................................. 3
3 Einführung in LabVIEW ..................................................................................................... 4
3.1 LabVIEW Entwicklungsumgebung ......................................................................................................... 4
3.2 Frontpanel und Blockdiagramm ............................................................................................................ 4
3.2.1 Symbol und Anschlussfeld ................................................................................................................. 6
3.2.2 Bedien- und Anzeigeelemente .......................................................................................................... 7
3.3 Anschlüsse, Knoten und Drähte ............................................................................................................. 8
3.4 Datenfluss .............................................................................................................................................. 9
3.5 Erstellen und Verwendung von SubVIs .................................................................................................. 9
3.6 Kommentare und Dokumentation in LabVIEW .................................................................................... 12
3.7 Fehlerbehandlung ................................................................................................................................ 13
3.8 Programmstrukturen ........................................................................................................................... 14
3.8.1 Die While-und For-Schleife.............................................................................................................. 14
3.8.2 Schiebe-Register .............................................................................................................................. 15
3.8.3 Case –und Sequenzstruktur............................................................................................................. 16
3.8.4 Ereignisstruktur ............................................................................................................................... 18
3.8.5 Variablen in LabVIEW ...................................................................................................................... 19
3.8.6 Lokale und globale Variablen .......................................................................................................... 19
3.8.7 Erstellen von Arrays ........................................................................................................................ 20
3.9 Zustandsautomat ................................................................................................................................. 25
3.9.1 Definition ......................................................................................................................................... 25
3.9.2 Anwendung von Zustandsautomaten ............................................................................................. 25
3.9.3 Aufbau des Zustandsautomaten ..................................................................................................... 26
3.9.4 Steuern von Zustandsautomaten .................................................................................................... 27
3.9.5 Übergänge bei Zustandsautomaten ................................................................................................ 27
4 QNET-HVACT 2.0 ........................................................................................................... 30
4.1 Einleitung ............................................................................................................................................. 30
4.2 Aufbau ................................................................................................................................................. 30
4.3 Ansteuerung ........................................................................................................................................ 31
4.4 Komponenten Beschreibung ................................................................................................................ 31
4.4.1 Heizkammer .................................................................................................................................... 31
4.4.2 Lüfter ............................................................................................................................................... 31
4.4.3 PWM Power Amplifier ..................................................................................................................... 32
4.4.4 Analoge Strommessung................................................................................................................... 32
4.4.5 Spannungsversorgung ..................................................................................................................... 32
4.5 Technische Daten ................................................................................................................................. 32
Automatisierungslabor 2
4.6 Äußere Einflüsse .................................................................................................................................. 32
5 Praktikumsdurchführung ................................................................................................... 33
5.1 Erstellung eines Beispielprojektes in LabVIEW..................................................................................... 33
5.2 Lesen und Schreiben mittels DAQmx ................................................................................................... 34
5.2.1 Aufgabe 1 Lesen .............................................................................................................................. 35
5.2.2 Aufgabe 2 Schreiben ....................................................................................................................... 35
5.3 Erstellung eines Zweipunktreglers ....................................................................................................... 35
5.3.1 Erklärung: ........................................................................................................................................ 35
5.3.2 Aufgabe 3: ....................................................................................................................................... 37
5.4 Erstellung eines PI/PID-Reglers ............................................................................................................ 37
5.4.1 Erklärung ......................................................................................................................................... 37
5.4.2 Aufgabe 4: ....................................................................................................................................... 39
5.5 Erstellung eines Fuzzy-Reglers ............................................................................................................. 39
5.5.1 Erklärung ......................................................................................................................................... 39
5.5.2 Aufgabe 5: ....................................................................................................................................... 39
5.5.3 Aufgabe 6: ....................................................................................................................................... 40
5.6 Zusammenfassen der Programme ....................................................................................................... 40
5.6.1 Aufgabe 7: ....................................................................................................................................... 40
5.6.2 Aufgabe 8: ....................................................................................................................................... 40
6 Anhang .............................................................................................................................. 41
6.1 Ein Fuzzy-Beispiel ................................................................................................................................. 41
Automatisierungslabor 3
1 Einleitung
Zielsetzung
In der heutigen Zeit wird in den meisten Forschungsinstituten vermehrt LabVIEW, zur Daten
Erfassung und Verarbeitung, eingesetzt. Diese Programmierumgebung ist durch die
datenflussorientierte Programmierung um einiges leichter zu verstehen und zu lernen. Dieser
Versuch soll ihnen einen Einblick in das Thema Datenerfassung und Verarbeitung mittels
LabVIEW geben, sowie den Umgang mit dem Toolkit „PID and Fuzzy Toolkit“ ermöglichen.
2 Voraussetzung zur Durchführung des Praktikums
Vorbereitung der Versuchsdurchführung
Bevor Sie den Versuchsstand in Betrieb nehmen, vergewissern Sie sich, dass die elektrische
Energieversorgung angeschlossen ist. Um die Anlage zu programmieren, muss der
verwendete Computer mit dem ELVIS Board über eine USB-Schnittstelle verbunden sein,
sowie die benötigte Software installiert sein.
Hilfe bzgl. der Aufgaben
Sollten Sie bei den Aufgaben nicht mehr weiterkommen, suchen Sie zuerst im Internet nach
einer Lösung ihres Problems oder verwenden Sie die ausführliche Hilfe von LabVIEW.
Verwenden Sie die Highlight-Funktion beim Ausführen ihres Programmes, um den
Programmablauf zu verstehen und Fehler auszuschließen. Die Dokumentation über das
Thema Fuzzy finden Sie auf der Auslegestelle (AMS-Labor). Weiter ist das Buch "Taschenbuch
der Regelungstechnik" zu empfehlen, um den PID-Regler richtig auszulegen.
Praktikumsdurchführung und Ausarbeitung
In der anzufertigen Dokumentation sollten nochmals kurz die Aufgabenstellungen des
Praktikums dargestellt werden. Der von ihnen angefertigte Programmcode sollte mit
sinnvollen Kommentaren versehen werden.
Ihre Dokumentation sollte ein Kapitel enthalten, in dem Sie Kritik und Vorschläge an den
Praktikumsaufgaben, der Praktikumsbeschreibung, Durchführung und Wissensvermittlung
ausüben. Sollten Sie Fehler finden oder Verbesserungsvorschläge haben, teilen Sie diese bitte
ihrer betreuenden Person mit.
Automatisierungslabor 4
3 Einführung in LabVIEW
3.1 LabVIEW Entwicklungsumgebung
Im Vergleich zu textbasierten Programmiersprachen (z.B. C++, C. usw.) ist LabVIEW eine
graphische Programmierumgebung zur Erstellung von Applikationen mit professioneller
Benutzeroberfläche. Mit Hilfe von LabVIEW werden anspruchsvolle Mess-, Prüf-, und
Regelsysteme entwickeln. Dazu werden grafische Symbole eingesetzt und durch Drähte
miteinander verbunden. Zusätzlich lässt sich die LabVIEW Plattform mit verschiedenen Ziel-
und Betriebssystemen verwenden, um die Erweiterung der Einsatzgebiete zu ermöglichen. Die
Programme in LabVIEW werden als Virtuelle Instrumente (VIs) bezeichnet, da diese im Grunde
ein echtes reales Gerät (Multimeter, Oszilloskop) als virtuelles Instrument darstellen.
VIs bestehen aus einem Frontpanel und einem Blockdiagramm. Auf dem Frontpanel werden
Bedienelemente platziert und auf das Blockdiagramm der dazugehörige Programmcode
erstellt. Anders wie bei textbasierten Programmiersprachen wird die Programmausführung in
LabVIEW durch den Datenfluss bestimmt.
3.2 Frontpanel und Blockdiagramm
Mit einem Doppelklick auf das LabVIEW-Symbol öffnet sich das LabVIEW Startfenster (vgl.
Abbildung 3.1). Hier können direkt Dateien geöffnet (2) oder Projekte auf der Basis von
Projektvorlagen (1) erstellt werden. Zusätzlich findet man zahlreiche Informationen zum
Umgang mit LabVIEW (4), sowie die Technische Unterstützung (3) über die NI-Forum-Seite.
Automatisierungslabor 5
Abbildung 3.1: LabVIEW Startfenster
Um ein neues VI zu erstellen gehen Sie auf Datei→ Neues VI erstellen. Auf dem
Bildschirmerscheinen zwei Fenster zum einen, das Frontpanel und zum anderen, das
Blockdiagramm. Das Frontpanel ist die Benutzeroberfläche des VIs. Hier werden alle Bedien-,
und Anzeigeelemente platziert, die für die Steuerung des Programms notwendig sind. Beim
Einfügen von Bedien-, und Anzeigeelementen erstellt LabVIEW automatisch einen
sogenannten Anschluss im Blockdiagramm. Im Blockdiagramm werden die Frontpanelobjekte
miteinander verdrahtet (vgl. Abbildung 3.2).
Ein VI besteht im Grunde aus einem Frontpanel, einem Blockdiagramm, einem Symbol und
dem Anschlussfeld.
Abbildung 3.2: Beispiel eines VIs
1
3 4
2
Automatisierungslabor 6
3.2.1 Symbol und Anschlussfeld
Ein Symbol und das Anschlussfeld ermöglichen die Verwendung und das Anzeigen eines VIs in
einem anderen VI. Ein VI, das in einem anderen VI verwendet wird, ähnlich einer Funktion in
befehlsorientierten Programmiersprachen, nennt man SubVI. Damit ein VI als SubVI
verwendet werden kann, muss es ein Symbol und ein Anschlussfeld besitzen. Für jedes VI wird
in der rechten oberen Ecke des Frontpanels und Blockdiagramms ein Symbol angezeigt.
Ein Beispiel eines Standardsymbols ist unten abgebildet (vgl. Abbildung 3.3). Das VI-Symbol
ist die grafische Darstellung eines VIs. Das Symbol kann sowohl Text als auch Bilder enthalten.
Wenn Sie ein VI als SubVI verwenden, kennzeichnet das Symbol das SubVI im Blockdiagramm
des übergeordneten VIs. Die Zahl auf dem Standardsymbol gibt an, wie viele neue VIs nach
dem Start von LabVIEW geöffnet wurden.
Abbildung 3.3: LabVIEW-Standardsymbol
Um ein VI als SubVI verwenden zu können, müssen Sie ein Anschlussfeld erstellen
(vgl.Abbildung 3.4). Das Anschlussfeld enthält die Anschlüsse des Symbols, die ähnlich der
Parameterliste eines Funktionsaufrufs in befehlsorientierten Programmiersprachen den
Bedien- und Anzeigeelementen des VIs entsprechen. Das Anschlussfeld wird in der rechten
oberen Ecke des Frontpanels neben dem VI-Symbol angezeigt. Im Blockdiagramm kann nicht
auf das Anschlussfeld zugegriffen werden.
Abbildung 3.4 : Anschlussfeld
Automatisierungslabor 7
3.2.2 Bedien- und Anzeigeelemente
Beim Erstellen eines VIs fügen Sie in das Frontpanel die gewünschten Bedien- und
Anzeigeelemente ein, also die Ein- und Ausgänge des VIs. Bedienelemente sind alle
Eingabeelemente wie Drehknöpfe, Druckschalter oder Drehregler. Zu den Anzeigeelementen
zählen zum Beispiel Graphen oder LEDs. Mit Bedienelementen werden Eingabegeräte
simuliert und Daten an das Blockdiagramm des VIs gesendet. Mit Anzeigeelementen werden
Ausgabegeräte simuliert und die vom Blockdiagramm erfassten oder erzeugten Werte
angezeigt.
LabVIEW stellt eine große Auswahl an Bedien- und Anzeigeelemente für die Erstellung einer
Applikation zur Verfügung. In Abbildung 3.5 und Abbildung 3.6 sehen Sie ein einige
Auswahlmöglichkeiten der numerischer und boolescher Bedien- und Anzeigeelemente. Durch
das Klicken auf das Frontpanel mit der rechten Maustaste öffnet sich die Palette zur
Gestaltung der Frontpanel-Oberfläche
Abbildung 3.5 : Auswahl einer Palette (Bedien- und Anzeigeelement) in LabVIEW
Um eine Benutzeroberfläche schneller zu erstellen, kann die entsprechende Palette
ausgewählt und mit dem Pinnsymbol auf dem Frontpanel fixiert werden. Somit können
Automatisierungslabor 8
Frontpanel-Objekte nacheinander auf das Frontpanel platziert und damit den mehrfachen
Rechtsklick zum Öffnen der Palette vermieden werden.
Abbildung 3.6 :Fixieren einer Palette mit dem Pinnsymbol in LabVIEW
3.3 Anschlüsse, Knoten und Drähte
Anschlüsse dienen zum Übertragen von Daten ins Blockdiagramm, die auf dem Frontpanel
eingegeben werden. Bedien-, und Anzeigeelemente werden im Blockdiagramm durch Drähte
verbunden. Diese sorgen für den Transport von Eingangsdaten.
Knoten bezeichnet man als Subfunktionen oder Operatoren, die für die Realisierung eines
Programms benötigt werden. Sie bestehen meistens aus Eingängen und Ausgängen. Im
unteren dargestellten Bild sind die einzelnen Teile beschriftet (vgl. Abbildung 3.7).
Abbildung 3.7 : Anschlüsse, Knoten und Drähte im Blockdiagramm
1- Anschluss Ausgang
2- Knoten
3- Anschluss Eingang
1 2
3
Automatisierungslabor 9
3.4 Datenfluss
Ein Blockdiagrammknoten kann erst ausgeführt werden, wenn an all seinen Eingängen Daten
anliegen. In LabVIEW wird die Ausführung eines VIs durch das Datenflussmodell bestimmt. In
Abbildung 3.8 wird das Prinzip des Datenflussmodells vorgestellt.
Abbildung 3.8 : Illustration des Datenflussmodells
Zuerst wird der erste Knoten(1) ausgeführt, wenn die Daten (Zahl 1 und Zahl 2) an seinen
Eingängen anliegen. Das Ergebnis wird an den Teileingang des zweiten Knotens(2)
weitergeleitet, wenn die Ausführung des Knotens beendet ist. Die Multiplikationsfunktion
kann demnach ausgeführt werden, wenn die Additionsfunktion beendet ist. Dies entspricht
dem Datenfluss. In LabVIEW lässt sich der Datenfluss im „Highlight Modus“ ansehen.
3.5 Erstellen und Verwendung von SubVIs
Stellen Sie sich vor, Sie würden eine große Applikation entwickeln ohne den Einsatz von
SubVIs. Das hätte zur Folge, dass Ihr Programmcode unübersichtlicher aussehen würde und
keinen wiederverwendbaren Abschnittscode hätte.
Mit SubVIs können Sie Ihre Applikation so gestalten, dass sie effizienter und einfacher zu
verstehen ist. SubVIs sind im Grunde VIs, die in einem anderen VI eingesetzt werden können.
Betrachten wir folgendes Beispiel, um diesen Begriff noch deutlicher zu schildern. Für das
Erstellen des SubVIs sind zwei Schritte erforderlich:
− Zuordnen des Anschlussfeldes
− Gestalten des SubVI-Symbols
Um ein SubVI zu erstellen gehen Sie folgendermaßen vor:
1
2
Automatisierungslabor 10
Um die Bedien-und Anzeigeelemente auf dem Frontpanel zuzuordnen, wählt man ein
Anschluss des angezeigten Musters (vgl. Abbildung 3) und klickt danach auf ein
Bedienelement. Wiederholen Sie das gleiche Verfahren für die anderen Anzeigeelemente,
indem sie jeweils auf die oben rechts zugeordneten Anschlüsse klicken und danach auf das
entsprechende Anzeigeelement. Nach Zuordnung der Frontpanelobjekte ändert sich die Farbe
des zugewiesenen Feldes am Anschluss (vgl. Abbildung 3.9).
Abbildung 3.9:Zuordnen des Anschlussfeldes
Abbildung 3.9: Anschlussfeld nach Zuordnen
Die Farbe stellt die verschiedenen Datentypen in LabVIEW dar (vgl. Abbildung 3.10).
Abbildung 3.10 : Häufig verwendete Datentypen in LabVIEW
In unserem Beispiel, soll der Mittelwert aus zwei Zahlen errechnet werden. Für das Gestalten
des Symbols klicken Sie mit der rechten Maustaste in das rechte oben angezeigte LabVIEW-
Icon und danach auf Symbol bearbeiten. Der Symbol-Editor erscheint auf dem Bildschirm (vgl.
Abbildung 3.11).
Automatisierungslabor 11
Abbildung 3.11 :LabVIEW Symbol-Editor
Im Symbol-Editor können Sie Ihr SubVI-Symbol gestalten. Wählen Sie das in der Abbildung
3.11 eingekreiste Element (1) und markieren sie das Standard-Symbol. Drücken Sie auf die
Taste „Entfernen“, um das Symbol zu löschen. Versuchen Sie ein aussagekräftiges SubVI zu
erstellen, denn das Symbol soll auf graphische Weise die Funktion des Programms darstellen.
Ein Beispiel des SubVI-Symbols zur Berechnung eines Mittelwerts könnte so aussehen (vgl.
Abbildung 3.12).
Abbildung 3.12: Beispiel eines SubVI-Symbols zur Berechnung des Mittelwertes
Öffnen Sie ein neues VI und drücken Sie die Tastenkombination (Strg + E), um in das
Blockdiagramm zu wechseln. Navigieren Sie mit einem rechten Mausklick in die
Funktionspalette und wählen Sie dort ein SubVI aus (vgl. Abbildung 3.13). Öffnen Sie das SubVI
und schauen Sie sich den Aufbau des VIs an.
Tipp: Beim Erstellen von SubVIs denken Sie bitte immer an den Fehlercluster. Mehr
Informationen darüber finden Sie im Unterkapitel 3.7.
1
Automatisierungslabor 12
Abbildung 3.13 :Vorgefertigte SubVIs in LabVIEW
3.6 Kommentare und Dokumentation in LabVIEW
Wie jede Programmiersprache haben Sie auch in LabVIEW die Möglichkeit Ihre Programme zu
dokumentieren. Mit einem Doppelklick auf das Blockdiagrammfeld, können die angezeigten
Kommentare mit gelbem Hintergrund eingefügt werden. Wenn Sie ein Draht beschriften
wollen, klicken Sie mit der rechten Maustaste auf den Draht (Sichtbare Objekte →
Beschriftung) und fügen Sie Kommentare ein (vgl. Abbildung 3.14).
Abbildung 3.14: Kommentare im Blockdiagramm
Zusätzlich dazu, können Sie Ihre Frontpanelobjekte kommentieren, sodass beim Ausführen
des VIs die Kommentare angezeigt werden. Dazu gehen Sie folgendermaßen vor:
Klicken Sie mit der rechten Maustaste auf ein Element und wählen Sie Eigenschaften. Danach
wechseln Sie in das Register Dokumentation und dort können Sie eine passende Beschreibung
zu Ihrem Objekt einfügen und mit OK bestätigen. Diese Art von Kommentaren lassen sich dann
anzeigen, wenn Sie die LabVIEW Hilfe aktivieren (Strg + H) oder auf das Fragezeichen klicken
und der Cursor auf das Element platzieren.
Automatisierungslabor 13
3.7 Fehlerbehandlung
Sobald ein VI in LabVIEW wegen Programmfehler nicht ausführbar ist, wird der
Ausführungspfeil zerbrochen dargestellt. Klicken Sie auf den zerbrochenen Pfeil, um die
Fehlerliste anzuzeigen. Hier werden alle im Blockdiagramm auftretende Errors und
Warnungen aufgelistet. Mit einem Klick auf den Button „Fehler anzeigen“ wird im
Blockdiagramm die Fehlerstelle „blickend“ dargestellt. In LabVIEW unterscheidet man zwei
Kategorien von Fehlerbehandlungen:
Die automatische Fehlerprüfung
Beim Ausführen eines VIs reagiert LabVIEW per Voreinstellung automatisch auf einen Fehler.
Das VI wird angehalten und ein Fehlerdialog mit einem Fehlercode erscheint mit der
dazugehörigen Meldung. Die automatische Fehlerbehandlung lässt sich in den VI-
Eigenschaften deaktivieren.
Die manuelle Fehlerprüfung
Unter manueller Fehlerbehandlung geht es darum, das VI so zu programmieren, dass es bei
einem bestimmten Fehlerauftritt den Benutzer informiert. Dazu werden Funktionen und
Fehlerbehandlungs-VIs verwendet. Zusätzlich dazu werden Fehler-Cluster zum Verwalten von
Errors in LabVIEW eingesetzt. Ein Fehler-Cluster (vgl. Abbildung 3.15) besteht aus drei
Komponenten:
Abbildung 3.15 : Fehler-Cluster
− Der Status vom Datentyp „Bool“ gibt den Wert True aus, wenn ein Fehler aufgetreten
ist.
− Der Code zeigt beim Fehlerauftritt ein Integerwert und meistens eine Beschreibung
der Fehlermeldung an.
− die Quelle, die Aufschluss auf den Fehler gibt, in Form eines Strings.
Automatisierungslabor 14
3.8 Programmstrukturen
3.8.1 Die While-und For-Schleife
In Abbildung 3.16 sehen Sie eine While-Schleife in LabVIEW, die durch ein Rahmen mit
veränderbarer Größe definiert ist. Sobald ein Unterprogramm von einer While-Schleife
umrahmt ist, wird diese mindestens einmal ausgeführt. Der Schleifenabbruch wird durch den
Bedingungsanschluss bestimmt. In der Palette „Strukturen“ im Blockdiagramm befindet sich
die While-Schleife. Um die While-Schleife auf das Blockdiagramm zu platzieren, muss diese
ausgewählt, und bei gedrückter Maustaste aufgezogen werden. Der Rahmen der While-
Schleife schließt sich um den markierten Bereich sobald die Maustaste wieder
Abbildung 3.16 : While-Schleife
losgelassen wird. Wenn Sie den Bedingungsanschluss mit einer Konstante False verbinden,
entsteht beim Ausführen des VIs eine Endlosschleife (vgl. Abbildung 3.17), die nur mit dem
Abbruch (Notaus-Taste) des VIs zu stoppen ist. Die Schleifeniteration zählt, wie oft die Schleife
ausgeführt wird.
Abbildung 3.17: Endlosschleife
Ablaufdiagramm
Schleifeniteration
Bedingungsanschluss
Automatisierungslabor 15
Die For-Schleife
Bei einer For-Schleife wird ein Unterprogramm so lange ausgeführt bis die festgelegte Anzahl
erreicht ist (vgl. Abbildung 3.18).
Der Zählanschluss bestimmt wie oft die Schleife ausgeführt wird. Der Iterationsanschluss
gibt die Anzahl der Durchläufe an.
Abbildung 3.18 :For-Schleife und Ablaufdiagramm
3.8.2 Schiebe-Register
Schieberegister dienen zum Speichern von Daten, wenn Sie zum Beispiel Daten zwischen
zwei Durchläufen austauschen wollen. Für For-und While-Schleifenkönnen Schiebe-Register
verwendet werden. Zum Erstellen von Schieberegistern klicken Sie mit der rechten Maustaste
auf den linken oder rechten Rand der Schleifen und wählen Sie aus dem Menü die Option
„Schieberegister hinzufügen“. Sie können auch mehrere Schieberegister für eine Schleife
vergeben. Dem Schieberegister kann auch ein Startwert gegeben werden (vgl. Abbildung
3.19).
Abbildung 3.19 :Initialisierung von Schieberegistern
Automatisierungslabor 16
3.8.3 Case –und Sequenzstruktur
Eine Case-Struktur ist wie der Name schon sagt eine Ablaufstruktur in LabVIEW, womit man
unterschiedliche Fallunterscheidungen umsetzen kann. Die Case-Struktur wird durch ein
Rahmen mit einem Auswahlmenü . im Blockdiagramm gekennzeichnet.
Standardmäßig besteht eine Case-Struktur aus zwei Unterdiagrammen (True und False).
Zusätzlich wird durch ein Case-Selektor festgelegt, welches Unterdiagramm ausgeführt
wird (vgl. Abbildung 3.20).
Abbildung 3.20 : Case Struktur
Es wird immer nur ein Unterdiagramm angezeigt. Klicken Sie auf den Aufwärts- oder Abwärts-
Pfeil, um die nächste oder vorherige Auswahl anzeigen zu lassen (vgl. Abbildung 3.21).
Abbildung 3.21: Abwärts- und Aufwärts-Pfeil der Case-Struktur
Sie finden die Case-Struktur auf der Funktionspalette im Blockdiagramm und diese lässt sich
wie eine While-Schleife im Blockdiagramm aufziehen.
Nehmen wir ein Beispiel, um die Funktion einer Case-Struktur näher zu erläutern. In diesem
Beispiel sollen zwei Zahlen addiert und dividiert werden.
− Öffnen Sie ein neues VI und platzieren Sie zwei numerische Bedienelemente, ein
boolesches Element und ein numerisches Anzeigeelement, auf das Frontpanel.
− Erstellen Sie, das in Abbildung 3.22angezeigte Blockdiagramm.
Erläuterung: Im „True“ Case wird die Addition beider Zahlen ausgeführt. Im False-Case wird
die Division durchgeführt.
Automatisierungslabor 17
Abbildung 3.22: Anwendung der Case-Struktur
Sequenzstruktur
Sequenzstrukturen dienen zur sequenziellen Ausführung von Programmteilen. Sehen Sie sich
das folgende Programmbeispiel in Abbildung 3.23an.
Abbildung 3.23 : Nicht Sequenzielle Programmierung
In diesem Beispiel wird nicht festgelegt, welches Ereignis zuerst ausgeführt wird. Aber es ist
durchaus möglich mittels Sequenzstruktur zu entscheiden, ob zuerst die Addition, dann die
Multiplikation und schließlich das Dialogfeld bearbeitet werden soll (vgl. Abbildung 3.24).Zur
Auswahl der Sequenzstruktur gehen Sie, wie in Abschnitt 3.8.1 vor.
Abbildung 3.24 :Sequenzielle Programmierung
Automatisierungslabor 18
3.8.4 Ereignisstruktur
Mit der Ereignisstrukturkönnen Ereignisse eines VIs verarbeitet werden. Damit können
Benutzeraktionen auf dem Frontpanel mit der Blockdiagrammausführung synchronisiert
werden. Wenn der Benutzer einen Wert eingibt, dann wird ein Event-Case ausgeführt.
Abbildung 3.25 zeigt eine Ereignisstruktur in LabVIEW.
Abbildung 3.25: Ereignisstruktur
Im folgenden Beispiel soll auf ein Ereignis im Frontpanel reagiert werden, welches über ein
Bedienelement ausgelöst wurde. Ziehen Sie ein Bedienelement in das Frontpanel rein. Zum
Konfigurieren der Ereignisstruktur klicken Sie den Rahmen der Struktur mit der rechte
Maustaste an und wählen „Ereignisse dieses Cases bearbeiten“ (vgl. Abbildung 3.26).
Abbildung 3.26 : Konfigurieren eines Ereignis-Cases
Wählen Sie unter Ereignisquellen das Bedienelement aus. Im rechten Bereich werden
Ereignisse angezeigt, die von den links ausgewählten Quellen erzeugt werden können. Auf die
Wertänderung des Bedienelements soll das VI reagieren. Das heißt man wählt das Ereignis
„Wertänderung“ aus (vgl. Abbildung 3.27).
Automatisierungslabor 19
Abbildung 3.27 : Ereignisse bearbeiten
3.8.5 Variablen in LabVIEW
Variable dienen zum Speichern und übertragen von Daten zwischen Prozessen.
3.8.6 Lokale und globale Variablen
Stellen Sie sich vor in Ihrer Applikation soll an mehreren Stellen im Programm auf eine Variable
zugegriffen werden. Ein Frontpanel-Element verfügt jedoch nur über einen
Blockdiagrammanschluss. Mit lokalen und globalen Variable, können Sie Daten an
unterschiedlichen Stellen in Ihrem Programm austauschen, ohne direkte
Blockdiagrammverbindung. Lokale Variablen sind dabei nur innerhalb eines VIs gültig.
Erstellen einer lokalen Variable
Eine lokale Variable lässt sich erstellen, indem Sie einen Rechtsklick auf das
Frontpanelelement oder Blockdiagrammobjekt (Erstellen→ lokale variable) machen. Die
zweite Möglichkeit ist eine lokale Variable direkt aus der Palette „Funktionen“ auszuwählen.
(vgl. Abbildung 3.28).Der Variable muss anschließend noch ein Objekt zugewiesen werden.
Abbildung 3.28: Lokale Variable in LabVIEW
Klicken Sie mit der rechten Maustaste auf die Variable und wählen Sie aus dem Menü die Option Objekt auswählen.
Automatisierungslabor 20
3.8.7 Erstellen von Arrays
Arrays lassen sich durch Platzieren eines Array-Containers erstellen. In den Container werden
anschließend die Datenobjekte reingelegt. Sie finden den Array-Container auf der Palette
„Array, Matrix“.
− Erstellen Sie ein neues VI.
− Klicken Sie mit der rechten Maustaste auf das Frontpanel zur Anzeige der
Palette Elemente.
− Navigieren Sie in der Palette Bedienelemente zu Modern→ Array, Matrix, &Cluster
und ziehen Sie den Array-Container auf das Frontpanel (vgl. Abbildung 3.29).
− Navigieren Sie auf der Palette Bedienelemente zu Modern→ Numerisch und ziehen
Sie ein numerisches Anzeigeelement in den Array-Container. (vgl. Abbildung 3.30).
Abbildung 3.29 : Erstellen eines Arrays
Abbildung 3.30 : Zuweisen des Array-Datentyps
Automatisierungslabor 21
5− Ziehen Sie das Array auf, um sich mehrere Elemente anzeigen zu lassen (vgl.
Abbildung 3.31).
Abbildung 3.31 :Anzeige der Elemente eines Arrays
2D Array
2D Arrays bestehen aus Zeilen und Spalten. Die einzelnen Elemente werden durch Spalten-
und Zeilenindex angesprochen (vgl. Abbildung 3.32).
Abbildung 3.32 :2D Array
Erstellen von 2D Array
Mit Hilfe zweier ineinander verschachtelter For-Schleifen (vgl. Abbildung 3.33) lassen sich
Zweidimensionalen Arrays darstellen. Die äußere Schleife liest die Zeile aus und die innere
Schleife die Spalten.
Abbildung 3.33 : Erzeugen eines 2D Array
Zeilenindex
Spaltenindex
Automatisierungslabor 22
Array Funktionen
LabVIEW stellt zur Bearbeitung von Arrays Funktionen zur Verfügung. Diese befinden sich in
der Palette „Array“ im Blockdiagramm.
Array-Größe: Gibt die Anzahl der Elemente von jeder Dimension aus (vgl. Abbildung 3.34).
Abbildung 3.34: Größe eines 2D-Arrays
Array initialisieren: Erzeugt ein n-dimensionales Array, in dem jedes Element vorinitialisiert
wird. Zum Erhöhen der Dimension muss die Funktion mit Hilfe des Positionierwerkzeugs
erweitern werden. Die Standarddatentypen für diese polymorphe Funktion sind im
Anschlussfeld dargestellt (vgl. Abbildung 3.35).
Abbildung 3.35 : Initialisieren eines Arrays
Array indizieren: Gibt ein Element oder Teil-Array am angegebenen Index aus. Wenn ein n-
dimensionales Array an diese Funktion angeschlossen wird, zeigt sie für jede Dimension einen
Index-Eingang an. Zum Hinzufügen zusätzlicher Elemente oder Teil-Array -Anschlüsse, kann
die Funktion mit der Maus aufgezogen werden. (vgl. Abbildung 3.36). Die Standarddatentypen
für diese polymorphe Funktion sind im Anschlussfeld dargestellt. Weitere Array Funktionen
finden Sie in der LabVIEW Hilfe (Neues VI→ Hilfe→ LabVIEW-Hilfe→ Inhalt→ VI- und
Funktionenübersicht → VI und Funktionen zur Programmierung→ Array-Funktionen)
Automatisierungslabor 23
Abbildung 3.36 : Indizieren eines 2D-Arrays
Clusters
Ein Cluster kann mehrere, auch unterschiedliche, Elemente bündeln. Ein einfaches Beispiel ist
unser Fehlercluster, der aus drei unterschiedlichen Datentypen (String, Bool, Integer) besteht.
In Befehlsorientierten Programmiersprachen sind Cluster mit Strukturen zu vergleichen. Das
Zusammenfassen mehrerer Datentypen als Cluster verringert die Anzahl der
Verbindungsleitungen und sorgt somit für einen übersichtlicheren Programmcode.
Erstellen von Clustern
Cluster lassen sich durch platzieren eines Cluster-Containers (vgl. Abbildung 3.37) im
Frontpanel erzeugen. Danach werden Datenobjekte oder Elemente in den Container
reingezogen. Sie finden den Cluster-Container auf der Palette „Array, Matrix“.
Abbildung 3.37 : Erstellen eines Cluster
Cluster Funktionen
LabVIEW stellt zur Bearbeitung von Cluster bzw. Zugriff auf die Elemente mehrere Funktionen
zur Verfügung. Diese befinden sich auf der Palette „Cluster“ im Blockdiagramm.
Nach Namen aufschlüsseln: Gibt die Cluster-Elemente aus. Die Reihenfolge der Elemente
innerhalb des Clusters muss nicht beachtet werden. Nachdem Sie die Funktion mit einem
Cluster verbunden haben, können Sie bestimmte Elemente auswählen (vgl. Abbildung 3.38).
Automatisierungslabor 24
Abbildung 3.38 : Aufschlüsseln der Elemente eines Clusters
Bündeln: Diese Funktion verbindet einzelne Elemente zu einem Cluster. Sie können außerdem
getrennt voneinander verändert werden. Verbinden Sie dazu ein Cluster, mit der Funktion
„Elemente Bündeln“. Wenn ein Cluster an die Funktion angeschlossen wird, passt sie sich
automatisch ihrer Größe an, so dass für jedes Element ein Eingang angezeigt wird. Die
Standarddatentypen für diese polymorphe Funktion sind im Anschlussfeld dargestellt (vgl.
Abbildung 3.39).
Abbildung 3.39 : Elemente bündeln
Weitere Cluster-Funktionen finden Sie in der LabVIEW Hilfe (Neues VI→ Hilfe→ LabVIEW-
Hilfe→ Inhalt→ VI- und Funktionenübersicht →VI und Funktionen zur Programmierung →VIs
und Funktionen der Palette „ Cluster, Klasse - und Variant-VIs und -Funktionen).
Automatisierungslabor 25
3.9 Zustandsautomat
3.9.1 Definition
Zustandsautomaten sind ein sehr häufig verwendetes und nützliches Entwurfsmuster in
LabVIEW. Mit dem Zustandsautomaten kann jeder Algorithmus umgesetzt werden, der mit
Hilfe eines Zustands- oder Ablaufdiagramms beschrieben werden kann. Zustandsautomaten
werden in der Regel für schwierigere Entscheidungsalgorithmen verwendet, z. B. bei der
Diagnose oder Prozessüberwachung.
Ein Zustandsautomat besteht aus mehreren Zuständen und einer Übergangsfunktion, die den
nächsten Zustand angibt. Endliche Zustandsautomaten kommen in verschiedenen Varianten
vor.
3.9.2 Anwendung von Zustandsautomaten
Verwenden Sie Zustandsautomaten immer dann in einer Applikation, wenn das Programm in
deutlich unterscheidbaren Zuständen gegliedert werden kann. Jeder Zustand kann zu einem
oder mehreren Zuständen oder zum Ende des gesamten Prozesses führen. Der nächste
Zustand eines Automaten wird anhand von Benutzereingaben oder internen Berechnungen
bestimmt. Viele Applikationen haben einen Initialisierungszustand. Diesem folgt in der Regel
ein Standardzustand, in dem verschiedene Aktionen durchgeführt werden können. Die
Aktionen können von vorherigen und aktuellen Eingaben oder Zuständen abhängig sein. Der
letzte Zustand dient meist zum Beenden des Programms und Löschen von Daten.
Benutzeroberflächen sind häufig nach dem Automatenprinzip programmiert. Die
Bedienschritte an der Benutzeroberfläche werden dabei von verschiedenen Programmteilen
verarbeitet.
Jeder Programmteil entspricht einem Zustand im Automaten. Nach Abarbeitung eines
Programmteils wird entweder zum nächsten Schritt gewechselt oder auf eine Eingabe des
Benutzers gewartet. In einer Applikation, die als virtuelles Bedienpult fungieren soll, spielen
für den Programmablauf nur Benutzereingriffe eine Rolle.
Das Automatenmodell wird auch bei der Testautomatisierung befolgt. Dabei entspricht jeder
Test einem Zustand. Je nach Ergebnis eines Tests wird ein anderer Zustand aufgerufen. Das
kann fortlaufend der Fall sein, wodurch Sie eine detaillierte Analyse des Testprozesses
erhalten. Der Vorteil von Automaten besteht darin, dass die Entwicklung von LabVIEW-VIs
nach der Erstellung des Zustandsdiagramms sehr einfach ist.
Automatisierungslabor 26
3.9.3 Aufbau des Zustandsautomaten
Zur Umsetzung eines Zustandsautomaten in einem LabVIEW-Blockdiagramm sind folgende
Komponenten erforderlich:
− While-Schleife: Führt kontinuierlich die verschiedenen Zustände aus.
− Case-Struktur: Enthält einen Case pro Zustand und die Blockdiagrammabschnitte für
die einzelnen Zustände.
− Schieberegister: Enthält Angaben zum Zustandsübergang.
− Programmcode für die Funktionen des Zustands: Setzt die Funktion des Zustands
programmtechnisch um.
− Programmcode für den Übergang: Bestimmt den nächsten Zustand.
In Abbildung 3.40 ist der grundsätzliche Aufbau eines Zustandsautomaten in LabVIEW zu
sehen.
Abbildung 3.40 : Aufbau des Zustandsautomaten
Der Ablauf im Zustandsdiagramm wird im Programm durch eine While-Schleife (1) umgesetzt.
Die einzelnen Zustände werden durch Cases in der Case-Struktur (2) dargestellt. Im
Schieberegister (3) der While-Schleife wird der aktuelle Zustand gespeichert und an den
Eingang der Case-Struktur übermittelt.
1 2
3 4
Automatisierungslabor 27
3.9.4 Steuern von Zustandsautomaten
Der Beginn und der Übergang von Zuständen im Automatenmodell werden am besten mit
Enum-Elementen(4) umgesetzt. Enum-Elemente dienen häufig zur Fallunterscheidung in
Programmen, die nach dem Automatenmodell programmiert sind. Wenn der Benutzer
allerdings versucht, einem Enum-Element einen Zustand hinzuzufügen oder einen Zustand zu
löschen, werden die verbleibenden Verbindungen unterbrochen, die mit Kopien des Enum-
Elements verbunden sind. Dies ist das häufigste Problem bei der programmatischen
Umsetzung von Zustandsautomaten mit Enum-Elementen. Eine Lösung für das Problem
besteht darin, eine Enum mit Typdefinition zu erstellen. Dadurch passen sich alle Exemplare
des Enum-Elements automatisch an gelöschte oder hinzugefügte Zustände an.
3.9.5 Übergänge bei Zustandsautomaten
Es gibt verschiedene Möglichkeit, die Ausführung der Cases in einem Zustandsautomaten
festzulegen. Wählen Sie daher die Methode, die der Funktion und Komplexität Ihres
Zustandsautomaten am besten entspricht. Die einfachste und gebräuchlichste Methode,
zwischen den Zuständen zu wechseln, ist eine einfache Case-Struktur. Diese Methode bietet
die am besten erweiterbare und überschaubare Architektur.
Anwendungsbeispiel: im folgenden Beispiel sollen zwei Zahlen dividiert werden. Die
Ausführung der Berechnung erfolgt über die Schaltfläche „Division“. Der Button „Stopp“
beendet das VI.
Erstellen Sie das in Abbildung 3.41 dargestellte Frontpanel und wechseln Sie in das
Blockdiagramm. Wählen Sie eine Enum-Konstante (Rechtsklick im Blockdiagramm→
Numerisch). In der Enum-Kontante werden die verschiedenen Zustände eingetragen. Dazu
klicken Sie das Element mit der rechten Maustaste an und wählen Sie „Objekte bearbeiten“.
Tragen Sie die Zustände ein und bestätigen Sie danach mit ok, wie in Abbildung 3.42.
angezeigt.
Abbildung 3.41:Frontpanel des Anwendungsbeispiels
Automatisierungslabor 28
Abbildung 3.42 :Eigenschaftsfenster für Enum-Konstante
Fügen Sie im Blockdiagramm eine While-Schleife, Case- und Ereignisstruktur ein. Verbinden
Sie die Enum-Konstante mit der Case-Struktur. Konfigurieren Sie die Bedienelemente
„Division“ und „Stopp“ mit den Ereignissen „Wertänderung“. Klicken Sie mit der rechten
Maustaste am Rand der Case-Struktur und wählen Sie „Case für jeden Wert hinzufügen“ (vgl.
Abbildung 3.43).
Abbildung 3.43 : Zustandsautomat
Kopieren Sie die Enum-Konstante und platzieren Sie diese in den Unterdiagrammen der
Ereignisstruktur. Ändern Sie die Zustände und verbinden Sie die Enum-Konstante mit der
While-Schleife. Wählen Sie mit einem rechten Mausklick am Rand der While-Schleife die
Option „Durch Schieberegister ersetzen“ (vgl. Abbildung 3.44).
Abbildung 3.44 :Zustandsübergängen
Automatisierungslabor 29
Vervollständigen Sie Ihr Blockdiagramm wie in Abbildung 3.45 angezeigt. In den Unter Cases
„Exit“ und „Init“ klicken Sie an den Ausgang des Bedienelements „Ergebnis“ und wählen Sie
„Standard verwenden, wenn nicht verbunden“. Aktivieren Sie die Highlight-Funktion, führen
Sie das VI aus und betrachten Sie den Datenfluss im Blockdiagramm.
Abbildung 3.45 : Blockdiagrammcode
Automatisierungslabor 30
4 QNET-HVACT 2.0
4.1 Einleitung
Die „Heizung, Lüftung und Klimaanlage“ (HVACT 2.0) ist ein QNET Modul das speziell
entwickelt wurde, um auf einer NI-ELVIS-Plattform betrieben zu werden. Das ELVIS-Board ist
mit einer Datenerfassungskarte der NI E-Serie oder M-Serie mit dem HVACT-Modul
verbunden. Um mit dieser Karte zu interagieren, muss ein LabVIEW-Programm geschrieben
werden, welches die Eingänge (Raum- und Umgebungstemperatur) auslesen und die
Ausgangspannung der Heizelemente sowie des Lüfters steuern kann.
4.2 Aufbau
Fehler! Verweisquelle konnte nicht gefunden werden. zeigt die einzelnen HVACT
Komponenten, die in der Tabelle 1 erklärt werden.
Abbildung 4.1: Aufbau HVACT_2
Nr. Beschreibung Nr. Beschreibung
1 +5 V;-15 V; +15 V LEDs 10 Umgebungstemperatur-Sensor
2 Status LEDs 11 Kammertemperatur-Sensor
3 24V QNET Versorgungsspannung 12 Kanaltemperatur-Sensoren
4 Sicherung 13 Spannungsanschluss Lüfter
5 Externe Power LED 14 8-Pin Heizkammer Anschluss
6 Heizung LED 15 5-Pin Lüfter Anschluss
7 Lüfter LED 16 4-PinTemperatur-Sensoren Anschluss
8 Lüfter 17 PCI Verbindung für NI ELVIS-Board
9 Heizkammer (Heizung)
Tabelle 1: Bestandteile
Automatisierungslabor 31
Das QNET-HVACT-System besteht aus einem Plexiglaskanal oder Kammer, mit einer
Heizvorrichtung an einem Ende und einem Gebläse auf der anderen Seite. Ein
Temperaturfühler ist in der Kammer platziert, an der Stelle, an der die Temperatur geregelt
werden soll. Die QNET HVAC Leiterplatte enthält eine PWM-Spannungsgesteuerten
Leistungsverstärker, der verwendet wird, um die Wärme zu erzeugen. Dies wird durch das
Anlegen einer Eingangsspannung (0-10V) auf ein Array von parallel geschalteten
Widerständen realisiert. Das Gebläse ist ein 10V,-drehzahlgeregelter Lüfter.
4.3 Ansteuerung
In Abbildung 4.2 ist der schematische Aufbau des DAQ-Systems dargestellt.
Abbildung 4.2: DAQ-System
4.4 Komponenten Beschreibung
In diesem Kapitel wird kurz auf die Beschreibung der einzelnen Komponenten eingegangen.
4.4.1 Heizkammer
Wichtig! Die Eingangsspannung der Widerstände sollte nicht mehr als 10V betragen, auch
wenn diese mit 24V betrieben werden können. Die Hitze die von den Elementen abgestrahlt
wird, kann für die anderen Komponenten des HVACT-Moduls schädlich sein.
4.4.2 Lüfter
Das Gebläse ist ein 10V-drehzahlgeregelter Lüfter. Dieser kann durch die Ansteuerung Hoch
und Runter geregelt werden. Es ist darauf zu achten, dass dieser Maximal 10V und Minimal
2V beträgt.
Automatisierungslabor 32
4.4.3 PWM Power Amplifier
Es wird ein PWM-Leistungsverstärker verwendet, um Widerstände anzusteuern und die
Kammer zu erwärmen. Der Eingang des Verstärkers ist der Ausgang des Digital-Analog-
Umwandlers (d.h. D/A) von Kanal #0 des DAQ-Systems. Die maximale Ausgangsspannung des
Verstärkers beträgt 10 V. Der maximale Spitzenstrom ist 2 A und der maximale kontinuierliche
Strom 0,5 A. Der Verstärkungsfaktor ist 2,3 V/V.
4.4.4 Analoge Strommessung
Das analoge Signal, das proportional zu der Ausgangsspannung des PWM-Verstärkers ist, ist
an dem A/D-Wandler von Kanal #0 erhältlich. Der Spannungssensor hat eine Empfindlichkeit
von 6,44 V/A. Eine solche Strommessung kann verwendet werden, um die an dem
Heizelement angelegten Strom zu überwachen.
4.4.5 Spannungsversorgung
Das HVACT-Board hat eine 24-Volt-Buchse, um den On-Board-PWM-Verstärker nutzen zu
können. Die B+ LED auf dem Board leuchtet grün, wenn der Verstärker eingeschaltet ist.
4.5 Technische Daten
Die Spezifikationen des HVACT Systemmodells ist in den nachfolgenden Tabellen aufgeführt.
Symbol Beschreibung Wert Einheit
Halogenlampe
Kv Steigungsfaktor 0,01 °C/(V.s)
PWM-Verstärker
Vmax PWM-Verstärker maximale Ausgangsspannung 24 V
PWM-Verstärker maximaler Ausgangsstrom 2,5 A
PWM-Verstärkungsfaktor 2,3 V/V
Tabelle 2: Systemeigenschaften
4.6 Äußere Einflüsse
Es ist wichtig, dass die Anlage unter folgenden Bedingungen betrieben wird:
Beschreibung Wert Einheit
Betriebstemperatur 5 bis 40 °C
Luftfeuchtigkeit 40 bis 80 %
Tabelle 3: Umweltbedingungen
Automatisierungslabor 33
5 Praktikumsdurchführung
5.1 Erstellung eines Beispielprojektes in LabVIEW
In diesem Versuch werden die Regelungsalgorithmen mit entsprechender Benutzeroberfläche
in LabVIEW implementiert. Die Verarbeitung der Algorithmen erfolgt über das „PID und Fuzzy
Logic Toolkit“ und „DAQmx“. Dazu werden folgende Softwarepaletten benötigt, um die
Ansteuerung des ELVIS-Boards zu realisieren.
• LabVIEW
• NI Elvis
• DAQmx
• PID und Fuzzy logic Toolkit
Starten Sie LabVIEW
Um ein neues Projekt zu erstellen, gehen Sie folgendermaßen vor:
Gehen Sie auf Datei → Projekt erstellen (vgl. Abbildung 5.1).
Abbildung 5.1 :Erstellen eines Projektes
Wählen Sie „Leeres Projekt“, um ein leeres Projekt anzulegen und klicken Sie auf fertigstellen.
LabVIEW erstellt ein Projekt, wie in Abbildung 5.2 angezeigt.
Automatisierungslabor 34
Abbildung 5.2: LabVIEWProjekt-Explorer
Wählen Sie Datei → Speichern, um das Projekt zu speichern.
− Projektname: HVAC.
− Pfad: C: → Users → User XXX→ Documents →LabVIEW >> Gruppe XYZ
und mit OK bestätigen (oder auf Ihrem USB-Stick).
Fügen Sie dem Projekt unter der Rubrik „Mein Computer“ ein neues VI hinzu. Dazu klicken Sie
im Projekt-Explorer mit der rechten Maustaste auf Mein Computer → Neu → VI. Klicken Sie
auf Datei → Speichern, und speichern Sie das VI ab. LabVIEW fügt im Projekt-Explorer das VI
hinzu. Öffnen Sie das VI mit einem Doppelklick. Danach kann die Benutzeroberfläche gestaltet
und im Blockdiagramm der Code erstellt werden.
5.2 Lesen und Schreiben mittels DAQmx
Machen Sie sich zuerst mit der Hardware vertraut, und überprüfen Sie ob diese richtig
angeschlossen und am PC erkannt wird. Verwenden Sie dafür den NI-MAX (Measurement
Automation Explorer) dieser dient zur:
− Konfiguration von Hard- und Software der Firma National Instruments.
− Anlegen von Sicherungskopien der Konfigurationsdaten.
− Erstellen und Bearbeiten von Kanälen, Task, Schnittstellen, Skalierungen und virtuelle
Instrumenten.
− Ausführung von Systemdiagnosen.
− Anzeigen von Geräten, die mit dem System verbunden sind.
− Aktualisieren von NI-Software.
Wird das Gerät nicht gefunden rufen Sie eine Aufsichtsperson!
Ist das Gerät im NI-MAX sichtbar, können Sie mit der ersten Aufgabe beginnen.
Automatisierungslabor 35
5.2.1 Aufgabe 1 Lesen
Verwenden Sie das vorhandene VI (HVAC Template) und machen Sie sich damit vertraut. In
diesem VI wird alles Initialisiert und die verschiedenen Temperaturen als Array ausgegeben.
Ändern Sie die vorhanden VI`s NICHT!
Programmieren Sie dieses VI mittels LabVIEW so um (als Zustandsautomat), dass die
Temperaturen in der Kammer (7) sowie die Außentemperaturen dargestellt werden. Folgende
Funktionen sollten in der dialogorientierten Anwendungssoftware möglich sein.
− Darstellung der Temperaturverläufe in einem Diagramm (ist, soll und die außen
Temperatur).
− Starten der Temperaturmessung über eine Schaltfläche „Ausführen“.
− Beenden der Temperaturmessung über eine Schaltfläche „Beenden“.
− Einen Fehler (Eingang) sowie Fehler (Ausgang).
5.2.2 Aufgabe 2 Schreiben
Programmieren Sie dieses VI mittels LabVIEW so um (als Zustandsautomat), das über den
Digital-Analog Wandler A0#0 eine Spannung zu der Heizkammer (max. 10V). und über A0#1
eine Spannung zu dem Lüfter (2V-10V) überträgt. Nach dem Beenden des Programms, sollen
die Ausgänge mit jeweils 0V beschrieben werden! Bevor Sie das Programm starten, rufen Sie
eine Aufsichtsperson!
Folgende Funktionen sollten in der dialogorientierten Anwendungssoftware möglich sein.
− Darstellung des Spannungsverlaufes in einem Diagramm.
− Eingabe der Spannungen über jeweils eine Schaltfläche „Spannung“.
− Beenden des Programmes über die Schaltfläche „Beenden“.
− Einen Fehler (Eingang) sowie Fehler (Ausgang).
Wichtig: Nach jedem Beenden, müssen die Heizkammer und der Lüfter wieder 0V am
Eingang haben.
5.3 Erstellung eines Zweipunktreglers
5.3.1 Erklärung:
Eine „Ein-Aus-Regelung“ oder auch Zweipunktregler genannt, ist eine der einfachsten
Regelungsmöglichkeiten. Die Heizung wird eingeschaltet, wenn die Temperatur niedriger ist
als der gewünschte Wert, und die Heizung wird abgeschaltet, wenn die Temperatur höher ist
als der gewünschte Wert. Um ein durchgehendes Umschalten zu verhindern, wird
üblicherweise eine Hysterese eingebaut. Ein Blockdiagramm ist in der nachfolgenden
Abbildung 5.3 zu erkennen.
Automatisierungslabor 36
Abbildung 5.3: Blockschaltbild
Die Regeldifferenz e im Bild 5.3 ist die Abweichung zwischen der soll Temperatur Ts und der
ist Temperatur Ti. Der Zweipunktregler ist mit einer bestimmten Hysterese Th implementiert
was in der Abbildung 5.4 gezeigt wird. Die Heizkammer fungiert hier als „Heizung“ und wird
als einfachen Stellantrieb mit Sättigung dargestellt. Als letztes wird die Kammer-Anlage mit
der Übertragungsfunktion P(s) gezeigt. Auf diese Kammer wirkt neben der Heizung noch ein
Lüfter, der als Störfunktion angenommen werden kann.
Abbildung 5.4: Zweipunktregler
Die Breite der Hysterese ΔTh muss so eingestellt werden, dass ein großes Messrauschen kein
unbeabsichtigtes Schalten erzeugt. Wie in der Abbildung 5.4 gezeigt wird, kann die
Ausgabesignalspannung des Zweipunktreglers mit einem Mittelwert eingestellt oder mit
einem Offset belegt werden. In dieser Aufgabe soll das Verhalten der Heizungsanlage für
verschiedene Werte der Regelparameter untersucht werden.
Automatisierungslabor 37
Der Steuereingang und die gemessene Ausgangstemperatur haben die interessante
Eigenschaft, dass es möglich ist, ein einfaches Modell für den Prozess zu finden. Das
Temperaturverhalten ist eine einfache Rampe. Dadurch kann man sagen, dass die Temperatur
das Integral der Spannung ist. Unter bestimmten Bedingungen kann das Verfahren durch die
einfache Übertragungsfunktion beschrieben werden:
Formel 1:
���� �����
������
�
Wobei der Parameter Kv die Steigung der Rampe ist.
5.3.2 Aufgabe 3:
Programmieren Sie mittels LabVIEW (als Zustandsautomat) und DAQmx ein Programm, das
einen Zweipunktregler verwendet um die eingegebene Solltemperatur zu regeln. Folgende
Funktionen sollten in der dialogorientierten Anwendungssoftware möglich sein:
− Darstellung des Spannungsverlaufes in einem Diagramm.
− Darstellung des Temperaturverlaufes in einem Diagramm (ist, soll, außen).
− Bedienelement für die Eingabe der Solltemperatur (Max. 60 °C).
− Starten der Regelung über eine Schaltfläche „Regelung Starten“.
− Bedienelemente für die breite der Hysterese sowie für die Amplitude und den Offset.
− Beenden des Programmes über die Schaltfläche „Beenden“.
− Einen Fehler (Eingang) sowie Fehler (Ausgang).
Bestimmen Sie den Parameter Kv indem Sie zuerst die Systemparameter so einstellen, dass
Sie einen Symmetrischen verlauf der Regelung erhalten. Anschließend können Sie über das
Verhältnis von Zeit und Temperatur den Wert bestimmen.
Wichtig: Nach jedem Beenden, muss die Heizkammer wieder 0V am Eingang haben.
5.4 Erstellung eines PI/PID-Reglers
5.4.1 Erklärung
Die Schwingungen, die mit einem Zweipunkregler erfolgen kann durch Verwendung eines PI-
Reglers verhindert werden. Um einen solchen Regler analytisch auszulegen, wird ein einfaches
Model der Anlage benötigt. Das Blockdiagramm in Abbildung 5.5 zeigt die Anlage mit den
verschiedenen Elementen.
Automatisierungslabor 38
Abbildung 5.5: Blockdiagramm PI-Regler
Die Übertragungsfunktion ist die Gleiche wie in Gleichung (1) gezeigt. Die geschlossene
Übertragungsfunktion lautet:
Formel 2:
��� � � ������ � �
�� � � ��� � � ��
Dabei lautet das charakteristische Polynom:
Formel 3:
�� � � ��� � � ��
Umgeschrieben lautet es:
Formel 4:
�� � 2��� � ���
Wobei �� die Kreisfrequenz und � die Dämpfung darstellt. Die Gleichung (Formel 4:) ist die
gleiche wie in Formel 3) mit dem Proportionalitäts-Glied:
Formel 5:
�� �2���
�
Und dem I-Glied:
Formel 6:
�� ���
�
�
Automatisierungslabor 39
Große Werte von �� geben eine große Regelverstärkung an, was große Schwankungen in den
Steuersignalen zur Folge hat. Der Vorfilter ��� kann verwendet werden, um das
Überschwingen der Sprungantwort anzupassen.
5.4.2 Aufgabe 4:
Programmieren Sie mittels LabVIEW (als Zustandsautomat) und DAQmx ein Programm, das
einen PI/PID-Regler verwendet um die eingegebene Solltemperatur zu regeln. Folgende
Funktionen sollten in der dialogorientierten Anwendungssoftware möglich sein:
− Darstellung des Spannungsverlaufes in einem Diagramm.
− Darstellung des Temperaturverlaufes in einem Diagramm (ist, soll, außen).
− Bedienelement für die Eingabe der Solltemperatur (Max. 60 °C).
− Starten der Regelung über eine Schaltfläche „Regelung starten“.
− Bedienelemente für die PI/PID-Werte.
− Beenden des Programmes über die Schaltfläche „Beenden“.
− Einen Fehler (Eingang) sowie Fehler (Ausgang).
− Berechnen Sie den Ki und Kp Wert mit den Parametern �� � 0,125� !� � 0,6.
Wichtig: Nach jedem Beenden, muss die Heizkammer wieder 0V am Eingang haben.
5.5 Erstellung eines Fuzzy-Reglers
5.5.1 Erklärung
Die sogenannte Fuzzylogik (engl. fuzzy) bedeutet „verwischt, verschwommen“, ist eine
Theorie, die für die Modellierung von Unsicherheit und Vagheit von umgangssprachlichen
Beschreibungen entwickelt wurde. Durch dieses Verfahren, können die sogenannte
„Fuzziness“ über Angaben wie „wenig“, „viel“, „etwas“ in mathematischen Modellen erfasst
werden. Ein Skript zur Erklärung finden Sie auf der Auslegestelle (AMS.Labor). Ein Beispiel wie
ein Fuzzy-System ausgelegt wird, finden Sie im Anhang.
5.5.2 Aufgabe 5:
Erstellen Sie mit Hilfe des „Fuzzy System Designer“ einen Fuzzy-Regler, der folgende
Eigenschaften besitzt:
− Die Eingabevariablen sind Ist-/Soll-Temperatur (Überlegen Sie sich sinnvolle Bereiche).
− Die Ausgabevariable ist die Spannung für die Heizkammer (0V-10V).
− Das Fuzzy-System soll jeweils 5 Membership-Funktionen besitzen.
− Erstellen Sie eine Matrix mit den Zusammenhängen von Eingang zu Ausgang.
− Erstellen Sie die Regeln für das System.
− Testen Sie ihr System mit dem „Fuzzy System Designer“.
Automatisierungslabor 40
5.5.3 Aufgabe 6:
Programmieren Sie mittels LabVIEW (als Zustandsautomat) und DAQmx ein Programm, das
einen Fuzzy-Regler verwendet um die eingegebene Solltemperatur zu regeln. Folgende
Funktionen sollten in der dialogorientierten Anwendungssoftware möglich sein:
− Darstellung des Spannungsverlaufes in einem Diagramm.
− Darstellung des Temperaturverlaufes in einem Diagramm (ist, soll, außen).
− Bedienelement für die Eingabe der Solltemperatur (Max. 60 °C).
− Starten der Regelung über eine Schaltfläche „Regelung starten“.
− Eine Lademöglichkeit für einen Fuzzy-System auszuwählen.
− Beenden des Programmes über die Schaltfläche „Beenden“.
− Einen Fehler (Eingang) sowie Fehler (Ausgang).
Wichtig: Nach jedem Beenden, muss die Heizkammer wieder 0V am Eingang haben.
5.6 Zusammenfassen der Programme
5.6.1 Aufgabe 7:
Programmieren Sie mittels LabVIEW (als Zustandsautomat) und DAQmx ein Programm, das
alle Teilprogramme (Aufgabe 3, 4, 5) beinhaltet. Der Benutzer soll die Möglichkeit haben in
dem Programm zu entscheiden welche Regelung er vornehmen möchte. Folgende Funktionen
sollten in der dialogorientierten Anwendungssoftware möglich sein:
− Darstellung des Spannungsverlaufes in einem Diagramm.
− Darstellung des Temperaturverlaufes in einem Diagramm (ist, soll, außen).
− Starten der Regelung über eine Schaltfläche „Regelung Starten“.
− Bedienelemente für die breite der Hysterese sowie für die Amplitude und den Offset.
− Bedienelemente für die PI/PID-Werte.
− Eine Lademöglichkeit für einen Fuzzy-System auszuwählen.
− Ein Auswahlfenster für die gewünschte Regelungsmethode.
− Beenden des Programmes über die Schaltfläche „Beenden“.
− Einen Fehler (Eingang) sowie Fehler (Ausgang).
5.6.2 Aufgabe 8:
Erstellen Sie eine Zusammenfassung mit folgenden Inhaltspunkten:
− Die Unterschiede eines Fuzzy-Reglers im Vergleich zu einem PI/PID-Regler.
− Erklärung, warum sich das Fuzzy-System in Deutschland nicht durchgesetzt hat.
− Was sind die wichtigsten Eigenschaften eines Fuzzy-Systems.
Automatisierungslabor 41
6 Anhang
6.1 Ein Fuzzy-Beispiel
Im nachfolgenden soll Ihnen ein einfaches Beispiel klar machen, wie man ein Fuzzy-System
auslegt.
Beispiel: Ein Bremsvorgang auf der Autobahn soll mit einem Fuzzy-Regler realisiert werden.
Die Eingangsvariablen sind dabei:
− Abstand A zum vorausfahrenden Fahrzeug
− Geschwindigkeit G des eigenen Fahrzeugs
Die Ausgangsvariable ist:
− Bremskraft K für Bremsmanöver
Zuerst wird festgelegt in welchen Bereichen der Abstand A, die Geschwindigkeit G und die
Bremskraft K angegeben werden. Z.B. wird für den Abstand ein Bereich von 0 bis 500m
gewählt. Diese Bereiche (Fuzzy-Set) können von dem Benutzer selbst erstellt werden. Es ist
allerdings darauf zu achten, dass hier sinnvolle Werte gewählt werden.
Als nächstes müssen diese Bereiche mit sogenannten Membership-Funktionen unterteilt
werden. Wie viele Bereiche gewählt werden, liegt wiederrum bei dem Benutzer es ist nur
darauf zu achten dass jeder Wert abgedeckt ist. Je mehr Funktionen, umso genauer wird der
Regler (Für den Abstand A werden fünf Membership-Funktionen eingeteilt).
Sind diese Funktionen bestimmt, müssen linguistische Variablen angelegt werden, die diese
Beschreiben. Die Namen der Variablen liegen wiederrum beim Benutzer. Z.B. werden für den
Abstand die Variablen „sehr_niedrig, niedrig, mittel, hoch und sehr_hoch“ angenommen.
Hat man diese drei Schritte erledigt, erhält man folgende Fuzzy-Sets (s. Abbildung 6.1).
Automatisierungslabor 42
Abbildung 6.1: Fuzzy-Sets
Als nächsten Schritt, müssen Regeln erstellt werden, die den Zusammenhang zwischen
Eingang und Ausgang definieren die sogenannte „Fuzzifizierung“. Es ist darauf zu achten, dass
für jeden Zusammenhang eine Regel definiert sein muss. Bei zwei Eingängen mit je fünf
Funktionen sind 25 Regeln erforderlich.
Bremsverhalten (1 Regel):
Wenn A = mittel UND G = sehr_hoch DANN K = dreiviertel.
Bremsverhalten (2 Regel):
Wenn A = niedrig UND G = sehr_hoch DANN K = voll.
Wenn wir uns jetzt einmal diese Regel betrachten, mit den Werten A=175m, und G=190 km/h
dann schneidet der Wert A=175 zwei Funktionen (niedrig und mittel) und G nur die Funktion
sehr_hoch. Es ergibt sich aus diesen Zusammenhängen folgende Abbildung 6.2:
Automatisierungslabor 43
Abbildung 6.2: Fuzzifizierung
Betrachten wir zuerst die erste Regel, dann stellt sich folgender Erfüllungsgrad ein:
Abbildung 6.3: Regel 1
Automatisierungslabor 44
Als Zweites muss die zweite Regel in Betracht gezogen werden:
Abbildung 6.4: Regel 2
Das Minimum der Fuzzifizierung liefert im Falle mehrerer Prämissen den Erfüllungsgrad der
Regel.
Nach der Bestimmung der Funktionen am Ausgang mit der jeweiligen Gewichtung (0.25, 0,75)
muss jetzt eine Aussage getroffen werden, welcher Wert sich daraus ergibt. Um dies zu
bestimmen, muss eine Defuzzifizierung vorgenommen werden. Durch die Defuzzifizierung
wird eine scharfe Ausgangsgröße berechnet (Scharf: einen festen Wert).
Um Defuzzifizieren zu können, gibt es viele verschiedene Möglichkeiten. Betrachten wir
nochmal unser Beispiel mit dem Bremsvorgang auf der Autobahn.
Wir erhielten als Ergebnis der zwei Regeln folgende „Attraktivitätsfunktion“:
Abbildung 6.5: Ergebnis der zwei Regeln
Automatisierungslabor 45
Es muss sich bei dem Bremsvorgang ein Wert einstellen, der im Bereich von 50%-100% liegt.
Die möglichen Defuzzifizierungsmethoden lauten:
− Maximummethoden
− Schwerpunktmethoden
Diese haben jeweils ihre eigenen Vor- bzw. Nachteile. Unser Bsp. wird hier mit der
Schwerpunktmethode (Flächenschwerpunkt) berechnet.
Abbildung 6.6: Ergebnis
Als Ergebnis würde man erhalten, dass man bei einer Geschwindigkeit 190 km/h und einem
Abstand von 175m eine Bremsung von ca. 80% durchführen muss.