Quelltext der Seite Ansteuerung einer Schrittmotor-Achse mit NI Labview

[[Kategorie:2013_WS_MTR7_Praktikum_GPE]]
[[Kategorie:LabView]]
==Einleitung==
Im Rahmen des Produktionstechnik II Praktikums und dem übergeordnetem Projekt "[[3-D-Bearbeitungsmaschine (Projekt des Schwerpunkts GPE im Studiengang MTR)]]" ist es die Aufgabe, mittels NI [[LabView]] die Ansteuerung eines CNC Fräsportals (3 Linearachsen + 1 Rotationsachse) zu realisieren. 
Unsere Namen sind [[Maximilian Bröer]] und [[Jarco Groenhagen]]. Wir haben uns im Wintersemester 2019/2020 mit diesem Thema beschäftigt. 

Folgende Studenten haben sich mit dieser Aufgabe beschäftigt:
{| class="mw-datatable"
! style="font-weight: bold;" | Student(en)
! style="font-weight: bold;" | Semester
! style="font-weight: bold;" | Anmerkung
|-
| [[Maximilian Bröer]] und [[Jarco Groenhagen]]
| Wintersemester 2019/2020
| 
|-
| [[Rainer Heither]] und [[Joel Dongmeza]] 
| Wintersemester 2016/2017 
| 
|-
| [[Raphael Bertelt]]
| Wintersemester 2015/2016
| 
|-
| [[Felix Kortmann]] und [[Dominik Rebein]]
| Wintersemester 2014/2015
| 
|-
| [[Martin Klingen ]]
| Wintersemester 2013/2014 
| Erstellung des Artikels
|}

Die verwendete Software ist LabView 2014 von National Instruments.

Es wurden die vorherigen Dateien "String lesen" und "Step machen" passend zusammengeführt und erweitert. Ausserdem wurde durch eine Kabel die Möglichkeit geschaffen Zukünftig das Programm, dass auf dem cRIO 9024 gespeichert und verarbeitet wird, über den cRIO 9403 zur Fräse  zu senden. 


__TOC__

==Regelkreis, technischer Systementwurf und Aufbau==

