Ansteuerung einer Schrittmotor-Achse mit NI Labview

LabView: Einleitung

Das Programm LabView des Herstellers National Instruments ermöglicht die Programmierung von Simulationsmodellen und/oder Eingabe/Ausgabe- Programmen mittels einer graphischen Oberfläche. Im englischen Sprachgebrauch wird dabei häufig der Begriff I/O (Input/Output) verwendet.

Dabei ist die Handhabung ähnlich den Produkten Matlab Simulink oder LEGO Mindstorms BricX.

Grundbestandteile sind dabei unterschiedliche Funktionsbausteine, welche durch farbige Linien in der graphischen Programmieroberfläche miteinander logisch verknüpft werden können.

Der Vorteil der graphischen Programmierung ist, dass die Erkennung der Zusammenhänge von Variablen bzw. Werten durch Verfolgen der Verbindungslinien visuell sehr leicht möglich ist. So kann u.U. schneller ein Verständnis für die Grundaufgaben des Programmes erzielt werden, als wenn nur abstrakter Funktionscode betrachtet wird.

Nachteil der graphischen Programmierung ist, dass bei einem stark verschachtelten Aufbau die Übersichtlichkeit des Programmes leidet. In diesen Fällen kann u.U. die selbe Aufgabe mit einer schriftbasierten Programmiersprache (bspw. C) übersichtlicher gelöst werden.

In der Folge soll der Einsatz der Software in Verbindung mit einem Eingabe/Ausgabe-Controller anhand einer Ansteuerung eines Schrittmotors erläutert werden.

Regelkreis

Vor der Realisierung in Hardware und Software wurde zunächst ein Regelkreis für die Ansteuerung des Schrittmotors entworfen. Für die Ansteuerung des Schrittmotors wird ein Motorcontroller des Typs Gecko Drive verwendet. Dieser übernimmt die leistungsseitige Ansteuerung des Motors. Der Motor bewegt eine Linearachse, deren Bewegung für eine Achse einer Bearbeitungsmaschine verwendet wird. Der NI Controller fungiert als Steuerteil des Aufbaus, indem die benötigten Signale an den Motorcontroller gesendet werden. Über einen Motorpositionssensor ist es möglich, die Bewegungen des Motors softwareseitig einzulesen und für einen Regelkreis zu verwenden. Dabei soll der Weg s, den die Linearachse zurücklegt, geregelt werden. Den Regelkreis zeigt die folgende Abbildung 1.

Abbildung 1: Regelkreis für Schrrittmotoransteuerung

Belegungsplan für Motoransteuerung

Zunächst sollten die benötigten Eingänge und Ausgänge, die für die Funktion des Motors benötigt werden, definiert werden. In diesem Fall wurde zur Ansteuerung des Schrittmotors ein Leistungsmodul des Typs Gecko Drive verwendet. Aus dem Datenblatt lassen sich die notwendigen Informationen über die Beschaffenheit der benötigten Signale entnehmen.

Schließlich kann das Leistungsmodul mit dem Schrittmotor verbunden werden und entsprechende Leitungen für den Anschluss an den NI Controller verlegt werden.

In diesem Fall wurde nach dem Belegungsplan in Abbildung 2 verkabelt.

Abbildung 2: Belegungsplan für Schrittmotoransteuerung

Installation der Hardware

Um mit der Programmierung zu starten, muss zunächst ein leeres Projekt erstellt werden. Dieses enthält später alle Informationen, Schnittstellen und graphischen Oberflächen, die man für ein Programm benötigt.

Dafür muss die aktuell auf dem Computer installierte Version von National Instruments LabView gestartet werden. Es öffnet sich ein Fenster.

Dort muss zum Start die Option ==> Leeres Projekt erzeugen gewählt werden. Daraufhin zeigt sich der sogenannte Projekt-Explorer, welcher alle wichtigen Bestandteile des Projektes als auf-und zuklappbare Reiter darstellt.

Möchte man das Projekt mit einem Eingabe/Ausgabegerät verwenden, muss dieses zunächst hinzugefügt werden. Die folgenden Schritte beschreiben, wie ein I/O Controller cRIO 9024 in ein Projekt eingebunden werden kann.

