Versuch NI-ELVIS (HVAC 2.0) - htwsaar.de · Versuch NI-ELVIS (HVAC 2.0) Programmierung mit LabVIEW...

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


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


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.


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.


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


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


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


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


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


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).


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


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.


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.


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


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


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.


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


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).


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.


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


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


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)


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).


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).


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.


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


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


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


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


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


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.


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


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.


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.


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“.


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.


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.


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 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.



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.


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:

��

�

�


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:


einen PI/PID-Regler verwendet um die eingegebene Solltemperatur zu regeln. Folgende





− Starten der Regelung über eine Schaltfläche „Regelung starten“.

− Bedienelemente für die PI/PID-Werte.



− Berechnen Sie den Ki und Kp Wert mit den Parametern �� 0,125� !� � 0,6.


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“.


5.5.3 Aufgabe 6:


einen Fuzzy-Regler verwendet um die eingegebene Solltemperatur zu regeln. Folgende





− Starten der Regelung über eine Schaltfläche „Regelung starten“.

− Eine Lademöglichkeit für einen Fuzzy-System auszuwählen.




5.6 Zusammenfassen der Programme

5.6.1 Aufgabe 7:


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:



− 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.



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.


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).


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:


Abbildung 6.2: Fuzzifizierung

Betrachten wir zuerst die erste Regel, dann stellt sich folgender Erfüllungsgrad ein:

Abbildung 6.3: Regel 1


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


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.

Date post:	14-Jun-2020
Category:	Documents
Upload:	others
View:	11 times
Download:	0 times