Vor der Hardware- und Softwarerealisierung  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 ([http://www.geckodrive.com/g201x.html Gecko G201X])<ref> http://www.geckodrive.com/g201x.html </ref> 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.<br>
[[Datei:Regelkreislabview.jpg|800px|Regelkreis für das Verfahren der Achse <ref> Regelkreis für das Verfahren der Achse  (eigene Abbildung) </ref>]]

Abbildung 1: ''Regelkreis für Schrittmotoransteuerung''<br>
<br>

Abbildung 2 zeigt den technischen Systementwurf des Gesamtsystems bestehend aus den einzelnen Bestandteilen zur Motoransteuerung.  <br>
[[Datei:Technischer Systementwurf für die Automatisierung mit LabView.png|800px]]<br>
Abbildung 2: ''Technischer Systementwurf mit NI-LabView'' <br>
''Originaldatei: [[Datei:Technischer_Systementwurf_LabView.vsdx]]''
<br>

Abbildung 3 zeigt die Verdrahtung der cRio 9024 im Ganzen. Sie soll als Orientierungshilfe für nachfolgende Projekte gedacht sein, um einen Einstieg zu bekommen oder mögliche Fehler in der Hardwareverdrahtung entdecken zu können.  <br>
[[Datei:Verdrahtung_der_cRIO_9024.jpeg|600px]]<br>
Abbildung 3: ''Verdrahtung und Aufbau cRio 9024'' <br>
<br>
Link zum Handbuch: '' [http://www.ni.com/pdf/manuals/375233f.pdf cRIO 9024 - Handbuch]''

==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 [http://www.geckodrive.com/gecko/images/cms_files/G201X%20REV-6%20Manual.pdf Datenblatt]<ref> http://www.geckodrive.com/gecko/images/cms_files/G201X%20REV-6%20Manual.pdf </ref> lassen sich die notwendigen Informationen über die Beschaffenheit der benötigten Signale entnehmen.

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

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

[[Datei:Schaltplan neu.jpg|700px]]

Abbildung 4: ''Belegungsplan für Schrittmotoransteuerung''

== Erstellung eines neuen Projekts ==

Um mit der Programmierung zu starten, muss wie in Bild 5 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 (wir haben NI LabView 2014 verwendet) gestartet werden. Es öffnet sich ein Fenster. 

Dort muss zum Start erstmal die Umgbungseinstellung gewählt werden. <br>
<br>
[[Datei:NP_1.png|400px|Umgebungseinstellungen für neues Projekt wählen <ref> Umgebungseinstellungen für neues Projekt wählen  (eigenes Foto) </ref>]] 

Abbildung 5: Umgebungseinstellungen für neues Projekt wählen

<br>
Als nächstes kann dann das neue Projekt erstellt werden:<br>
<br>
[[Datei:NP_2.png|400px|Neues Projekt erstellen <ref> Neues Projekt erstellen  (eigenes Foto) </ref>]] 

Abbildung 6: Neues Projekt erstellen<br>

''Originaldatei:[[https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Fachthemen/3D_Bearbeitungsmaschine/Automatisierung_LabView/05_Entwicklung/Screenshots/Neues%20Projekt%20anlegen/NP_2.png Datei:NP_2.png]]'' <br>
<br>
Wählen Sie  ==> Alle ==> Leeres Projekt ==> Fertigstellen <br>
<br>
[[Datei:NP_3.png|400px|Leeres Projekt erstellen <ref> Leeres Projekt erstellen  (eigenes Foto) </ref>]] 

Abbildung 7: Leeres Projekt erstellen<br>


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

<br>
[[Datei:Np4.png|400px|Hardware cRio 9024 einbinden <ref> Hardware cRio 9024 einbinden  (eigenes Foto) </ref>]] 

Abbildung 8: Hardware cRio 9024 einbinden<br>

•	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.
<br>
[[Datei:Np5.png|400px|Hardware cRio 9024 einbinden (2) <ref>Hardware cRio 9024 einbinden (2) (eigenes Foto) </ref>]] 

Abbildung 9: Hardware cRio 9024 einbinden (2)<br>

Nun muss noch der Programmiermodus ausgewählt werden.<br>
<br>
[[Datei:Np6.png|400px|Programmiermodus ausgewählen <ref>Programmiermodus ausgewählen (eigenes Foto) </ref>]] 

Abbildung 10: Programmiermodus ausgewählen <br>

Anschließend erscheint im Project-Explorer (siehe Bild 11) die Hardware Chassis (cRio 9024). 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. 
<br>
[[Datei:Np7.png|300px|Erfolgreich Eingebundene Hardware in neuene Projekt <ref>Erfolgreich Eingebundene Hardware in neuene Projekt (eigenes Foto) </ref>]] 

Abbildung 11: Erfolgreich Eingebundene Hardware in neuene Projekt<br>



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

''Originaldatei der Bilder:[[Datei:Originaldatei_NP.pptx]]'' <br>
<br>


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.

== Ansteuerung eines Schrittmotors mit LabView ==

Grundsätzlich gibt es mehrere Möglichkeiten über LabView einen Schrittmotor anzusteuern. Voraussetzung dafür 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 dieser Baustein nur aus einer Sequenz in Form eines Rahmens wie man in Bild 12 erkennt. 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").

[[Datei:Flache Sequenz.jpg]]

Abbildung 12:''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 (siehe Bild 13) verbunden werden, da die Wartezeiten beider Zustände immer identisch sein sollte. (High- / Low-Flanken jeweils 50%) 

[[Datei:Regler.jpg]]

Abbildung 13:''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, wie in Bild 14 dargestellt, 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 Anzeigeelement erscheint ebenso automatisch im VI und kann dort jederzeit abgelesen werden.

[[Datei:Zähler.jpg]]

Abbildung 14:''Einbindung eines Schleifenzählers''



Jedoch werden in diesem Fall nur die Anzahl der Steps angezeigt. In Abbildung 15 ist die Funktion erweitert worden. 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 ist.  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.

[[Datei:Definierter_Verfahrweg.jpeg]]

Abbildung 15:''Verfahren einer definierten Wegstrecke''


=====Richtungsänderung des Schrittmotors=====

Um die Verfahrrichtung des Schrittmotors zu ändern, muss zunächst ein Schalter, welche 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, wie in Bild 16 zu erkennen ist, die aktuell gefahrene Richtung visualisiert.

[[Datei:Richtungsänderung.jpg]]

Abbildung 16:''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 17 zeigt die Umsetzung der Verkabelung am im D-Sub-Stecker zum NI-9403 Modul. Die Widerstände sind [http://www.elektronik-kompendium.de/public/schaerer/pullr.htm Pull-Down-Widerstände] um die anliegende Spannung an dem jeweiligen Eingang nach dem Umschalten der Spannung abzuziehen.

[[Datei:32_Poliger_D_Sub_Stecker.jpg|500px]] 

Abbildung 17:''Stecker NI-9403''



In der untenstehenden Tabelle ist die Pinbelegung der Steckverbindung zwischen dem NI-9403 Modul und dem Geckodrive G201X einzusehen. Außerdem ist zu erkennen, wie die Pull-Down-Widerstände (siehe Abbildung 10 rot umkreist) im inneren des Steckers zu verlöten sind [[Datei:Steckerbelegungsplan_32_D_Sub_Stecker.xlsx]].

{| border="1"

|-
 |'''Pin 32-Poliger D-Sub-Stecker''' 
 |'''Bezeichner in LabView'''
 |'''Bezeichner Geckodrive G201X'''
 |'''Sonstige Bauteile'''
 
|-
 |1
 |01 Step
 |Step
 |

|-
 |2
 |Direction
 |Direction
 |

|-
 |3
 |03 Konstanter Endschalter Außen
 |
 |1. Endschalter/1. Hochohmiger Widerstand

|-
 |4
 |04 Konstanter Endschalter Motor
 |
 |2. Endschalter/2. Hochohmiger Widerstand

|-
 |20
 |
 |Disable
 |

|-
 |21
 |21 Schalter betaetigt Motor
 |
 |1. Endschalter

|-
 |22
 |Schalter betaetigt Außen
 |
 |2. Endschalter

|-
 |28
 |
 |
 |1. Hochohmiger Widerstand/2. Hochohmiger Widerstand

|-
 |29
 |
 |Common
 |
|}

===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“ (siehe Abbildung 18) öffnet direkt das VI im Realtime-Modus.

[[Datei:realtime.jpg]]

Abbildung 18:''Erstellung eines VI im Realtime-Modus''

<br>
''<span style="color:#FF0000"> (Dieses Thema wurde im Wintersemester 2019/2020 nicht bearbeitet) </span>''


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

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

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

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


'''Host- und Target-Programm'''
Im Projektbaum zeigt sich bei der Erstellung eines Realtime-Projekts eine neue Struktur. 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): 

[[Datei:hostvstarget.jpg]]

Abbildung 19:''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, wie in der nächsten Abbildung, 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.


[[Datei:directioncase.jpg]]

Abbildung 20:''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.

=====Erweitertes Target-Programm mit Verarbeitung eines übernommenen Strings=====

In diesem Kapitel geht es darum, einen String der übergeben wird zu speichern, diesen gespeicherten String in X-,Y-,Z- und F-Werte zu separieren und mit einer weiteren Funktion die separierte Soll-Position anzufahren.

Wie in der Abbildung 21 links zu erkennen ist, erhalten wir in diesem Ausschnitt des erweiterten Target-Programms den übergebenen String z.B. durch das Terminal Programm Hercules. Wie man ein RS232 Modul einbindet und Funktionen in LabView verbindet um im Endeffekt ein String zu übergeben, ist in dem Artikel [[LabVIEW_RS232_Schnittstelle]] nachzulesen. Aufgrund der While-Schleife, in der Sich das komplette Programms befinde, wird der übergebene String durchgängig mit dem nächsten Schleifendurchlauf überschrieben. Um aber einen String verarbeiten zu können, benötigt man einen zusammenhängenden String, der zur Verarbeitung abgespeichert werden muss. Dies übernimmt die programmierte Funktion oben links in der Abbildung über dem Case-Struktur-Kästchen. Der übergebene String wird hier mit der Funktion „Strings verknüpfen“ mit dem zuletzt gespeicherten String verknüpft, so dass einzelne übergebene Zeichen miteinander verkettet werden können. 

Die darauffolgende Funktion „Teil-String“ begrenzt den zu speichernden String auf 20 Zeichen, welches die exakte Länge eines Strings ist, um X-,Y-,Z-, und F-Werte mit jeweils 4 Zahlen und einem abschließenden Semikolon z.B. „X1234Y1234Z1234F1234;“ zu erhalten. Die numerische Zahl 20 ist somit mit der Funktion am Eingang "Länge" zu verknüpfen. 

Die rosa Kästchen mit dem schwarzen Häuschen sind lokale Variablen, die sich unter den Funktionen in der Registerkarte Datenaustausch befinden. Um eine lokale Variable verwenden zu können, müssen sie jedoch schon definiert bzw. vorhanden sein. Hierzu muss erst ein String-Anzeigeelement im Frontpanel erstellt werden. Durch einen Links-klick auf die lokale Variable lässt sich nun die zu verwendende Variable auswählen und durch einen Rechts-klick und auf „In ‚Lesen‘ ändern“ so ändern, dass die gespeicherte Variable bei der Funktion „Strings verknüpfen“ verwendet werden kann.

[[Datei:Filter.jpg]]

Abbildung 21:''String speichern''


Unter der Funktion zum Speichern des Strings befindet sich eine Case-Struktur. Alle Funktionen, die sich in dem Case-Struktur-Kästchen befinden, werden ausgeführt, wenn sich der boolische Wert am Case-Selektor von 0 auf 1 ändert. Die Bedingung, dass die Funktionen in der Case-Struktur ausgeführt werden, wird hier durch einen gleich-Operator realisiert. Wenn sich in dem übergebenen String ein Semikolon befindet, wird durch die „Gleich?“ Funktion der boolesche Wert 1 an die Case-Struktur übergeben und die sich darin befindende Funktionen ausgeführt. 

In der Case-Struktur befindet sich wieder die lokale Variable „Speicher“, in der alle X-,Y-,Z- und F-Werte gespeichert wurden. Die sich in der Mitte befindende Funktion „In String suchen“ kann den eingelesenen String in verschiedene Formate umformatieren und teilweise, komplett oder unterteilt wieder ausgeben. Die sich darüber befindende Codierung „X%4dY%4dZ%4dF%4d“ realisiert, dass die Zahlen des Strings nach X, Y, Z und F alle natürlichen Zahlen separat an verschiedene Ausgängen ausgeben werden. Die verschiedenen Codierungen sind in einer Tabelle in der erweiterten Hilfe von LabView hinterlegt. 

Die 0 am Eingang „Anfangssuchposition“ gibt lediglich an, ab welcher Stelle der String untersucht werden soll und ist daher mit 0 angegeben. Der Ausgang „verbleibender String“ sollte nach der Durchführung nichts ausgeben, da alle Werte verarbeitet werden sollten. Auch das Semikolon sollte im String nicht enthalten sein, da die Case-Struktur im Programmablauf vor dem Speichern des Semikolons ausgeführt wird. Alle „gefilterten“ X-, Y-, Z- und F-Werte werden hier von den Ausgängen an das Frontpanel weitergeleitet und durch numerische Anzeigeelemente visualisiert. Außerdem werden sie dadurch auch wieder in lokale Variablen gespeichert, um sie an anderer Stelle im Programm zu verwenden.   

[[Datei:Schritt.jpg]]

Abbildung 22:''Position anfahren''



In der Abbildung 22 ist eine erweiterte Funktion des VI aus dem Kapitel „Verfahren einer vorgegebenen Wegstrecke“ dargestellt.  Die erweiterte Funktion ermittelt den Unterschied zwischen der Ist-Position zur Soll-Position und lässt den Motor in die Richtung fahren, um zur übergebenen Soll-Position zu gelangen. Wie in dem VI aus dem Kapitel „Verfahren einer vorgegebenen Wegstrecke“ wird dies mit Vergleichern realisiert. 

Die beiden Vergleicher „größer“ und „kleiner“ unterhalb der Funktion „Flache Sequenz“ addieren bzw. subtrahiert mit jedem Schleifendurchlauf immer eine 1 zur aktuellen Ist-Position. Um allerdings einen Wert von 1 zu addieren bzw. zu subtrahieren, benötigt man an dieser Stelle einen Konvertierer der boolesche Werte zu einen numerischen Wert konvertiert, da die Vergleicher keine numerischen Werte ausgeben können. Diese Funktion findet man unter der Registerkarte „Programmierung“ und „Boolesch“. Weil die booleschen Werte einen Schalter zur Richtungsänderung ersetzen, wird hier eine Verbindung zum zuvor definierten Output des NI Controllers geschaffen (siehe Kapitel “Richtungsänderung des Schrittmotors“). Die Funktion erkennt nun, in welche Richtung der Motor fahren muss und gibt das Signal autonom an den Motor Controller weiter. 

Um den Motor bei Abweichung der Ist-Position mit dem Soll-Position fahren zu lassen, wird bei der erweiterten Funktion der Ist-Wert mit dem Soll-Wert, der übergeben wurde, verglichen. Dies übernimmt ein ungleich Operator „Ungleich?“. Bei Abweichung des Ist-Werts vom Soll-Wert wird auch hier ein True (1) an den DIO angelegt und der Motor dreht sich (siehe Kapitel „Ansteuerung eines Schrittmotors mit LabView“). 

In der nächsten Abbildung werden die Endschalter Softwaretechnisch ausgelesen. Dazu müssen vier Umgebungsvariablen der While-Schleife hinzugefügt werden. Zwei müssen davon durch ein rechtsklick zu „lesen“ geändert werden und für eine Visualisierung auf dem Frontpanel mit LED’s verbunden werden. Damit der Motor nicht weiter dreht, ist eine Verbindung wie oben links in der Abbildung 23 zu schaffen. „oder“ Operatoren dienen hier einer gefächerten Verbindung und Stoppen das Programm bei Betätigung eines Schalters. Um eine Verbindung zu den richtigen Ein- und Ausgängen zu schaffen, werden wieder durch einen Linksklick auf die Umgebungsvariablen die zuvor Konfigurierten Ausgänge ausgewählt. Zum Schluss müssen noch zwei Umgebungsvariablen mit einer „True-Konstante“ verbunden werden, um sie mit Spannung zu versorgen.

[[Datei:Endschalter.jpg]]

Abbildung 23:''Endschalter''



Weil das komplette Programm (VI) die maximale Upload-Größe überschreitet, finden Sie das Originalprogramm im SVN an dem Ort: 

\MTR_GPE_Praktikum\Fachthemen\Automatisierung_LabView\Programme\Motoransteuerung_RealtimePro

unter den Namen: Target_Programm

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

===Aufgetretene Probleme in der Programmierung===
'''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 spezifischen 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'''

Wie in dem Kapitel "Erweitertes Target-Programm mit Verarbeitung eines übernommenen Strings" beschrieben wird, ist das Programm in der Lage, einen String zu analysieren, die Z-Werte zu separieren und einen Motor damit anzusteuern. Um jedoch alle Motoren der CNC-Maschine anzusteuern, muss das Programm noch vervollständigt werden und weitere Ausgänge angesteuert werden.

'''Real-Time'''

Außerdem ist die Funktion, dass das Target- mit dem Host-Programm  interagiert noch nicht funktionsfähig. Globale Variablen sind in dem Host-Programm und dem "Erweitertes Target-Programm" zwar bereits erstellt worden, es konnte jedoch aus zeitlichen Gründen noch nicht zu Ende programmiert werden.

====Softwareerweiterung auf mehrere Achsen====

Bisher wurden Einzelprogramme geschrieben und alles für eine Achse geschrieben. in Zukunft soll es möglich sein die Fräse mit LabVIEW ansteuern zu können. 
Der jetzige Stand wird nun wiedergegeben



====Software Zusammensetzung====

Nach der Zusammensetzung den beiden Dateien "Step machen" und "String lesen" und der Erweiterung auf 4 Achsen durchgeführt wurde, ist es nun möglich, die vorher aus den String extrahierten Koordinaten, weiter zu leiten an die jeweiligen Achsen und diese dann anzusteuern. Die Programmierung ist im Blockdiagramm zu sehen(Abb. 25). X-, Y-, Z- und F- Achsen Ansteuerungen die in Abbildung 19 nicht richtig erkennbar sind, sind in Abbildung 16 [[Datei:Schritt.jpg]] genau zu erkennen.Im Frontpanel (Abb. 20) ist erkennbar dass der String in die 4 verschiedenen Koordinierten extrahiert. Ausserdem ist es möglich die Step Geschwindigkeit zu beeinflussen, es ist erkennbar ob und welcher Endschalter betätigt ist und in welche Richtung der Motor läuft.



[[Datei:Blockdiagramm.jpg|1000px]]

Abbildung 25: ''Blockdiagramm''



[[Datei:Frontpanel.jpg|1000px]]

Abbildung 26: ''Frontpanel''

===Verkabelung zwischen der LabVIEW Hardware und der Fräse===

Es wurde ein Kabel angefertigt, dass die Kommunikation zwischen der LabVIEW Hardware NI 9403 und der Fräse sichert.


[[Datei:Leitung.jpg]]

Abbildung 27: ''Leitung''




=====Pinnbelegung=====

Um den NI 9403 (37Pin) mit dem Fräse (25Pin) zu verbinden, brauchen wir eine besondere Verkabelung; Die D`Sub 37 Pin wird in D'Sub 25 Pin umgewandelt. Die Umwandlung erfolgt durch die willkürliche Zuteilung von Pin. 
Die nachfolgende Tabelle zeigt eine mögliche Zuteilung. (

{| border="1"

|-
 |'''D'Sub 25 pin''' 
 |'''Belegung bei LPT-Ports'''
 |'''Belegung im Schaltschrank'''
 |'''D`Sub 37 pin'''
 
|-
 |1
 |
 |
 |

|-
 |2
 |
 |Step x-Achse
 |1 DIO 0

|-
 |3
 |
 |Direction x-Achse
 |2 DIO 1

|-
 |4
 |
 |Step y-Achse
 |5 DIO 4

|-
 |5
 |
 |Direction y-Achse
 |6 DIO 5

|-
 |6
 |
 |Step z-Achse
 |7 DIO 6

|-
 |7
 |
 |Direction z-Achse
 |8 DIO 7

|-
 |8
 |
 |Step Rotationsachse
 |9 COM

|-
 |9
 |
 |Direction Rotationsachse
 |10 COM

|-
 |10
 |
 |Step Extruder
 |11 DIO 8

|-
 |11
 |
 |Direction Extruder
 |12 DIO 9

|-
 |12
 |
 |Relais Spindel
 |13 DIO 10

|-
 |13
 |
 |Relais Staubsauger
 |14 DIO 11

|-
 |14
 |
 |Relais noch frei
 |15 DIO 12

|-
 |15
 |
 |
 |

|-
 |16
 |
 |
 |

|-
 |17
 |
 |
 |

|-
 |18
 |Ground
 |
 |

|-
 |19
 |Ground
 |
 |

|-
 |20
 |Ground
 |
 |

|-
 |21
 |Ground
 |Common x-Achse
 |16 DIO 13 

|-
 |22
 |Ground
 |Common y-Achse
 |17 DIO 14

|-
 |23
 |Ground
 |Common z-Achse
 |18 DIO 15

|-
 |24
 |Ground
 |Common Rotationsachse
 |19 RSVD (Pin reserviert speziell für Kommunikation mit NI-Zubehör)

|-
 |25
 |Ground
 |Common Extruder
 |23 DIO 19
|}
Abbildung 28: ''Pinbelegung''

====Anhang====
Das Programm zum Download als .zip-Datei<br>
[[Datei:Automatisierung_LabView.zip]]

==Derzeitige Probleme==
'''Generell:'''

*Nach der Verschachteln der Schleifen, haben wir probiert unsere Programm laufen zu lassen, leider sind wir auf folgende Probleme gestoßen:
*Der Motor bewegt sich aber sehr langsam: Das könnte einfacht gelöst werden, indem man die Änderung des Parameters "Scan Period" im Unterpunkt "Scan Engine" bei den Einstellungen der "Real-Time CompactRIO Properties" die Geschwindigkeit der Achse  verbessert --> Auch das funktioniert nicht, da dann Fehlermeldung ausgegeben wird <br>
<br>
[[Datei:Sce2.2.PNG|400px|Einstellung der Stufenweite auf 1 µs <ref> Einstellung der Stufenweite auf 1 µs  (eigenes Foto) </ref>]]<br>
Abbildung 29: ''Einstellung der Stufenweite auf 1 µs'' <br>

<br>
[[Datei:Scanperiode_1ns_FEHLERMELDUNG.PNG|400px|Fehlermeldung für Stufenlänge 1 µs <ref> Fehlermeldung für Stufenlänge 1 µs (eigenes Foto) </ref>]]<br>
Abbildung 30: ''Fehlermeldung für Stufenlänge 1 µs'' <br>
<br> 

* Die Dauer der Steps ist bis max. 10 ms runterskalierbar. Danach gibt die cRIO nur noch ein dauerhaftes HIGH-Signal aus --> Wünschenswert wäre eine Steplänge von 1 µs <br>
[[Datei:Zeit_TRUE_10ms_FALSE_10ms.PNG|400px|Stufensignal mit Stufenzeit 10ms <ref> Zeit_TRUE_10ms_FALSE_10ms (eigenes Foto)</ref>]]<br>
Abbildung 31: ''Zeit_TRUE_10ms_FALSE_10ms.PNG'' <br>
<br>

==Lösungsansätze==
===Lösungsmöglichkeit laut NI Support===
* Hardware des PC's (Stand: 13.1.2020) zu langsam ("nur" 4GB RAM) 
* LabView 2014 Sofrware "nur" als 32-bit Version vorhanden
* Um mehr als 4GB Systemspeicher nutzen zu können wird ein 64-bit Betriebssystem notwendig
==> Abhilfe schafft:
* Leistungsfähigere Hardware (mind. 16 GB RAM) 
* Installation NI LabView als 64-bit Version
* Windows-Betriebssystem als 64-bit Version
<br>

===Einstellung der Scan-Rate===
'''<span style="color:#FF0000"> Erst sinnvoll, wenn Computer aufgerüstet ist. </span>'''

Ziel:
Durch die Änderung des Parameters "Scan Period" im Unterpunkt "Scan Engine" bei den Einstellungen der  "Real-Time CompactRIO Properties" kann die Geschwindigkeit der Achse eminent verbessert werden. Die "Scan Period" ist die maximale Abtastrate zwischen CRio und dem NI9403-Modul. Durch eine schnellere Abtastrate ist es möglich, mehr Stepsignale an den Geko-Drive zu übertragen um somit die Geschwindigkeit der Achse zu erhöhen. Durch die Änderung dieses Parameters auf die minimale Zeit von 1ms ist es möglich, eine erhebliche und ausreichende, maximal mögliche Geschwindigkeit zu erlangen.

'''Einstellung der Scan-Rate wie folgt:'''

1. Im Projekt ==> Rechtsklick auf cRIO-Modul ==> "Eigenschaften" <br>
<br>
[[Datei:Sce1.png|300px|Einstellung der Scan-Rate <ref> Einstellung der Scan-Rate 1 (eigenes Foto)</ref>]]<br>
Abbildung 32: ''Einstellung der Scan-Rate 1'' <br>
<br>

2. Klick auf Kategorie "Scan Engine" ==> Einstellung der Scan-Rate wie im markierten Feld (vgl. Bild unten) <br>
<br>
[[Datei:Fehler 1mys 1.PNG|400px|Einstellung der Scan-Rate für Stufenlänge 1 µs <ref> Einstellung der Scan-Rate 2 (eigenes Foto)</ref>]]<br>
Abbildung 33: ''Einstellung der Scan-Rate 2'' <br>
<br>
''Originaldatei der Bilder:[[Datei:Originaldatei_sce.pptx]]''

== Literatur ==
<references />


Übergeordnetes Projekt:[[3-D-Bearbeitungsmaschine (Projekt des Schwerpunkts GPE im Studiengang MTR)]]