Im Project-Explorer befindet sich nun das leere Projekt, dem nun die Hardware hinzugefügt wird:

• Rechtsklick auf das Projekt => Neu => Ziele und Geräte

• Im Ordner Real-Time CompactRIO befindet sich die über das Netzwerk verbundene HSHL-CRIO-CPU02 und wird über einen Doppelklick zum bestehenden Projekt hinzugefügt.

Abbildung 3: Leeres Projekt

Anschließend erscheint im Project-Explorer die Hardware Chassis (CRIO-9114). Das im Slot 1 befindliche Modul zeigt alle DIO´s (DIO = digital Input/Output) welche über einen Rechtsklick auf Mod1 konfiguriert werden können, d.h. die jeweiligen DIO´s können als Input oder Output definiert werden.

• Um potenzielle Fehler zu vermeiden, ist es sinnvoll den verwendeten Input bzw. Output direkt umzubenennen. Dazu muss lediglich doppelt auf die Bezeichnung des DIO (bspw. DIO20) im Projektexplorer geklickt werden und der gewünschte Name eingetragen und durch die Enter-Taste bestätigt werden.

Abbildung 4: Einbindung der Hardware CompactRIO

Die Hardware wurde nun mit dem Programm "bekannt gemacht" und kann verwendet werden.

Das folgende Kapitel beschreibt die notwendigen Schritte, um mit der Programmierung zu starten und welche Bestandteile die Programmieroberfläche aufweist.

Grundlegendes: VI und Blockdiagramm

In ein erstelltes leeres Projekt kann nun ein "Visual Interface", kurz VI genannt, eingefügt werden. Es handelt sich dabei um eine graphische Benutzeroberfläche für das zugehörige Programm. Auf dieser Oberfläche lassen sich Bedienelemente oder Eingabefelder anordnen, um durch diese Einfluss auf das Programm zu nehmen. Außerdem lassen sich Zustände und Werte des Programmes durch Anzeigeelemente darstellen, um den Fortschritt des Programmes während des Laufes verfolgen zu können. Dies erleichtert oftmals die Fehlerbehebung. Um ein VI hinzuzufügen, muss auf das weiße-Blatt-Symbol oben links in der Projekt-Explorer Ansicht geklickt werden:

Abbildung 5:Erstellung eines leeren VI

Es erscheint daraufhin ein leeres VI. Dieses stellt ein graphic user interface für die Interaktion mit dem späteren Programm dar. Das eigentliche Programm wird in einem "Blockdiagramm" genannten Fenster erzeugt und editiert. Das Blockdiagramm wird folgendermaßen geöffnet:

"Fenster" => "Blockdiagramm"

VI und Blockdiagramm stehen in direkter Beziehung. Es können Eingaben im VI gemacht werden, die das Blockdiagramm beeinflussen und es können Ausgaben des Blockdiagramms auf dem VI dargestellt werden.

Besonders zu beachten ist, dass es sich in diesem Fall um ein Programm handelt, welches auch trotz Installation der Hardware, stets nur auf dem PC abläuft. Dadurch können sich Schwierigkeiten bei der Übertragung ergeben. Dies gilt besonders bei verhältnismäßig "schnellen" Signalen (d.h. Signale mit hohen Frequenzen). In diesem Fall soll die Ansteuerung eines Schrittmotors mit Signalen im Mikrosekunden-Bereich erfolgen. Daher wird die Nutzung des sogenannten Host-Programmes, d.h. des Programmes welches auf dem PC läuft, nicht zum Erfolg bei der Ansteuerung führen. LabView bietet durch den sogenannten RealTime-Modus eine Funktionalität um diese Problematik zu Umgehen.

Das folgende Kapitel erläutert zunächst, wie die eigentliche Programmierung im Blockdiagramm umgesetzt wird.

Erste Schritte: Programmieren im Blockdiagramm

In das leere Blockdiagramm können nun Schleifen, Variablen und Funktionsbausteine per drag&drop aus dem "Funktionsmenü" eingefügt und miteinander verknüpft werden. Die Verbindungen zwischen Bausteinen werden grafisch durch Linien gebildet, die mit der Computermaus gezogen werden:

