3D-CNC-Bearbeitungsmaschine: Unterschied zwischen den Versionen

Aus HSHL Mechatronik
Zur Navigation springen Zur Suche springen
Keine Bearbeitungszusammenfassung
 
(159 dazwischenliegende Versionen von 19 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
= Einführung =
[[Kategorie:Projekte]]
[[Datei:CNC_Maschine_nach_Neukonstruktion_gerendert.JPG|500px|rechts]]


Ein 3D-Fräsbearbeitungszentrum soll in Gruppenarbeit realisiert werden. Neben der Konstruktion des Bearbeitungszentrums und dessen Montage sollen die drei Achsen mit unterschiedlichen Steuerungen und damit auch mit unterschiedlichen Programmiersprachen realisiert werden. Des Weiteren muss ein zentraler Steuerungs-Algorithmus die drei Steuerungen vereinen, um Zielvorgaben respektive Koordinaten auf die entsprechenden Achsen zu verteilen.


= Einführung =
Im [[Praktikum_Produktionstechnik | Praktikum "Produktionstechnik" des 7. Semesters]] im Studiengang Mechatronik (Schwerpunkt "Global Production Systems") wird an einem selbst konzipierten, entwickelten und weiterentwickelten 3D-Bearbeitungszentrum gearbeitet. In Kleingruppen á 2-3 Personen wird die Ansteuerung anhand von unterschiedlicher, in der Industrie und Mikrocontroller-Welt üblichen Automationshardware (Siemens, PHOENIXCONTACT, NationalInstruments, dSPACE, Arduino) selbst erstellt und programmiert. Dies schafft fundierte Kenntnisse über die Funktionsweise einer 3D-Maschine, wie z. B. einer 3-Achs-Fräse oder eines 3D-Druckers. Des Weiteren wurde begonnen, einen zentralen Steuerungs-Algorithmus in Matlab/Simulink zu entwickeln, der die drei Achsen mit ihren unterschiedlichen Treibern mit Zielvorgaben bzw. Koordinaten per [[Broadcast mit RS232]] versorgt.


== Allgemeines ==
Leitung: [[Benutzer:Mirekgoebel| Prof. Dr. Mirek Göbel]]
 
=== Komponenten ===
 
 
==== Schrittmotor ====
 
Ein Schrittmotor ist ein Synchronmotor. Der Rotor kann durch ein gesteuertes, schrittweise rotierendes elektromagnetisches Feld der Statorspulen um einen minimalen Winkel (Schritt) gedreht werden. Es kann in mehreren Schritten jeder Drehwinkel, wenn er ein Vielfaches des minimalen Drehwinkels ist, realisiert werden.
 
Mit einem Schrittmotor kann man ohne aufwendige Wegstreckenerkennung genaue Positionen anfahren. Da Schrittmotoren exakt dem außen angelegten Feld folgen können, ist ein Betrieb ohne Sensoren zur Positionsrückmeldung möglich. Da alle Schritte im Links- und Rechtslauf gezählt werden, erkennt die Elektronik immer die exakte Position der Achse. Wie groß ein Schritt ist, hängt vom jeweiligen Motor ab, aber zumeist beträgt ein Schrittwinkel 1.8°, sodass mit 200 Schritten eine Umdrehung realisiert werden kann.
 
Man unterscheidet grundsätzlich zwei verschiedene Schrittmotormodelle. Der unipolare
Schrittmotor hat zwei Spulen mit einem jeweiligen Mittelabgriff. Für ihn ist eine Spannung ausreichend. Der bipolare Schrittmotor hat mit vier Spulen und polt die Spannungen kontinuierlich um.
 
Wird ein Schrittmotor durch ein externes Lastmoment oder durch die anzutreibende Masse beim starken Beschleunigen überlastet, kann der Rotor dem Drehfeld nicht mehr folgen. Es werden Schritte übersprungen und eine korrekte Information über die aktuelle Position des Rotors ist nicht verfügbar. Bei einem solchen Schrittverlust springt der Motor in die vorherige oder nächste Position gleicher Phase. Auftretende Schrittverluste summieren sich und führen dann zu einer ungenauen Positionierung.
Für höhere Geschwindigkeiten ist ein sanftes Anfahren und Verzögern zu empfehlen, um einen Schrittverlust zu vermeiden.
 
Die Kenngrößen eines Schrittmotors:
 
• Schrittwinkel, das heißt der Winkel für einen Vollschritt. Ein Vollschritt tritt bei der Umschaltung des Stromes von einer Wicklung auf die nächste auf.
 
• Phasenanzahl
 
• Schrittanzahl n pro Umdrehung
 
• maximaler Strangstrom I
 
• ohmscher Spulenwiderstand R
 
• Spuleninduktivität L
 
• Drehmoment im Stand (Haltemoment) für einen gegebenen Strom und Drehmomentverlauf mit steigender Drehzahl
 
• Wicklungsanschlussgestaltung (ohne Mittelanzapfung, mit Mittelanzapfung, mit gemeinsamer Mittelanzapfung)
 
Quellen:
http://de.wikipedia.org/wiki/Schrittmotor
http://www.wolfgang-back.com/PDF/Schrittmotor.pdf
http://www.rn-wissen.de/index.php/Schrittmotoren
 
==== Gecko Drive ====
 
Der Gecko Drive ist ein Treiber, mit dem ein Schrittmotor angesteuert werden kann. Der Regler im Gecko arbeitet analog und nicht über einen Microcontroller. Die interne Schaltung besteht aus einigen digitalen Standard-IC's (Zähler, Addierer, Flip-Flops, Schmitt-Trigger-Nand-Gatter), OPVs, DA-Wandlern und einigen passiven Bauteile. Über Potentiometer lassen sich P und D einstellen, I ist dagegen festgelegt.
Die optoentkoppelten Eingänge bei Geckodrives sollten nicht gegen Masse, sondern gegen +5V geschaltet werden. Über DIP-Schalter kann man den maximalen Motorstrom einstellen, der bis 7A betragen kann.
Sobald die Encoderposition 128 Schritte außerhalb des Sollwertes liegt, tritt ein Following Error auf. Der Gecko schaltet ab und es muss ein Neustart durchgeführt werden.
 
Die Kenngrößen des Gecko Drive G201X:
 
• Zulässige Versorgungsspannung: 18 – 80 VDC
 
• Anzahl der Phasen: 2
 
• Zulässiger Frequenzbereich: 0.01 Hz bis 300 kHz
 
• Zulässige Betriebstemperatur: 0 – 70 °C
 
• Zulässiger Motorstrom. 0 - 7 A
 
• Verlustleistung:  1 - 13 W
 
• Motorinduktiviät: 1 – 50 mH
 
• Zulässige Eingangsfrequenz:  0 - 200 kHz
 
• Zulässige Signalspannung: 3.3 - 5 VDC
 
Quellen:
http://www.farnell.com/datasheets/1496194.pdf
http://linuxwiki.de/EMC/ServoGecko
 
 
==== Arduino Mega 2560 ====
 
Der Arduino Mega 2560 ist ein Mikrocontroller Board, basierend auf dem ATmega2560 (datasheet). Er verfügt über 54 digitale Input/Output Pins (von denen 14 als PWM Output nutzbar), 16 analoge Inputs, 4 UARTs (Hardware Serial Ports), einen 16 MHz Quarz Oszillator, eine USB Verbindung, eine Strombuchse, einen ICSP Header und einen Reset-Button. Er besitzt alles Notwendige um den Mikrocontroller zu betreiben. Um loszulegen müssen Sie den Arduino Mega 2560 lediglich per USB Kabel mit einem Computer verbinden oder an ein AC-to-DC Netzteil oder eine Batterie anschließen. Der Mega ist mit den meisten für den Arduino Duemilanove und Diecimila entworfenen Shields kompatibel. Der Mega 2560 ist ein Update des Arduino Mega und ersetzt diesen.
 
Der Mega 2560 unterscheidet sich von allen vorherigen Arduino Boards darin, dass er keinen extra FTDI USB-to-Serial Treiber Chip nutzt, sondern einen als USB-To-Serial Converter programmierten ATmega16U2 (in den Versionen bis R2 Atmega8U2).
 
'''Quelle:''' Arduino, http://arduino.cc/de/Main/ArduinoBoardMega2560, Zugriff am 26.11.2013
 
'''Kennzahlen Arduino Mega 2560:'''
 
- Operating Voltage: 5 V
 
- Input Voltage (recommended): 7-12 V
 
- Input Voltage (limits): 6-20 V
 
- Digital I/O Pins: 54 (of which 15 provide PWM output)
 
- Analog Input Pins: 16
 
- DC Current per I/O Pin: 40 mA
 
- DC Current for 3.3V Pin: 50 mA
 
- Flash Memory: 256 KB of which 8 KB used by bootloader
 
- SRAM: 8 KB
 
- EEPROM: 4 KB
 
- Clock Speed: 16 MHz
 
'''Quelle:''' Arduino, http://arduino.cc/de/Main/ArduinoBoardMega2560, Zugriff am 26.11.2013
 
 
==== SPS SIMATIC S7-300 ====
 
[[Datei:S7-300-Uebersicht-001.jpg|160px|thumb|left|SPS SIMATIC-300]]
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Die SIMATIC S7-300 ist speziell für innovative Systemlösungen in der Fertigungsindustrie konzipiert – z. B. in der Automobil- oder Verpackungsindustrie. Hier ist der modulare Controller als universelles Automatisierungssystem die optimale Lösung für Anwendungen im zentralen und dezentralen Aufbau. Neben der Standard-Automatisierung lassen sich auch Sicherheitstechnik und Motion Control integrieren.
 
Die SIMATIC S7-300 ermöglicht einen Platz sparenden und modularen Aufbau. Das vielfältige Baugruppenspektrum kann aufgabenspezifisch für zentrale Erweiterungen oder den Aufbau dezentraler Strukturen verwendet werden und ermöglicht eine kostengünstige Ersatzteilhaltung. Zahlreiche Innovationen machen die SIMATIC S7-300 zu einem durchgängigen System, das Ihnen zusätzliche Investitions- und Wartungskosten erspart.
 
Für die Programmierung der S7-300 steht von Unternehmen Siemens die Software STEP 7 zur Verfügung. Dies ist die Standardsoftware zum programmieren von Siemens SPS.
 
Quelle: http://www.automation.siemens.com/mcms/programmable-logic-controller/de/simatic-s7-controller/s7-300/seiten/default.aspx, abgerufen am 21.01.2014
 
 
==== dSpace DS1104 R&D Controller Board ====
 
[[Datei:ds1104.jpg|300px|thumb|left|DS1104]]
 
Anwendungsbereiche
 
Durch die auf PowerPC-Technologie und I/O-Schnittstellen basierende Echtzeit-Hardware ist die Karte eine optimale Lösung für die Reglerentwicklung in zahlreichen Anwendungsbereichen der Industrie wie Antriebe, Automotive, Robotik sowie Luft- und Raumfahrt. Das DS1104 kommt in vielen Hochschullabors zum Einsatz.
 
 
Vorteile
 
Das DS1104 R&D Controller Board (Research and Development, R&D) macht Ihren PC zu einem leistungsstarken Enwicklungssystem für Rapid Control Prototyping. Real-Time Interface (RTI) bietet Simulink®-Blöcke für grafische I/O-Konfiguration. Die Karte kann in nahezu jeden PC mit freiem 5-V-PCI-Steckplatz installiert werden.
 
 
Arbeiten mit Real-Time Interface
 
Mit Real-Time Interface (RTI) können Sie Ihre Funktionsmodelle leicht auf dem DS1104 R&D Controller Board ausführen. Sie können die gesamte I/O grafisch konfigurieren, die Blöcke in ein Simulinkblockdiagramm einfügen sowie den Modellcode über Simulink Coder® (ehemals Real-Time Workshop®) generieren. Das Echtzeitmodell wird kompiliert, heruntergeladen sowie automatisch gestartet. Dies reduziert die Implementierungszeit auf ein Minimum.
 
'''Quelle:''' dSpace, http://www.dspace.com/de/gmb/home/products/hw/singbord/ds1104.cfm?nv=bbp, Zugriff am 28.01.2014
 
weitere Informationen zu Ein- und Ausgängen des Boards sind hier zu finden: http://www.me.iitb.ac.in/~seth/controlab/expt_5.pdf, Zugriff am 30.01.2014
 
=== Anleitungen ===
 
 
 
==== SPS: Linksammlung zur Siemens SIMATIC S7-300. [[SIMATIC S7]] ====
 
=Fachthemen=
 
== Achsenansteuerung mit Siemens SIMATIC S7-300 SPS ==
 
=== Aufgabenstellung ===
 
Ansteuerung einer Zahnriemenachse mit Schrittmotor durch den Einsatz von einer Speicherprogrammierbaren Steuerung (SPS),Link zu SPS => [[http://193.175.248.56/wiki/index.php/Speicherprogrammierbare_Steuerung]] SIMATIC S7-300, des Unternehmen Siemens.
Zwischen der SPS und dem Schrittmotor befindet sich zusätzlich noch ein GeckoDrive G201X als Motorsteuerung.
 
=== Aufbau / Schaltplan ===
 
=== Einrichtung der Hardware SIMATIC S7-300 ===
 
Wichtig bei der Programmierung einer SPS ist, dass die CPU (Central Processing Unit) weis welche Hardware vorhanden ist.
 
[[Datei:CPU_SPS.jpg]]
 
Bevor eine Steuerung mit STEP 7 in Betrieb genommen werden kann, muss die vorhandene Hardware in der Software STEP 7 konfiguriert werden. Das SPS-System kann ohne eine Hardwarekonfiguration der SPS und der dazugehörigen Baugruppen nicht in Betrieb genommen werden.
 
Bei der Hardwarekonfiguration werden in STEP 7 die vorhandene Hardware (Profilschiene, Stromversorgung, CPU) aufgelistet. Danach werden je nach Bedarf die Baugruppen ausgewählt und Adressen zugewiesen. Zum Schluss wird diese Konfiguration in die CPU geladen, damit die CPU weis, welche Baugruppen zur Verfügung stehen welche Adressen vergeben sind.
 
Weitere Informationen zur Hardwarekonfiguration sind unter folgendem Link zu finden:
 
http://www.sps-lehrgang.de/hardwarekonfiguration/
 
=== Kommunikation zwischen SPS und Rechner ===
 
Bei der Einrichtung der Hardware muss zunächst eine Verbindung zwischen SPS und dem Rechner mit der Software STEP 7 hergestellt werden. Dazu wird ein Multimaster-Kabel verwendet welches die RS 232 Schnittstelle der SPS-CPU mit der USB-Schnittstelle des Rechners verbindet (siehe Abbildung unten).
 
[[Datei:SPS_RS232.jpg]]
 
Diese Verbindung ist wichtig, um die Programm-Daten  aus der Software STEP 7 in die SPS zu laden und ebenfalls die SPS auslesen zu können. Beim Auslesen können sowohl schon vorhandene Programme ausgelesen werden, als auch Signalzustände z.B. von Sensorik am Eingang der SPS. Die SPS besitzt sowohl einen internen Speicher, als auch einen Slot für eine SD-Speicherkarte.
 
=== Komplikationen und letzter Stand ===
 
Beim laden der Software in die SPS gab es ein Problem mir der Kommunikation zwischen dem Rechner und der SPS. Als Fehlermeldung wurde folgender Text ausgegeben: "Die Systemdaten können nicht auf die Baugruppe CPU 313C der Station SIMATIC 300 geladen werden".
 
[[Datei:2013-10-29_155401_1.png]]
 
Daraufhin wurde der Kontakt zum Siemens Support gesucht. Herr Asaad Al-Suleihi hält den Kontakt zum Siemens Support.
 
== Achsensteuerung mit dSpace DS1104 und Matlab Simulink ==
 
=== Aufgabenstellung ===
 
Ansteuerung einer Zahnriemenachse mit Schrittmotor durch den Einsatz von einem dSpace Board (DS1104) mit einer Programmierung auf Basis von Matlab Simulink.
Zwischen dem dSpace Board und dem Schrittmotor befindet sich zusätzlich noch ein GeckoDrive G201X als Motorsteuerung.
 
=== Aufbau / Schaltplan ===
 
Im Allgemeinen ist der Aufbau der Hardwarekomponenten wie bei den meisten Steuerungen in Last- und Steuerkreis aufgeteilt.
 
Laststromkreis:
*alle Verbindungen zwischen der Spannungsversorgung (Power Supply), dem Geckodrive und dem Schrittmotor
 
Steuerstromkreis:
*alle Verbindungen zwischen der dSpace Ausgabebox (dSpace CP1104) und dem Geckodrive
 
[[Datei:Schaltplan dSpace-Gecko-Igus.jpg]]
 
Pinbelegung am SubD-Stecker der Ausgabebox
 
[[Datei:Pinbelegung dSpace Panel.jpg|300px|thumb|left|Pinbelegung CP1104]]
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
=== Regelkreis ===
 
 
=== Simulink Programm ===
 
Im Simulink Programm startet mit der Eingabe der blau markierten Sollposition in hundertstel Millimetern. Dieser Wert kann in ControlDesk durch einen Schieberegler verändert oder durch einen Baustein zum Einlesen von Daten einer RS232-Schnittstelle ersetzt werden.
Im nächsten Schritt wird diese Position in eine Position umgerechnet, welche eine Datenbasis in Schritten besitzt. 0,01 mm sind dann 0,303 Schritte. In einer Datentyp-Umwandlung wird dieser Positionswert in ganzzahlige Werte (Integer-Werte) umgewandelt. Im nächsten Schritt wird dieses Signal mit der aktuellen Position, welche in der Software hinterlegt ist, verglichen. Der Rational Operator1 unterbricht bei Erreichen des Zielwertes die Verbindung zwischen dem Pulsgenerator und dem Digitalausgang für die Schritte. Der Rational Operator im unteren Bereich des Programms vergleicht die Sollposition mit der aktuellen Position, um die Richtung vorzugeben. Ist der neue Wert größer als die aktuelle Position, so fährt der Motor weiter vorwärts, sonst rückwärts. Dies funktioniert über den Switch-Richtung-Baustein. Das Richtungssignal wird dann durch den Gain-Baustein halbiert, da es auf einen Analogausgang geleitet wird. Dieser Ausgang gibt bei dem Wert 1 eine Spannung von 10 V. Um 5 V zu erreichen muss also ein Wert von 0.5 an den Ausgang gesendet werden.
 
 
 
[[Datei:Programm dSpace Simulink.jpg]]
 
=== ControlDesk Oberfläche ===
 
== Achsensteuerung mit µController ==
=== Aufgabenstellung ===
 
 
Innerhalb dieses HSHL-Wikipedia Eintrags wird die Automatisierung einer Achse mit µC „Arduino Mega“ als Steuerungskonzept vorgestellt.
 
=== Regelkreis ===
Als Regelkreis bezeichnet man ein Wirkungsgefüge, das aus einem Steuerungsprozess mit eingeschalteter Gegenkoppelung besteht.
 
In unserem Fall wird als Sollgröße ein zuvor definierter Weg vorgegeben, der innerhalb des Arduino-Programmes in digitale Signale übersetzt wird. Diese digitalen Signale bzw. Steps nutzt der Schrittmotorcontroller (Geckodrive G201X) um den Schrittmotor der Linearachse anzusteuern. Die rotatorische Bewegung des Antriebes wird mittels Inkrementalgeber erfasst und durch die Programmierung in absolute Distanzen umgerechnet, sodass diese Werte als Rückführgröße übergeben werden können. Die Regeldifferenz errechnet Abweichungen dieser Rückführgröße zum Sollwert, sodass ggf. der Arduino die Maßabweichung ausgleicht. Ziel ist es, dass die Regeldifferenz Null wird.
 
[[Datei:Regelkreis.jpg]]
 
=== Belegungsplan ===
Bei der Ansteuerung der Bauteile muss zwischen einem Last- und einem Steuerkreis unterschieden werden. Der Steuerkreis besteht aus einem µc Arduino Mega welcher den Motorcontroller Geckodrive G201X mit den Signalen „step“ für die Schrittanzahl und „direction“ für die Richtungsvorgabe der Bewegung ansteuert.
Die Spannungsversorgung des Arduino Megas wird über USB bzw. ein Festspannungsnetzteil sichergestellt.
Der Geckodrive wird durch eine externe Spannungsquelle versorgt. Diese Nennspannung von 24 Volt wird durch den Geckodrive derart geschaltet, sodass der Schrittmotor nach Steuervorgaben betrieben wird.
Die Bremsvorrichtung des Schrittmotors wird präventiv als Sicherheitseinrichtung bei Spannungsverlust eingesetzt. Deshalb wird diese bei Betrieb der Linieareinheit mit Energie versorgt und damit gelöst bzw. entriegelt.
 
Aus sicherheitstechnischen Gründen müssen beidseitig je ein Endschalter verwendet werden. Die Endschalter registrieren das Erreichen des maximalen Hubweges des Motorschlittens und erzeugen ein Steuersignal welches den Motorschlitten zum Stillstand zwingt und einen definierten Weg in die entgegengesetzte Richtung fahren lässt.
Der Pulldown-Widerstand wird dazu verwendet um den Eingang bei Nichtbeschaltung auf GND zu „ziehen“ um damit Störsignale zu unterbinden.  Zur Sicherheit wird beidseitig je ein weiterer Endschalter benötigt, der am Motorcontroller direkt, durch Verbinden der Anschlusspins 7 und 12, die Spannungsversorgung des Motors zu unterbindet. Hierbei wird allerdings keine Rückmeldung an die Steuerung geliefert, allerdings ist die Stromversorgung sofort unterbrochen, falls die davor installierten Endschlater nicht auslösen.
 
Nachfolgend ist eine mögliche Beschaltung der unterschiedlichen Komponenten detailliert aufgeführt.
 
[[Datei:Schaltplan zur Ansteuerung eines Linearmotors mit Arduino Mega.jpg]]
 
[[Datei:Pinbelegung.jpg]]
 
=== Software ===
==== Kompatibilitätsermittlung für den Betrieb mit Geckodrive G201 REV-6 ====
 
'''STEP AND DIRECTION INPUTS'''
TERMINAL 8:  Direction
Connect the DIRECTION line to this terminal.
TERMINAL 9:  Step
Connect the STEP line to this terminal.
TERMINAL 10:  Common
Connect the controller’s +3.3VDC, +5VDC or GND to this terminal.
These inputs are optically isolated from the rest of the drive. Terminal 10 is the common connection for the opto-isolators and
must be connected to the +3.3VDC, +5VDC or GND of your indexer or pulse generator.
These inputs are meant to be driven by 3.3V to 5.5V logic capable of sourcing or sinking 2.5mA of current. The minimum logic
“0” time is .5uS while the minimum logic “1” time is 3uS with 3.3V – 5V connected on the COMMON terminal. The minimum
logic  “0”  time  is  3uS  while  the  minimum  logic  “1”  time  is  0.5uS  when  connected  to  GND  on  the  COMMON  terminal.
Microstepping occurs on the falling edge of the step input when COMMON is a positive voltage and on the rising edge when
COMMON is connected to GND and on the rising edge when connected to 3.3V – 5V.
 
'''Quelle:''' Datenblatt: Geckodrive Motor Controls, G201X / G210X User Manual, 2011, Tustin CA (USA)
 
 
[[Datei:Theoretische Grundlagenbetrachtung.jpg]]
 
'''Zusammenfassung:''' Eine Mindestperiodendauer von 3,5 µs wird durch die Festelegeung der Parameter im Programm eingehalten.
 
 
====Analyse der Vorwärts- und Rückwärtsbewegung des Hubschlittens====
 
[[Datei:Richtungssignal.jpg]]
 
'''Zusammenfassung:''' Wird ein Directionsignal high am Arduino Mega ausgegeben, so verfährt der Hubschlitten in positive Richtung (vorwärts). Wird hingegen ein Directionsignal low am Arduino Mega ausgegeben, so verfährt der Hubschlitten in negative Richtung (rückwärts).
 
==== Quellcode für die Ansteuerung der x-Achse ====
'''Statusübersicht des Quellcodes für die Ansteuerung der x-Achse:'''
 
• Kommunikation des Arduino Mega mit dem seriellen Monitor (RS232-Kommuniaktion) zur Eingabe des Sollweges. Hierbei wird eine Umwandlung von ASCII-Code in Dezimal durchgeführt.
 
• Es wird bei einer Referenzposition gestartet, auf welche sich alle weiteren Sollwegangeben in Relation beziehen. Das heißt, dass weitere Sollwegeingaben Vielfache der ursprünglich eingegebenen Sollwegangabe sind.
 
'''Beispiel:''' Eine Eingabe des Sollweges von 50 mm zu Beginn der Dateneingabe verfährt den Hubschlitten 50 mm in positive Richtung. Diese Sollposition "merkt" sich die Programmierung. Bei einer weiteren Sollwegeingabe von z.B. 40 mm verfährt der Hubschlitten 10 mm zurück.
 
• Einbindung Endschalter in Programmablauf. Bei der Auslösung der Endschalter wird ein kurzer Weg in inverse Richtung verfahren. Innerhalb des Monitors wird eine entsprechende Fehlermeldung ausgegeben.
 
 
'''Weiterführende Gedanken:'''
 
• Einbindung eines Inkrementalgebers zur Überprüfung des Sollweges
 
• Einbindung festen Referenzpunktes bei Programmstart:
 
'''Vorschlag:''' Bei Programmstart wird solange in eine Richtung verfahren, bis z.B. eine Lichtschranke ausgelöst wird. Damit ist der Referenzpunkt erreicht, z.B. Koordinatenursprung Null. Hierdurch ist gleichzeitig ein begrenztes Intervall zur Sollwegeingabe
geschaffen.
 
 
Anbei ist der gesamte Quellcode für die Ansteuerung eines Linearmotors mit dem Mikrocontroller Arduino mega abgebildet. Der Quellcode ist mit ausreichenden Kommentaren versehen und wird deshalb nicht näher erläutert.
 
Angemerkt werden muss, dass die Bibliothek "Accelstepper" für die Arduino-Software vorinstalliert werden muss. Diese kann konstenfrei über das Internet bezogen werden.
 
Bibliothekseinbindung:
#include <AccelStepper.h> //vordefinierte Bibliothek
 
Parameter und Variablendefinition:
AccelStepper stepper(1,9,8);          // 1 = Treiberboard(definiert), Schritt, Richtung, (vorwärts fahren = 1, rückwärts fahren = 0 (über Directionsignal), autom. Umsetzung durch Bibliothek)
int EndschalterPinlinks = 22;        // Eingang 22 für Kontakt links
int EndschalterPinrechts = 23;        // Eingang 23 für Kontakt rechts
int sollweg = 0;                      // sollweg in mm
int zielweg = 0;
int Vorzeichen = 1;                  // wird bei der ASCII Umwandlung benötigt
double Schritt = 0.033;              // Verhältnis, um absolute Distanzen anzufahren 66/200 = 0,33 (Übersetzung = 66 mm/Umdrehung -> ZLW/-OD-1040Basic Datenblatt,
                                      // 200 = Auflösung bei 1,8° Schrittwinkel, Gecko: Verhältnis 1 zu 10 --> 0,033
double Verfahr = 0;                  // Zuordnen des Verfahrweg --> Verfahr = Anzahl der Schritte für den gewünschten Weg
                                     
Initilaisierung:
 
void setup()
{
        Serial.begin(9600);                    // Port für serielle Kommunikation auf 9600 baud Rate Übertragungsgeschwindigkeit setzen 
        stepper.setAcceleration(24000000);    // Beschleunigung,Geschwindigkeit --> Frequenzänderung
        stepper.setCurrentPosition(0);        // Referenzposition = 0 setzen 
        pinMode(EndschalterPinlinks,  INPUT);
        pinMode(EndschalterPinrechts, INPUT);   
        Serial.println("Initialisierung abgeschlossen"); 
}
 
Hauptprogramm:
void loop()
{             
    if(Serial.available()>0)                          // Koordinaten einlesen
        {
          char ascii = Serial.read();
          //Serial.println(ascii, DEC);
         
          if (ascii == '-')                            // feststellen, ob Minusvorzeichen gesetzt wurde
          {
            Vorzeichen = -1;
          }
         
          if(isDigit (ascii))                          // Prüfen, ob ASCII-Zeichen zw. 0 und 9 liegt (Dezimalzahlen 48 bis 57)
          {
           
            zielweg = (zielweg*10) + (ascii - '0');    // der ASCII Wert 48 entspricht der 0 (Synonym: 'ascii - 48') --> es wird aus dem ASCII Wert der Variablen ein Dezimalwert gebildet
                                                        // die Multiplikation mit 10 erfolgt nach jeder zusätzlich eingegeben Zeichen in einer Zeile, um so auch mehrstellige Dezimalzahlen
                                                        // darstellen zu können eine Zahleneingabe endet mit dem NewLine Befehl, dieser entspricht dem ASCII-Code '10'
          }
         
          else if(ascii == 10 ) //feststellen, ob Zahleneingabe komplett, d.h NewLine Befehl (ASCII=10)
          {
            zielweg = zielweg*Vorzeichen;              // Wert mit Vorzeichen multiplizieren
            Serial.print("Bekommener Wert: ");
            Serial.println(zielweg, DEC);
            sollweg = zielweg;
            zielweg = 0;
            Vorzeichen = 1;
          }
          }     
       
    if (digitalRead(EndschalterPinlinks) == LOW && digitalRead(EndschalterPinrechts) == LOW) // Sicherheitsabfrage
      {
        Verfahr = sollweg/Schritt;                    // Umrechnen des eingegebenen Koordinatenwertes in Anzahl von Schritten
        stepper.moveTo(Verfahr);                      // Festlegen des Weges
        Verfahren();                                  // Unterprogramm Verfahren() ausführen
      }
     
    else if(digitalRead(EndschalterPinlinks) == HIGH)  // wenn Schalter belegt - rückfahren
        {
          Serial.println("Endschalter_links");
          stepper.move(500);
          int diff =  stepper.currentPosition() + 500;       
          while(stepper.currentPosition() != diff)
          {
            stepper.run();
          }
            sollweg = stepper.currentPosition()*Schritt;
        }
         
    else if(digitalRead(EndschalterPinrechts) == HIGH) // wenn Schalter belegt - rückfahren
        {
          Serial.println("Endschalter_rechts");
          stepper.move(-500);
          int diff =  stepper.currentPosition() - 500;       
          while(stepper.currentPosition() != diff)
          {
            stepper.run();
          }         
            sollweg = stepper.currentPosition()*Schritt;       
        }       
}
   
 
Funktion "Verfahren"
 
void Verfahren()
{
    if (stepper.currentPosition() != Verfahr )      // solange bis Position erreicht "run"
    {
        stepper.run();
    }               
    stepper.setSpeed(0);
    stepper.moveTo(stepper.currentPosition());    // Beschreiben der aktuellen Position 
}
 
==== Quellcode für die die Duplizierung auf alle Achsen ====
'''Statusübersicht des Quellcodes für die Duplizierung der Programmierung auf alle drei Achsen (Zusatzaufgabe):'''
 
• Die Programmierung ist im Stande, alle drei Achsen anzusprechen
 
• Eine eindeutige Zeichenkette (z.B.: x2000y0000z0000e) muss dem Programm vorgegeben werden, um die Achsen anzusteuern
 
 
'''Weiterführende Gedanken:'''
 
• Die sich wiederholende Programmabschnitte können mit allgemeingültigen Funktionen umgesetzt werden
 
 
 
'''Programmablaufplan für die Ansteuerung von drei Achsen mit dem ArduinoMega'''
 
 
[[Datei:Flussdiagramm für die Duplizierung auf alle drei Achsen.jpg]]
 
 
Repräsentativ bilden wir die wesentlichen Abschnitte des Programms ab. Hierbei konzentrieren wir uns auf die Abschnitte für die x-Achse. Die Abschnitte für die y- und z-Achse sind identisch, mit der Ausnahme der Beschriftung mit y- und z sowie dem Abbruchkriterium mit dem Buchstaben e für die z-Achse.
 
 
Bibliothekseinbindung:
#include <AccelStepper.h>                // vordefinierte Bibliothek
 
Parameter und Variablendefinition:
AccelStepper stepperx(1,9,8);          // 1 = Treiberboard(definiert), Schritt, Richtung
int EndschalterPinlinksx = 22;          // Eingang 22 für Kontakt links
int EndschalterPinrechtsx = 23;        // Eingang 23 für Kontakt rechts
int sollwegx = 0;                      // Sollweg in mm
int Vorzeichen = 1;                    // wird bei der ASCII Umwandlung benötigt
double Schritt = 0.033;                // Verhältnis, um absolute Distanzen anzufahren
                                        // 66/200 = 0,33 (Übersetzung = 66 mm/Umdrehung -> ZLW/-OD-1040Basic Datenblatt,
                                        // 200 = Auflösung bei 1,8° Schrittwinkel)
                                        // Gecko: Verhältnis 1 zu 10 --> 0,033
double Verfahrx = 0;                    // Zuordnen des Verfahrweg --> Verfahr = Anzahl der Schritte für den gewünschten Weg
int status_x = 0;
char ascii;
 
Initilaisierung:
void setup()
{
        Serial.begin(9600);                    // Port für serielle Kommunikation auf 9600 baud Rate Übertragungsgeschwindigkeit setzen 
        stepperx.setAcceleration(24000000);    // Beschleunigung,Geschwindigkeit --> Frequenzänderung
        stepperx.setCurrentPosition(0);        // Referenzposition = 0 setzen 
        pinMode(EndschalterPinlinksx,  INPUT);
        pinMode(EndschalterPinrechtsx, INPUT); 
        Serial.println("Initialisierung abgeschlossen");
        Serial.flush();
}
 
Hauptprogramm (Ausschnitt):
  void loop()
{ 
  if(Serial.available() > 0)                      // Koordinaten einlesen
        {
          ascii = Serial.read();
         
     
          if (ascii == 'x')                        // feststellen, ob x gesetzt wurde
          {
            status_x = 1;
            while (status_x == 1) 
              {
                status_x = UmrechnungplusBerechnung();
              }
          }         
          if (ascii == 'y')
          {
            Serial.print("Bekommener Wertx: ");
            Serial.println(zielweg, DEC);
            sollwegx = zielweg;
            zielweg = 0;   
          }
 
Weiterführender Hauptteil (Ausschnitt):
 
if (digitalRead(EndschalterPinlinksx) == LOW && digitalRead(EndschalterPinrechtsx) == LOW)    // Sicherheitsabfrage
      {
        Verfahrx = sollwegx/Schritt;                  // Umrechnen des eingegebenen Koordinatenwertes in Anzahl von Schritten
        stepperx.moveTo(Verfahrx);                    // Festlegen des Weges
        Verfahrenx();                                  // Unterprogramm Verfahren() ausführen
      }       
    else if(digitalRead(EndschalterPinlinksx) == HIGH)          // wenn Schalter belegt - rückfahren
        {
          Serial.println("Endschalter_linksx");
          stepperx.move(500);
          int diff =  stepperx.currentPosition() + 500;       
          while(stepperx.currentPosition() != diff)
          {
            stepperx.run();
          }
            sollwegx = stepperx.currentPosition()*Schritt;
        }
         
    else if(digitalRead(EndschalterPinrechtsx) == HIGH)          // wenn Schalter belegt - rückfahren
        {
          Serial.println("Endschalter_rechtsx");
          stepperx.move(-500);
          int diff =  stepperx.currentPosition() - 500;       
          while(stepperx.currentPosition() != diff)
          {
            stepperx.run();
          }         
            sollwegx = stepperx.currentPosition()*Schritt;       
        }
 
Funktion Verfahren():
 
void Verfahrenx()
{
  if (stepperx.currentPosition() != Verfahrx ) //solange bis Position erreicht "run"
  {
    stepperx.run();
  }               
  stepperx.setSpeed(0);
  stepperx.moveTo(stepperx.currentPosition()); //Beschreiben der aktuellen Position     
}
 
Funktion Umrechnung plus Berechnung:
  int UmrechnungplusBerechnung()
{
      ascii = Serial.read();
      if(isDigit(ascii))          //Prüfen, ob ASCII-Zeichen zw. 0 und 9 liegt (Dezimalzahlen 48 bis 57)
          {                   
              zielweg = (zielweg*10) + (ascii - '0'); // Erklärung siehe Quelltext oben
              return 1;
          }
          else
          {
                return 0;
          }
}
 
== Achsensteuerung mit 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.
 
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 Verarbeitung 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 schriftbasierte 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.
 
====Belegungsplan für Motoransteuerung====
 
Zunächst sollten die benötigten Eingänge und Ausgände, 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 I/O- Controller verlegt werden.
 
In diesem Fall wurde nach folgendem Belegungsplan verkabelt:
 
[[Datei:Schaltplan neu.jpg]]
 
==== 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.
 
 
 
[[Datei:Leeres Projekt..jpg]]
 
 
Anschließend erscheint im Project-Explorer die Hardware Chassis (CRIO-9114). Das im Slot 1 befindliche Modul zeigt alle DIO´s welche über ein 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.
 
 
[[Datei:Einfügen der Hardware.jpg]]
 
 
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:
 
[[Datei:neues VI.jpg]]
 
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:
 
[[Datei:Blockdiagramm.jpg]]
 
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 stellt 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.
 
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 gleichzeit 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 and Drop in die Arbeitsfläche gezogen werden.  Unter "Programmierung" => "Strukturen" befindet sich der Baustein "Flache Sequenz". Nachdem diese auf die Arbeitsfläche gefügt wird, besteht dieses Bauteil nur aus einer Sequenz. 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 ("Programmiereung" => "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]]
 
Damit auch vom Front-Panel 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%)
 
[[Datei:Regler.jpg]]
 
=====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 Front-Panel und kann dort jederzeit abgelesen werden.
 
[[Datei:Zähler.jpg]]
 
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.
 
[[Datei:Definierter_Verfahrweg.jpeg]]
 
=====Richtungsänderung des Schrittmotors=====
 
Um die Verfahrrichtung des Schrittmotors zu ändern, muss zunächst ein Schalter, welches anschließend über das Frontpanel 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 Hardwaremoduls. Damit ist die Drehrichtung des Motors definiert. In diesem Beispiel wird mittels LED´s die aktuell gefahrene Richtung visualisiert.
 
[[Datei:Richtungsänderung.jpg]]
 
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. Ist dies erwünscht, muss vorab das VI im Real-time Modus angelegt werden: VERWEIS
 
=====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 Frontpanel 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 empfielt 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).
 
 
=====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.
 
[[Datei:realtime.jpg]]
 
 
 
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“. Diesen dagegen läuft auf der Hardware und wird nur dann durchgeführt, wenn sich die Absolutposition des Schrittmotors ändern soll.
 
'''Variablen definieren'''
Der Realtime-Modus ermöglicht es Variablen zu erstellen und zu definieren. Diese können innerhalb mehrerer VIs 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 and Drop“ (analog zu den DIOs ) in das gewünschte VI einfügen. Über einen Rechtsklick auf den Baustein kann der Zugriffsmodus (lesen oder schreiben) definiert werden.
 
=====Realtime-Projekt erstellen=====
 
=====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.
 
 
=====Ausblick=====
 
'''Schrittlänge'''
Die minimale Periodendauer des Signales zur Motoransteuerung beträgt mit dem bisherigen Einstellungen des Programmes 20ms. Laut Datenblatt ist die Hardware in der Lage, weitaus höhere Signalfrequenzen zu verarbeiten. Für einen optimalen Einsatz  der Schrittmotoren sollte versucht werden die mögliche Ausgabefrequenz zu erhöhen.
 
'''Einbindung der RS232 Schnittstelle'''
Um die Achsen miteinander kommunizieren zu lassen, ist es notwendig eine RS232 Schnittstelle einzubinden.  Dazu gilt es ein weiteres Modul in die Hardware einzufügen und in der Software zu implementieren.
 
Mittels der Schnittstelle können dann Koordinaten mittels eines Strings seriell übertragen werden.
Dieser kann wie folgt aussehen: X1000Y0000Z0000E. Dieses Format ermöglicht die Weitergabe der einzelnen Soll-Positionen an die Achsen. Jeder Achse wird hinter einem Buchstaben X,Y oder Z ein Wert für die Soll-Position vorgegeben, die diese dann selbständig anfahren soll. Der String muss dafür Zeichen für Zeichen entziffert werden, damit die entsprechende Achse ihren Teil der "Botschaft" erkennen und verarbeiten kann.
 
== Zentraler Steueralgorithmus ==
 
== Konstruktion ==
=== Aufgabe im Fachthema ===
 
Das Fachthema Konstruktion im Rahmen des Praktikums „Produktionstechnik“ umfasst die mechanische Planung und den Aufbau einer CNC-Maschine.
Es geht hierbei um die Zusammenstellung von Anforderungen bezüglich einer 3-Achs-CNC-Maschine sowie die konstruktive Planung mittels CAD-Modellen und technischen Zeichnungen und die Umsetzung dieser Planung durch die Montage der Maschine.
 
=== Erste Überlegungen ===
Im ersten Schritt wurden Anforderungen an die Maschine, an den Werkzeughalter sowie den Werkstückhalter gesammelt und ein erster Entwurf der Maschine erstellt.
 
==== Anforderungen ====
Um eine präzise Ausführung der Bewegungen zu realisieren, muss der Aufbau sowohl leichtgängig als auch verwindungssteif sein.
Da die Maschine von mehreren Generationen von Studenten genutzt werden soll, sollte die Bedienung einfach und intuitiv sein.
Um eine Flexibilität des Gebrauchs zu gewährleisten, sollte die Maschine möglichst leicht im Gewicht sein sowie (ggf. durch teilweise einfache Demontierbarkeit) gut transportierbar.
Das verwendete Material sollte korrosionsbeständig, preisgünstig sowie mit einfachen Mitteln zu bearbeiten sein. Das Material war zum großen Teil bei Projektaufnahme bereits vorhanden.
 
Der Werkzeughalter sollte erweiterbar sein, sodass keine Beschränkung auf zuvor geplante Werkzeuge vorliegt. Der Werkzeughalter sollte entsprechend entweder kompatibel oder leicht zu wechseln sein.
Durch eine gute Abriebfestigkeit soll eine hohe Genauigkeit sowie eine hohe Haltbarkeit erreicht werden.
 
Der Werkstückhalter sollte flexibel sein, sodass Werkstücke unterschiedlicher Form und Größe eingespannt werden können. Außerdem muss er nach Gebrauch leicht zu reinigen und gut transportierbar sein.
 
==== Erster Entwurf ====
In einem ersten Entwurf wurden zunächst verschiedene Möglichkeiten aufgezeigt, um eine 3-Achs-CNC-Maschine zu konzipieren.
Generell gibt es die Möglichkeit, einen Tisch unterhalb eines Portalbalkens zu verfahren. Der Tisch stellt dabei die X-Achse dar. An dem Portalbalken sitzt die zweite Achse, welche im 90 Grad-Winkel zur X-Achse verfährt und die Y-Achse darstellt. Auf dieser Y-Achse sitzt wiederum im 90 Grad-Winkel die Z-Achse, welche senkrecht zur X-Achse steht.
Alternativ kann man ein in X-Richtung fahrbares Portal erzeugen, welches an einem feststehenden Tisch entlangfährt. Vorteil bei dieser Variante ist der geringere Platzbedarf und damit die bessere Ausnutzung der Linearachsen für die X-Achse. Nachteil ist, dass für eine ausreichende Steifigkeit das Portal stabiler ausgeführt werden muss, als dies bei einem feststehenden Portal nötig wäre.
Da sämtliche Linearachsen bereits vorhanden waren und möglichst gut ausgenutzt werden sollten, entschied man sich für ein fahrbares Portal, bei welchem dieses an einem rechteckigen Grundrahmen vorbeifährt und damit die X-Achse darstellt.
 
=== Detaillierung ===
==== CNC-Maschine ====
Der beschriebene Aufbau wurde im Weiteren detailliert und ergänzt.
Der generelle Aufbau der Maschine wurde in einem CAD-Modell erstellt. Mit hochkant angeordneten Aluminiumprofilen mit den Außenabmessungen 160x40mm wurde ein kastenförmiger Grundrahmen zusammengesetzt. Seitlich an den Längsseiten sitzen die Linearantriebe für die x-Achse. Diese sind an beiden Seiten angeordnet, um ein Verkanten des Portalbalkens bei außermittiger Krafteinwirkung zu verhindern. Der Kasten wird durch zwei weitere Aluminiumprofile versteift.  Seitlich an den beiden X-Achsen-Linearantrieben werden senkrechte Aluminiumprofile montiert, welche einen waagerechten Portalbalken aufnehmen. Auf diesem ist der Linearantrieb der Y-Achse montiert, welcher wiederum den Linearantrieb der Z-Achse aufnimmt. Wichtig bei der Konstruktion des Portales war es, einen möglichst breiten Führungsschlitten auf den beiden Linearführungen des Portales realisieren zu können. Daher wurden die serienmäßigen Linearschlitten durch speziell konstruierte Neuteile ersetzt, um eine breitere Führung realisieren zu können. Dadurch wird ein Verkanten des Schlittens auf der Führung wirkungsvoll verhindert.
 
Als Arbeitsfläche der 3Achs-Maschine dient eine 21mm starke Birke-Multiplexplatte, welche bündig auf dem Grundrahmen der Maschine montiert ist.
 
Die Konstruktion wurde um Haltewinkel für Endschalter sowie um eine Halterung für die benötigte E-Kette ergänzt.
Es wurden für jede Achse vier Endschalter-Haltewinkel vorgesehen, wobei jeweils zwei an jedem Ende der Achsen hintereinander angebracht sind. Der jeweilige innere Endschalter wird von der jeweiligen Steuerung ausgelesen und kann beispielsweise als Referenzschalter verwendet werden. Der jeweilige äußere Endschalter dient als Not-Aus und geht direkt auf den Disable Eingang des Gecko-Drive. So wird der Gecko hardware-seitig ausgeschaltet, um einen mechanischen Schaden zu verhindern.
 
==== Werkzeug- und Werkstückhalter ====
 
Als Werkzeughalter wurden zwei 20mm starke Aluminiumplatten mit unterschiedlich großen Bohrungen (Ø43H7 sowie Ø20H7) zur Aufnahme von zwei verschiedenen Werkzeugen konstruiert. Die Platten sind mittels zwei Schrauben befestigt und so leicht zu wechseln. Gespannt wird das Werkzeug jeweils über eine Passung, welche durch eine Schlitzung zusammengedrückt werden kann. Dies gewährleistet einen sicheren Halt des Werkzeuges.
 
[[Datei:Werkzeughalter.jpg]]
 
 
Als Werkstückhalter bieten sich die Holzplatte und eine ergänzte Nutenplatte. Hier kann das Werkstück auf der Holzplatte festgeschraubt werden beziehungsweise im Profil der Nutenplatte befestigt werden.
 
==== Platte für Steuerungseinheiten ====
Da für die Maschine die Steuerungseinheiten mit Treibern, Kühlern und Netzteilen benötigt werden, wurde eine Platte konzipiert, die genügend Platz für alle benötigten Elemente bietet.
Es handelt sich hierbei um eine 80x50cm große Holzplatte. Um  einen optimalen Wärmetransport zu realisieren, wurden die wärmsten Bauteile am oberen Ende der Platte angebracht. Die drei Gecko-Drives wurden mit Schrauben und Wärmeleitfolie an einem Aluminiumwinkel befestigt. Gegenüber von jeden Gecko-Drive sitzt an dem Aluminiumwinkel jeweils ein Kühlkörper mit Lüfter. Unterhalb des Winkels befinden sich die 24V-DC-Netzteile als Stromversorgung für die Gecko-Drives. Am unteren Ende der Platte sind die Steuereinheiten und eine Mehrfachsteckdose montiert.
Eine Darstellung der Platte inklusive aller zu montierenden Elemente ist der nachfolgenden Abbildung zu entnehmen.
 
[[Datei:E-Platte.png]]
 
=== Stückliste & Montageanleitung ===
==== Stückliste ====
 
{| class="wikitable"
!Bezeichnung
!Anzahl
|-
| "Opferplatte"
| 1
 
|-
| "Adapter"
| 12
 
|-
| "Adapter2"
|2
 
|-
| "AdapterYZAchse_kurz"
|1
 
|-
| "AdapterYZAchse_kurz2"
|1
 
|-
| "Elektroplatte"
|1
 
|-
| "E_Kettenblech"
|1
 
|-
| "E_Kettenblech2"
|1
 
|-
| "E_Kettenblech3"
|1
 
|-
| "E_Kettenblech4"
|1
 
|-
| "Haltewinkel"
|1
 
|-
| "Haltewinkel_Endschalter"
|8
 
|-
| "Werkzeughalter"
|1
 
|-
| "Z-Achse_kurz"
|1
 
|-
| "Z-Achse_kurz_Adapter"
|1
 
|-
| Profil 8 leicht 160x40 L1000
|2
 
|-
| Profil 8 leicht160x40 L1126
|1
 
|-
| Profil 8 leicht160x40 L920
|2
 
|-
| Profil 8 leicht160x40 L520
|2
 
|-
| Profil 8 leicht 160x40 1250
|2
 
|-
| Zahnriemenantrieb ZLW-1040-02-B-100-R-300
|1
 
|-
| MK-0089 Motorkit
|1
 
|-
| Zahnriemenantrieb ZLW-1040-02-B-100-R-1000
|3
 
|-
| MK-0089 Motorkit
|3
 
|-
| Führungsschiene WS-20, 1120
|1
 
|-
| Gehäuselager WJ200UM-01-20
|2
 
|-
| Anschlußelementsatz 117.4.12PZ.A2
|2
 
|-
| Winkel S208W40S
|16
 
|-
| Kritec Winkel (80x80x80)Zn, Art.-Nr. 11355
|12
 
|-
| Energiekette E16.4.060.0 Länge 1830mm
|2
 
|-
| Nutenstein 8 St M8
|118++
 
|-
| Gummifüße
|6
 
|-
| Senkschraube DIN 7991-M8x14
|32
 
|-
| Senkkopf-Holzschraube 4x20
|19
 
|-
| Senkkopf-Holzschraube 2,5x25
| 4
 
|-
| Senkkopf-Holzschraube 3x20
|6
 
|-
| Schraube M3x8 DIN912
|30
 
|-
| Schraube M3x16 DIN912
|12
 
|-
| Schraube M8x25 DIN912
|24
 
|-
| Schraube M6x16 DIN912
|24
 
|-
| Schraube M8x16 DIN912
|16
 
|-
| Schraube M3x10 DIN912
|16
 
|-
| Bohrschleifer IBS/E, Inkl. 34tlg. Einsatzwerkzeugeset und 6 Spannzangen
|1
 
|-
| Steckerleiste, Conrad Best.-Nr.: 611856 - 62
|1
|-
|}
 
 
 
==== Montageanleitung ====
 
Zunächst wird der Grundrahmen, wie unten abgebildet, zusammengebaut. Benötigt werden dafür Aluminiumprofile mit dem Querschnitt 160x40mm, je zwei Stück in den Längen 1250mm, 1000mm sowie 920mm. Die 1250mm langen Profile dienen als Längsprofil. Quer verbunden werden diese über die 1000mm langen Profile. Verbunden werden die Ecken mittels acht Aluminium-Druckgusswinkeln und passenden M8-Innensechskant-Schrauben.
Der Rahmen wird innen durch die beiden 920mm langen Aluminiumprofile in drei gleich große Bereiche unterteilt. Montiert werden diese Profile mittels 16 schwarz lackierter Stahlwinkel, 32 passenden M8-Senkkopf-Innensechskant-Schrauben sowie 32 Nutensteinen.
 
 
[[Datei:Montage1.png]]
 
 
An den beiden langen Seiten des Grundrahmens werden je Seite vier "Adapter" mit Hilfe von je zwei M8x25-Innensechskantschrauben, zwei U-Scheiben M8 sowie zwei Nutensteinen montiert (blaue Markierungen). Dabei ist auf einen gleichmäßigen Abstand der vier "Adpater" zu achten.
 
[[Datei:Montage2.png]]
 
Anschließend werden die beiden langen Linearachsen vom Typ Igus ZLW 1040 mit insgesamt acht Befestigungsschellen und acht M6x16-Innensechskantschrauben mit den Adaptern formschlüssig verschraubt (blaue Markierung).
 
[[Datei:Montage3.png]]
 
Die Verbindungsplatte der beiden Schlitten wird demontiert und gegen die Platte mit der Bezeichnung "Adapter2" ausgetauscht. Dabei ist darauf zu achten, dass der Riemen stramm gespannt ist, wenn er mit den beiden Schrauben (grüne Markierung) festgeklemmt wird. Der "Adapter2" dient anschließend zur Befestigung der senkrecht stehenden Portal-Seitenwände.
 
[[Datei:Montage4.png]]
 
 
 
[[Datei:Montage5.png]]
 
 
Die beiden Profile mit dem Querschnitt 160x40mm und der Länge von 520mm werden jeweils auf eine Adapterplatte geschraubt. Befestigt sind die Profile über je 4 Stk. M8x16 Schrauben und Nutensteinen (blaue Markierung). Es ist darauf zu achten, dass das Aluminiumprofil bündig mit der Adapterplatte ist (grüne Markierung).
 
[[Datei:Montage6.png]]
 
[[Datei:Montage7.png]]
 
 
Am oberen Ende der beiden Profile werden jeweils 2 Verbindungswinkel 80x80x80mm mittig an den Profilen befestigt, wie im nachfolgenden Bild gezeigt.
 
[[Datei:Montage8.png]]
 
[[Datei:Montage9.png]]
 
 
Das Aluminiumprofil mit dem Querschnitt 160x40mm und  der Länge von 1126mm wird mit den Winkeln verschraubt und bildet somit den Portalbalken.
 
 
[[Datei:Montage10.png]]
 
 
Für die Montage des Y-Achsen-Linearantriebes werden die vier "Adapter" im gleichmäßigen Abstand auf dem Portalbalken verschraubt. Verwendet werden dazu insgesamt acht M8x25-Innensechskantschrauben, acht U-Scheiben M8 sowie acht Nutensteinen (blaue Markierungen).
 
[[Datei:Montage11.png]]
 
 
 
Nun wird der Linearantrieb vom Typ Igus ZLW 1040 mit insgesamt acht Befestigungsschellen und acht M6x16-Innensechskantschrauben mit den Adaptern formschlüssig verschraubt. Außerdem wird oberhalb des Portalbalkens die Linearführung vom Typ Igus WS-20 mit zehn M8x12-Innensechskantschrauben sowie zehn Nutensteinen verschraubt, sodass die Linearführung mittig auf dem Portal sitzt.
 
[[Datei:Montage12.png]]
 
[[Datei:Montage13.png]]
 
 
Der "AdapterYZAchse_kurz2" wird mit insgesamt vier M8x25-Innensechskantschrauben und vier M8-Unterlegscheiben mit den zwei Führungswagen der Igus WS-20 Linearführung verschraubt. Außerdem wird die Verbindungsplatte des Igus ZLW 1040 Schlittens demontiert und gegen die Platte mit der Bezeichnung "AdapterYZAchse_kurz" ausgetauscht. Dabei ist darauf zu achten, dass der Riemen stramm gespannt ist, wenn er mit den beiden Schrauben festgeklemmt wird.
 
 
[[Datei:Montage14.png]]
 
[[Datei:Montage15.png]]
 
Der kurze Linearantrieb vom Typ Igus ZLW 1040 wird mit insgesamt sechs Befestigungsschellen, sechs M6x12-Innensechskantschrauben sowie sechs M6-Unterlegscheiben  formschlüssig mit der Z-Achse verschraubt (blaue Markierungen). Wichtig dabei ist, dass die Unterseite der Z-Achsen-Platte mit dem Linearantrieb bündig abschließt.
 
[[Datei:Montage16.png]]
 
Die Verbindungsplatte des Igus ZLW 1040 Z-Achsen-Schlittens wird demontiert und gegen die Platte mit der Bezeichnung "Z-Achse_kurz_Adapter" ausgetauscht (blaue Markierung). Dabei ist darauf zu achten, dass der Riemen stramm gespannt ist, wenn er mit den beiden Schrauben festgeklemmt wird .
 
[[Datei:Montage17.png]]
 
 
Die Platte mit der Bezeichnung "Z-Achse_kurz" wird mit vier M8x25-Innensechskantschrauben mit dem Linearschlitten der Z-Achse verschraubt, sodass dieser seitlich bündig mit der Schlittenplatte ist (blaue Markierung).
 
[[Datei:Montage18.png]]
 
 
Der Werkzeughalter mit der Bezeichnung "Werkzeughalter" oder alternativ "Werkzeughalter2" wird mit zwei M6x25-Innensechskantschrauben mit der z-Achsenplatte verschraubt, sodass die Unterseiten beider Teile bündig sind (blaue Markierung).
 
 
[[Datei:Montage19.png]]
 
 
Auf der Rückseite der Z-Achse wird mit zwei schwarzen Stahlwinkeln und vier M8-Innensechskantschrauben das "E-Kettenblech4" montiert, welches als einer von zwei Befestigungspunkten für die Energiekette der Y-Achse dient (blaue Markierung).
 
[[Datei:Montage20.png]]
 
 
Auf der Rückseite des Portalbalkens werden drei schwarze Stahlwinkel mittels M8-Innensechskantschrauben und Nutensteinen mit der obersten Nut des Aluminiumprofiles verschraubt, sodass eine Schenkelfläche bündig zum Profil ist (blaue Markierung). Diese Winkel dienen als Durchhangschutz für die Y-Achsen Energiekette.
 
[[Datei:Montage21.png]]
 
Die Teile "E_Kettenblech" sowie "E_Kettenblech2" werden jeweils mittels 2 schwarzen Stahlwinkeln, vier M8-Senkkopf-Innensechskantschrauben, zwei M8-Muttern sowie zwei
Nutensteinen wie nachfolgend gezeigt montiert. Wichtig dabei ist eine Höhendifferenz beider Bleche von 120mm, damit die Energiekette später sauber mitläuft.
 
[[Datei:Montage22.png]]


Die "Opferplatte" wird mit M8-Senkkopf-Innensechskantschrauben mit dem Grundrahmen der Maschine verschraubt. Die Bohrungen dafür müssen noch in die Platte eingebracht werden. Wichtig dabei ist, dass die Senkungen tief genug ausgeführt werden, damit der Schraubenkopf tief genug im Holz verschwindet. Nur so ist gewährleistet, dass im Falle eines Hereinfräsens in die Opferplatte nicht der Fräser den Schraubenkopf berührt.
= Weitere im Rahmen von Sonderthemen für das Praktikum entstandene Artikel =
*[[Schrittmotor]]
*[[Schrittmotoransteuerung mit Gecko Drive]]
*[[Mikrocontrollerboard Arduino Mega 2560]]
*[[Automatisierungssystem SPS SIMATIC S7-300]]
*[[Automatisierungssystem dSpace DS1104 R&D Controller Board]]
*[[Ansteuerung des Mitsubishi Roboters]]
*[[3D-Druck mit dem German RepRap X400]]
*[[Baukasten Automatisierung]]
*[[Entwicklung und Bau von Roboterzellen für Delta-Roboter]]
*[[2D-Styroporschneidewerkzeug für 3D-CNC-Bearbeitungsmaschine]]
*[[Computer_Aided_Manufacturing_(CAM)#Fr.C3.A4ser_und_ihre_Parameter_zum_Fr.C3.A4sen_von_unterschiedlichen_Materialien]]


=Fachthemen für die Kleingruppen =


[[Datei:Montage24.png]]
==Ansteuerung:==


*[[Ansteuerung einer Schrittmotor-Achse mit Siemens SIMATIC S7-300 SPS]]
*[[Ansteuerung einer Schrittmotor-Achse mit PHOENIXCONTACT AXC 1050]]
*[[Ansteuerung_einer_Schrittmotor-Achse_mit_dSpace_DS1104 und_Matlab/Simulink]]
*[[Ansteuerung einer Schrittmotor-Achse mit Mikrocontrollern am Beispiel eines Arduino-Mega]]
*[[Ansteuerung einer Schrittmotor-Achse mit NI Labview]]
*[[Zentraler Steuerungsalgorithmus für ein 3-Achs-CNC-Bearbeitungszentrum]]
*[[Zentraler Steuerungsalgorithmus für ein 3-Achs-CNC-Bearbeitungszentrum mit Matlab/GUIDE]]
*[[Computer Aided Manufacturing (CAM)]]


[[Datei:Montage23.png]]
==Konstruktion:==
*[[Konstruktion eines 3-Achs-CNC-Bearbeitungszentrums]]
*[[Weiterentwicklung eines 3-Achs-CNC-Bearbeitungszentrums mit neuen Spindelantrieben]]
*[[Erweiterung/Fehlerbehebung an dem 3-Achs-CNC-Bearbeitungszentrums und Konstruktion eines Außengehäuses]]
*[[Konstruktion, Fertigung und Inbetriebnahme eines Rundtisches (4.Achse)]]


== Broadcast mit der RS232-Kommunikationsschnittstelle ==
[[Boradcast mit RS232]]


=Linksammlung=
=Linksammlung=
* Fräsmaschine im Eigenbau, sehr schick [http://der-frickler.net/technik/frickelfraese]
* Fräsmaschine im Eigenbau, sehr schick [http://der-frickler.net/technik/frickelfraese]
* ...
* Eigenbau einer Maschine für weniger als 1000€ [http://www.tron-cnc.de/]
* "open-hardware"-Projekt [http://www.shapeoko.com/wiki/index.php/Main_Page]
* Tips fürs die Holzverarbeitung [https://www.holzwerken.net/tipps-tricks]

Aktuelle Version vom 30. Januar 2022, 11:46 Uhr


Einführung

Im Praktikum "Produktionstechnik" des 7. Semesters im Studiengang Mechatronik (Schwerpunkt "Global Production Systems") wird an einem selbst konzipierten, entwickelten und weiterentwickelten 3D-Bearbeitungszentrum gearbeitet. In Kleingruppen á 2-3 Personen wird die Ansteuerung anhand von unterschiedlicher, in der Industrie und Mikrocontroller-Welt üblichen Automationshardware (Siemens, PHOENIXCONTACT, NationalInstruments, dSPACE, Arduino) selbst erstellt und programmiert. Dies schafft fundierte Kenntnisse über die Funktionsweise einer 3D-Maschine, wie z. B. einer 3-Achs-Fräse oder eines 3D-Druckers. Des Weiteren wurde begonnen, einen zentralen Steuerungs-Algorithmus in Matlab/Simulink zu entwickeln, der die drei Achsen mit ihren unterschiedlichen Treibern mit Zielvorgaben bzw. Koordinaten per Broadcast mit RS232 versorgt.

Leitung: Prof. Dr. Mirek Göbel

Weitere im Rahmen von Sonderthemen für das Praktikum entstandene Artikel

Fachthemen für die Kleingruppen

Ansteuerung:

Konstruktion:


Linksammlung

  • Fräsmaschine im Eigenbau, sehr schick [1]
  • Eigenbau einer Maschine für weniger als 1000€ [2]
  • "open-hardware"-Projekt [3]
  • Tips fürs die Holzverarbeitung [4]
Abgerufen von „https://wiki-test.hshl.de/wiki/index.php?title=3D-CNC-Bearbeitungsmaschine&oldid=87865“