Abbildung 6: Beispieldarstellung im Blockdiagramm

Die Funktionspalette enthält eine Vielzahl an Elementen, die unterschiedlichste Möglichkeiten von Berechnungen, Umformungen, Vergleichen etc. bieten. Besonders beachtet werden muss, dass nicht jeder Baustein mit jedem verknüpft werden kann, da teilweise die verwendeten Datentypen nicht kompatibel sind. Am sinnvollsten ist es, wenn man einen neuen Baustein einsetzen möchte, diesen zunächst anzuklicken und unter "Hilfe" die Beschreibung zu studieren. Dort sind alle Eingangs-und Ausgangsgrößen, die Funktion und die benötigten Datentypen des Bausteins beschrieben.

Die unterschiedlichen Datentypen, die in einem Blockdiagramm zum Einsatz kommen, werden durch unterschiedliche Farben der Verbindungslinien dargestellt. Die wichtigsten sind:

- blau = integer - orange = double - grün = bool

Teilweise können Datentypen auch durch Bausteine entsprechend transformiert werden, um sie einsetzen zu können.

Im Falle von Programm-Schleifen zeigt sich der Vorteil der graphischen Programmierung: Eine Schleife wird durch einen Rahmen dargestellt, in den entsprechende Operationen eingefügt werden können. Der Inhalt des Rahmens entspricht dann dem Teil des Programmes, welches entsprechend der Laufzeit der Schleife wiederholt wird. Als Abbruchbedingung für die Schleife kann beispielsweise ein Bedienelement auf dem VI dienen oder es kann eine Laufzeit der Schleife analog zu anderen Programmiersprachen vorgegeben werden.

Eine Eingabemöglichkeit im VI, die dann auf das Programm im Blockdiagramm Einfluss nimmt, lässt sich folgendermaßen umsetzen: Man fügt zunächst ein Bedienelement im Blockdiagramm ein. Dieses erscheint dann gleichzeitig auch im VI und kann dort beliebig platziert werden.

Ansteuerung eines Schrittmotors mit LabView

Grundsätzlich gibt es mehrere Möglichkeiten über LabView einen Schrittmotor anzusteuern. Voraussetzung dazu ist eine Art Pulsweitenmodulation (PWM) zu erhalten. Eine Option ist einen von LabView bereits fertigen "Signalgenerator" zu wählen. Dieser ist einfach und übersichtlich aufgebaut. Jedoch führte es schnell zu Problemen sobald man einen Zähler oder ein Abbruchkriterium hinzufügen möchte. In dem folgenden Programm wird dies über eine "flache Sequenz" realisiert.

Befindet man sich im Blockdiagramm, so können über die von LabView gestellte Funktionspalette die gewünschten Bausteine mittels drag&drop in die Arbeitsfläche gezogen werden. Unter "Programmierung" => "Strukturen" befindet sich der Baustein "Flache Sequenz". Die Funktion dieses Bausteins ist es, die entsprechenden Operationen, die in der Sequenz angegeben werden, zyklisch zu wiederholen. Nachdem der Baustein auf die Arbeitsfläche gefügt wird, besteht dieses Bauteil nur aus einer Sequenz in Form eines Rahmens. Da wir für die Ansteuerung des Schrittmotors jedoch zwei unterschiedliche Zustände (1/0) benötigen, kann man über ein Rechtsklick der Sequenz "einen Rahmen danach einfügen" wählen. Um die Zustände der jeweiligen Sequenz zu definieren, wird über "Programmierung" => "Boolesch" eine "True"- bzw. "False-Konstante" eingefügt. Die Länge der einzelnen Zustände werden über Wartezeiten ("Warten auf ein Vielfaches von…") bestimmt ("Programmierung" => "Timing"). Um den Output des Signals festzulegen, muss über den Projekt-Explorer der gewünschte DIO in das Blockdiagramm gefügt werden. Wichtig: Der gleiche DIO muss in jeder der Beiden Sequenzen vorhanden sein. Anschließen muss die True- bzw. False-Konstante mit dem jeweiligen DIO verbunden werden (Hier DIO0). Somit ändert sich der Zustand nach der definierten Wartezeit von z.B. 20ms von 1 (5V) auf 0(0V). Dieser Ablauf würde einem Step entsprechen. Um dies zu duplizieren, wird das Programm in eine While-Schleife gefügt ("Programmierung" => "Strukturen" => "While-Schleife"). Damit werden die Sequenzen so oft wiederholt, bis über ein Abbruchkriterium die Schleife gestoppt wird. Anfangs ist es sinnvoll, dies über einen Schalter o.ä. zu realisieren (Rechtsklick auf das Abbruchkriterium der Schleife=> "Erstellen" => "Bedienelement").

Abbildung 7:Programmierung einer flachen Sequenz

Damit auch vom VI Einfluss auf diese Zeiten und damit die Fahrgeschwindigkeit des Schrittmotors genommen werden kann, ist ein Regler einzufügen, welcher außerhalb der „flachen Sequenzen“ liegt. Dieser kann mit beiden Warteelementen verbunden werden, da die Wartezeiten beider Zustände immer identisch sein sollte. (High- / Low-Flanken jeweils 50%)

Abbildung 8:Einstellung des Taktverhältnisses

Verfahren einer vorgegebenen Wegstrecke

Einfügen eines Zählers:

Um mit dem Schrittmotor eine definierte Strecke zu verfahren, müssen vorab die tatsächlichen Zustandsänderungen gezählt werden. Auch hierbei gibt es mehrere Möglichkeiten. Eine einfache wie funktionelle Lösung wird im Folgenden beschrieben:

• Vorab muss eine Konstante erstellt werden, welche für den Startwert des Zählers steht (Programmierung => Numerisch => Num. Konstante) Diese muss für diesen Fall vor der ersten Sequenz positioniert werden.

• Sobald das Programm in die erste Sequenz springt soll der Zähler um 1 gesteigert werden. Dazu dient der Baustein Programmierung => Numerisch => Inkrementieren.

• Der Feedback-Node dient hierbei als Speicher und Rückkopplungselement.

• Um sich den aktuellen Zählerwert ausgeben zu lassen muss ein numerisches Anzeigeelement eingefügt werden, welches den Zählerstand nach dem Inkrementieren abgreift.

• Das eingefügte Anzeigeelementes erscheint ebenso automatisch im VI und kann dort jederzeit abgelesen werden.

Abbildung 9:Einbindung eines Schleifenzählers

Jedoch werden in diesem Fall nur die Anzahl der Steps angezeigt. Für die Ausgabe in Millimeter ist vorab eine kleine Rechenoption nötig. Aus dem Datenblatt des Schrittmotors lässt sich entnehmen, dass ein Schritt 0,033mm entspricht. Daher muss die Anzahl der Schritte mit 0,033 multipliziert werden. Ein weiteres Anzeigeelement ermöglicht die Ausgabe der aktuell verfahrenen Strecke in Millimeter. Fügt man ein Eingabeelement hinzu, um die gewünschte Strecke im Millimeter einzugeben, muss dieser daher mit 30 multipliziert werden um die nötige Anzahl der Steps zu ermitteln. Um ein Abbruchkriterium der While-Schleife zu erzeugen, greift man den aktuellen Zählerwert der bereits gefahrenen Schritte ab und vergleicht („größer/gleich“) dieses Ergebnis mit der Anzahl an Steps, welche für die vorgegebene Wegstrecke nötig sind. Sobald dieser Vergleich „True“ ist, ist die Bedingung erfüllt um die While-Schleife zu verlassen. Mit diesem Vorgehen ist ein Verfahren einer vorgegebenen Wegstrecke möglich.

Abbildung 10:Verfahren einer definierten Wegstrecke

Richtungsänderung des Schrittmotors

Um die Verfahrrichtung des Schrittmotors zu ändern, muss zunächst ein Schalter, welches anschließend über das VI zu bedienen ist, in das Blockdiagramm eingefügt werden. Für die Übergabe des Signals an die Hardware ist der jeweilige DIO-Port (Hier DIO-1) aus dem Projekt-Explorer in das bestehende Programm zu involvieren. Da dies eine einmalige Abfrage beim Start des Programmes ist, ist der Befehl außerhalb der While-Schleife zu positionieren. Je nach Schaltlage gibt dieser ein Highpegel(5V) oder Lowpegel (0V) an den zuvor definierten Output des NI Controllers, welcher mit dem Input "Direction" des Gecko Drive verbunden ist. Damit ist die Drehrichtung des Motors definiert. In diesem Beispiel wird mittels LED´s die aktuell gefahrene Richtung visualisiert.

Abbildung 11:Einstellung der Fahrtrichtung

VORSICHT: In dem oben genannten Modus ist keine Real-time Übertragung an die Hardware möglich, d.h. im laufenden Programm kann keine Richtungsänderung mehr durchgeführt werden. Das Programm wird nur auf dem PC ausgeführt und die notwendigen Signale über die Netzwerkverbindung zum NI Controller geleitet. Ist eine Einflussnahme während des laufenden Betriebes erwünscht, muss vorab das VI im Real-time Modus angelegt werden!

Einbindung der Endlagenschalter

Um eine unbeabsichtigte Kollision des Schlittens der Linearachse mit den mechanischen Endanschlägen zu vermeiden, werden Endlagenschalter eingesetzt, welche softwareseitig den Verfahrweg begrenzen. Es handelt sich dabei um Mikroschalter, welche als Schließerkontakt mit der Hardware verbunden werden. Dabei wird pro Schalter ein Ausgang der Hardware permanent auf High (5V) gesetzt und mit einem Kontakt des Schalters verbunden. Der andere Kontakt wird mit einem Eingang der Hardware verbunden, sodass bei betätigen des Schalters ein High-Signal auf einem Eingang festgestellt und entsprechend in der Software verarbeitet werden kann.

Die Umsetzung des Endlagen-Stops erfolgt durch die Verbindung mit der Abbruchbedingung der While-Schleife. Als Visualisierung können im VI LED´s eingefügt werden, die die Betätigung der Schalter anzeigen.

Auch hier gilt, dass das VI im Real-time Modus angelegt werden muss, um in Echtzeit durch die Endlagenschalter das Programm beeinflussen zu können.

Eine hundertprozentige Sicherheit gegen einen Crash bietet diese Lösung nicht! Es empfiehlt sich daher, um auch Softwarefehler auszuschließen, zusätzlich pro Seite der Linearachse einen Öffnerkontakt zu platzieren, welcher bei Betätigung die Stromzufuhr des Motors unterbricht und so ein weiteres Verfahren unmöglich macht.

Die softwareseitig eingebundenen Endschalter bieten auch die Möglichkeit, diese als Positionierhilfen zu verwenden. Denn auch wenn der Speicher der Software gelöscht worden sein könnte und daher die Ist-Position der Achse unbekannt ist, kann durch Verfahren bis zum Endschalter eine neue bekannte Ist-Position angelernt werden. Dabei muss jedoch sichergestellt sein, dass die Achse auf ihrem Weg zum Endschalter keinen Schaden anrichten kann (beispielsweise Bearbeitungswerkzeug NICHT im Eingriff).

Die Abbildung 14 zeigt die Umsetzung der Verkabelung am NI-9403 Modul. Die Widerstände sind Pull-Down-Widerstände um die anliegende Spannung an dem jeweiligen Eingang nach dem Umschalten der Spannung abzuziehen.

Abbildung 14:Stecker NI-9403

Realtime-Projekt erstellen

Es zeigte sich die Problematik, dass keine Änderungen am laufenden Programm durchgeführt werden können (z.B.: Richtung, Geschwindigkeit oder Weg). Um dieses Problem zu umgehen kann in LabView ein Programm im Realtime-Modus erstellt werden:

Um ein Programm im Realtime-Modus zu erstellen, muss vorab ein Projekt (wie bereits beschrieben) erstellt werden. Anschließend lässt sich über „Werkzeuge“ => „Project Wizard“ ein neues Fenster öffnen, in dem die notwendigen Voreinstellungen durchgeführt werden müssen. Als erstes ist dem Realtime-Projekt ein Projektname zuzuordnen. Die weiteren Voreinstellungen können direkt übernommen werden. Es ist notwendig das Feld bei „include user-interface“ zu markieren. Im folgenden Schritt lässt sich die Hardware im Unterordner „Real-Time ComapctRIO“ wählen und somit in das Projekt einfügen. Das Feld „Fertigstellen“ öffnet direkt das VI im Realtime-Modus.

Abbildung 12:Erstellung eines VI im Realtime-Modus

Weitere Lösungsmöglichkeiten und Anregungen finden sich in folgenden Links des Softwareherstellers:

Real-Time VI to Host VI Communication Methods http://digital.ni.com/public.nsf/allkb/48D244EC86971D3986256BD4005CCC28

Sharing Data Using Shared Variables (RT Module) http://zone.ni.com/reference/en-XX/help/370622G-01/lvrtconcepts/rt_projectvariable/

Lossless Communication with Network Streams: Components, Architecture, and Performance http://www.ni.com/white-paper/12267/en/

Host- und Target-Programm Im Projektbaum zeigt sich bei der Erstellung eines Realtime-Projekts eine neue Struktur auf. Das Programm untergliedert sich in diesem Fall in zwei Teile. Das „Host-VI“ und das „Target-VI“. Das „Host-VI“ läuft in der Regel in einer Endlosschleife auf dem Rechner. Es dient bei Änderungen des Programms zur Variablenübergabe zum „Target-VI“. Das Target VI hingegen läuft auf der Hardware und wird nur dann ausgeführt, wenn sich die Absolutposition des Schrittmotors ändern soll. Für die Übergabe von Werten zwischen den beiden Programmen können Variablen definiert werden.

Variablen definieren Der Realtime-Modus ermöglicht es Variablen zu erstellen und zu definieren. Diese können innerhalb mehrerer Blockdiagramme jeweils gelesen bzw. geschrieben werden. Mit einem Rechtsklick auf „Variablen“ im Projektbaum können diese verwaltet (erstellt, umbenannt, etc.) werden. Diese lassen sich anschließend mittels „drag&drop“ (analog zu den DIOs ) in das gewünschte Blockdiagramm einfügen. Über einen Rechtsklick auf den Baustein kann der Zugriffsmodus (lesen oder schreiben) definiert werden.

Absolutwert-Berechnung

Den aktuellen Verfahrweg in Millimeter, welcher im VI des Targetprogrammes eingegeben wird, wird in der folgenden Abbildung im Blockdiagramm des Target-Programmes vor dem Anzeigeelement abgegriffen und in die Variable "abs_pos" geschrieben. Diese Variable wird im Blockdiagramm des Host-Programmes ausgelesen und richtungsabhängig als positiver bzw. negativer Wert auf die aktuelle Absolutposition addiert.

Der folgende Screenshot zeigt Verknüpfung von Host- und Targetprogramm durch die globale Variable "abs_pos" (rot umrandet):

Abbildung 13:Verknüpfung des Host- und Targetprogrammes mittels Variablen

Einbindung der automatischen Richtungsänderung in Abhängigkeit der Absolutposition

Mittels eines Vergleichs von der aktuellen Absolutwertposition und des Vorgabewertes wird die Richtung ermittelt, in die der Schrittmotor verfahren muss. Ist der Vorgabewert größer als der Absolutwert, hat die boolsche Variable (Data) den Zustand "true". Im anderen Fall wird der Zustand auf "false" gesetzt. Eine Case-Struktur sorgt zustandsabhängig für eine Addition bzw. Subtraktion der Werte von Verfahrweg und Absolutposition. Nach jeder Rechenoption wird der Wert der Variable (abs_pos) überschrieben und kann über ein Anzeigeelement im Host-VI dargestellt werden.

Abbildung 14:Automatische Fahrtrichtungsänderung

Quellen:

Die Programmausschnitte wurden aus dem aktuellen LabView-Programm entnommen, welches im entsprechenden Ordner im Versionierungswerkzeug SVN auf der Hochschulseite abgelegt wurde.

Einbindung der RS232 Schnittstelle zur Datenübertragung (WICHTIG für weitere Praktika in diesem Bereich!)

Bisher wurde in diesem Artikel der Umgang mit LabVIEW beschrieben und die Programmierung eines funktionsfähigen Programmes zur Steuerung einer Achse erläutert. Ein weiterer wichtiger Bereich zur Realisierung einer autonomen Achsenbewegung ist allerdings die autonome Übergabe von Parametern zur Steuerung der Achse. Dabei ist es von Bedeutung, eine Real-Time Anwendung zu gewährleisten. Hierzu wird in dem Artikel LabVIEW RS232 Schnittstelle eine Möglichkeit aufgezeigt, Daten über die RS232 Schnittstelle zu erhalten und im Blockdiagramm weiterführend zu verwenden.

Abbildung 15:Programm auf dem PC

Abbildung 16:Programm auf dem CRIO

Abbildung 16:Scan Time

Aufgetretene Probleme

Neueinbindung der DIOs bei Neustart des Rechners:

Beim Neustart des Computers wird der Hardware eine neue IP-Adresse zugeordnet. Die Hardware muss neu eingebunden werden, da das bestehende Programm diese nicht mehr erkennt. Das führt dazu, dass die digitalen In- und Outputs im gewünschten Programm neu zugeordnet werden müssen. Dabei gehen auch die vormals hinzugefügten Bezeichnungen der DIO's verloren.

Alternativ kann im Projektexplorer die angezeigte Hardware mit der "alten" IP-Adresse gelöscht werden und anstatt dessen die Hardware nochmal neu eingebunden und an dieser Stelle eingefügt werden.

Falsche Datentypen:

Teilweise kann es bei zyklischen Abfragen eines bool'schen Datentyps (bspw. in jedem Durchlauf einer Schleife) zu Problemen kommen, wenn dieser Wert für die Abbruchbedingung der Schleife verwendet wird. Dabei wird ein Fehler angezeigt, dass es sich nicht um einen bool'schen Wert an sich, sondern um ein eindimensionales Array handelt.

National Instruments Support:

Im Kontext der Einbindung der RS232 Schnittstelle zur Übergabe von Parametern zur Motorbewegung konnte der Support leider keine Hilfestellung leisten. Der betreuende Mitarbeiter verwies auf die Vielzahl der Module von NI und konnte leider zu keiner Lösung beitragen. Dazu möchte ich anmerken, dass die Hilfe des Supports angenommen werden soll, jedoch vor allem bei spezifische Problemen es einer parallelen Eigenrecherche bedarf. Für weitere Informationen und Hilfestellungen beachten Sie bitte den eigenständigen Artikel LabVIEW RS232 Schnittstelle.

Ausblick

Encoder

Das aktuelle Programm stellt nur eine Steuerung des Motors dar. D.h. es wird davon ausgegangen, dass das Ausgangssignal der Steuerung eine entsprechende Bewegung des Motors zur Folge hat. Beispielsweise unter Belastung oder anderen Betriebszuständen kann die Ist-Position des Motors jedoch von der Soll-Position im Programm abweichen. Um diese Abweichung zu erkennen und ausgleichen zu können, kann ein Motorpositionssensor eingesetzt werden. Dieser wird auch als Encoder bezeichnet. Anhand des Beschaltungsplanes kann dieser an mehrere Eingänge des Controllers angeschlossen werden und so entsprechend die Position des Motors an das Programm übermittelt werden.

Auswertung des Strings über die RS232 Schnittstelle

Um eine autonome Achsensteuerung zu gewährleisten ist es nicht nur erforderlich, den String mit den nötigen Parametern für das Blockdiagramm zur Verfügung zu stellen. Weiterhin muss der relevante Teil des Strings für die definierte Achse ausgelesen werden.
Als Beispiel dazu dient folgender Code: X11111Y22222Z33333F44444E Ist die zu betreibende Achse beispielsweise die Y-Achse, so muss die Zahlenkombination "22222" als Verfahrweg und die Zahlenkombination "4444" als Vorschub abgespeichert und weiterverwendet werden.