|
|
| (92 dazwischenliegende Versionen von 16 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|300px|thumb|none|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|500px|thumb|none|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 ===
| |
| | |
| 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 SPS und dem Geckodrive
| |
| | |
| [[Datei:Schaltplan SPS-Gecko-Igus.jpg|500px|thumb|none|Schaltplan SPS-Gecko-Igus]]
| |
| | |
| === 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.
| |
| Mail an Siemens Support:
| |
| | |
| "Geehrter Siemens Support,
| |
| | |
| wir haben in einem Praktikum unseres Studiengangs Mechatronik ein Projekt, in dem die Studierenden mit einer Siemens SPS (313-5BG04-0AB0) arbeiten.
| |
| Die Verbindung der SPS mit dem Computer erfolgt über ein USB PC Adapter und soll als Programmierschnittstelle genutzt werden.
| |
| | |
| Unser Problem tritt bei dem Ladevorgang der Hardwarekonfiguration in die Baugruppe auf.
| |
| Es wird dann folgende Fehlermeldung ausgegeben:
| |
| | |
| Die Systemdaten können nicht auf die Baugruppe CPU 313C - (R0/S2) der Station SIMATIC 300(1) geladen werden.
| |
| Schauen Sie unter Details nach oder versuchen Sie die Ursache im Diagnosepuffer der Baugruppe zu ermitteln.
| |
| | |
| Die Hilfe-Angaben wurden bereits ausprobiert.
| |
| | |
| In der Anlage befindet sich auch der aktuelle Screenshot des Problems.
| |
| Das Problem taucht nur bei der Nutzung ohne SD-Karte auf.
| |
| Wenn eine SD-Karte eingesetzt wird, wird die Hardware nicht in dem Fenster "Teilnehmeradresse auswählen" erkannt."
| |
| | |
| == 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
| |
| | |
| Zum Programmieren wurde nach Schaltplan ein Versuchsaufbau generiert, damit erste Ergebnisse direkt erkannt und dokumentiert werden konnten.
| |
| | |
| [[Datei:Schaltplan dSpace-Gecko-Igus.jpg|500px|thumb|none|Schaltplan dSpace-Geckodrive-Schrittmotor]]
| |
| | |
| Pinbelegung am SubD-Stecker der Ausgabebox
| |
| | |
| [[Datei:Pinbelegung dSpace Panel.jpg|500px|thumb|none|Pinbelegung CP1104]]
| |
| | |
| === Regelkreis ===
| |
| | |
| Für diesen Anwendungsfall startet der Regelkreis mit dem Einlesen eines bestimmten Weges über eine RS232 Schnittstelle.
| |
| Dieser Wert ist der Sollwert der Position (Xsoll). Aus dieser Position wird durch die Programmierung auf dem dSpace Board ein PWM Signal erzeugt, welches eine bestimmte Anzahl an High-Pegeln an den Geckodrive sendet. Jeder High-Pegel steht für einen Schritt. Der Schrittmotor setzt diese Signale dann in 1.8° Schritte um und entlang der Linearachse wird ein Weg verfahren.
| |
| Ein Encoder soll dann diesen Weg durch Rückgabewerte zurücksenden, so dass ein kontinuierlicher Vergleich zwischen der Ist- und der Sollposition stattfinden kann, bis keine Regeldifferenz vorhanden ist.
| |
| | |
| [[Datei:Regelkreis_dSpace.jpg|500px|thumb|none|Regelkreis dSpace]]
| |
| | |
| === Starten einer Simulink Programmierung inkl. ControlDesk ===
| |
| | |
| Informationen zum Start einer Simulink Programmierung inkl. Anbindung von ControlDesk sind unter diesem Link zu finden: [[Datei:Start Simulink und ControlDesk.pdf|500px|thumb|none|Informationen zum Start von Simulink & ControlDesk]]
| |
| | |
| | |
| === 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.
| |
| | |
| Anschließend wird dieses Signal mit der aktuellen Position, welche in der Software hinterlegt ist, verglichen.
| |
| Der Relational Operator1 unterbricht bei Erreichen des Zielwertes die Verbindung zwischen dem Pulsgenerator und dem Digitalausgang für die Schritte. Dies geschieht durch ein Umschalten des Switch_Stop-Bausteins auf ein konstantes Low-Signal.
| |
| Der Relational 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.
| |
| | |
| Für die Positionsbestimmung ist im oberen rechten Bereich ein Zähler über ein getriggertes Subsystem realisiert worden. Je nach gefahrener Richtung wird pro Schritt, also pro High-Signal, ein Schritt addiert oder subtrahiert, so dass für jedes reale Signal am Schrittmotor auch ein Schritt im Memory-Baustein gespeichert wird. Der Ausgang dieses Bausteins wird dann wie beschrieben zum Ist-Soll-Vergleich genutzt.
| |
| | |
| Mit dem rechts dargestellten Scope können in der Simulink Simulation die Richtung, sowie die Ist- und die Sollpositionen dargestellt werden.
| |
| | |
| [[Datei:Programm dSpace Simulink.jpg|1000px|thumb|none|Programm dSpace Simulink]]
| |
| | |
| === ControlDesk Oberfläche ===
| |
| | |
| ControlDesk ist als Programm für die Visualisierung und Steuerung des Simulinkprogramms genutzt worden.
| |
| | |
| In dem Bild ist die erstellte Oberfläche dargestellt.
| |
| Oben ist ein Schieberegler für die Sollposition vorhanden. Links oben ist eine Anzeige der aktuellen Position in Schritten integriert (Labels/IstSchritte).
| |
| | |
| Darüber hinaus ist ein Plotter für den Vergleich der Ist- und der Sollschritte integriert worden.
| |
| | |
| Mit den Schiebereglern links unten kann man die Pulsweite und die Periodendauer variieren.
| |
| | |
| | |
| [[Datei:ControlDesk.jpg|1000px|thumb|none|ControlDesk Oberfläche]]
| |
| | |
| === PWM Signal zur Ansteuerung des Motors ===
| |
| | |
| Die Mindestperiodendauer, die der GeckoDrive benötigt um die einzelnen Schritte erkennen zu können beträgt 3,5 µs. In dem vorhandenen Simulinkprogramm ist bisher eine Periodendauer von 2 ms realisiert worden. Dieses Signal besteht aus 1 ms High- und 1 ms Low-Pegel.
| |
| | |
| | |
| [[Datei:PWM-Signal zur Motoransteuerung.JPG|500px|thumb|none|PWM-Signal zur Motoransteuerung]]
| |
| | |
| === Herausforderungen ===
| |
| | |
| Integration eines Zählers für die Erkennung der Ist-Position durch
| |
| * eine Matlab-Funktion
| |
| * einen Counter aus der DSP-Toolbox
| |
| * eine Eigenentwicklung (siehe Simulink Programm)
| |
| | |
| | |
| Spannungsabfall am Digitalausgang (von 5 V auf 1,77 V)
| |
| * Nutzung eines Netzteils
| |
| * Wechsel auf Analogausgang
| |
| * Kontakt zum dSpace Support wurde aufgenommen (ohne nutzbares Ergebnis)
| |
| | |
| | |
| Positioniergenauigkeit
| |
| *Datentyp double musste in Integer umgewandelt werden, um einen Vergleich möglich zu machen. Realisierung durch Simulink-Baustein (siehe Programm)
| |
| | |
| | |
| Historisch gewachsenes Programm
| |
| * zwischenzeitlich sehr unübersichliches Programm
| |
| | |
| === Ausblick ===
| |
| | |
| * Integration einer RS232-Schnittstelle
| |
| * Integration von Software-Endschaltern
| |
| * Integration einer Kalibrierfahrt
| |
| * Integration des Encoders
| |
| | |
| == 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. Im englischen Sprachgebrauch wird dabei häufig der Begriff I/O (Input/Output) verwendet.
| |
| | |
| Dabei ist die Handhabung ähnlich den Produkten Matlab Simulink oder LEGO Mindstorms BricX.
| |
| | |
| Grundbestandteile sind dabei unterschiedliche Funktionsbausteine, welche durch farbige Linien in der graphischen Programmieroberfläche miteinander logisch verknüpft werden können.
| |
| | |
| Der Vorteil der graphischen Programmierung ist, dass die Erkennung der Zusammenhänge von Variablen bzw. Werten durch Verfolgen der Verbindungslinien visuell sehr leicht möglich ist. So kann u.U. schneller ein Verständnis für die Grundaufgaben des Programmes erzielt werden, als wenn nur abstrakter Funktionscode betrachtet wird.
| |
| | |
| Nachteil der graphischen Programmierung ist, dass bei einem stark verschachtelten Aufbau die Übersichtlichkeit des Programmes leidet. In diesen Fällen kann u.U. die selbe Aufgabe mit einer schriftbasierten Programmiersprache (bspw. C) übersichtlicher gelöst werden.
| |
| | |
| In der Folge soll der Einsatz der Software in Verbindung mit einem Eingabe/Ausgabe-Controller anhand einer Ansteuerung eines Schrittmotors erläutert werden.
| |
| | |
| ====Regelkreis====
| |
| | |
| Vor der Realisierung in Hardware und Software wurde zunächst ein Regelkreis für die Ansteuerung des Schrittmotors entworfen. Für die Ansteuerung des Schrittmotors wird ein Motorcontroller des Typs Gecko Drive verwendet. Dieser übernimmt die leistungsseitige Ansteuerung des Motors. Der Motor bewegt eine Linearachse, deren Bewegung für eine Achse einer Bearbeitungsmaschine verwendet wird. Der NI Controller fungiert als Steuerteil des Aufbaus, indem die benötigten Signale an den Motorcontroller gesendet werden. Über einen Motorpositionssensor ist es möglich, die Bewegungen des Motors software-seitig 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.
| |
| | |
| [[Datei:Regelkreislabview.jpg]]
| |
| | |
| ====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 NI 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 (DIO = digital Input/Output) welche über einen Rechtsklick auf Mod1 konfiguriert werden können, d.h. die jeweiligen DIO´s können als Input oder Output definiert werden.
| |
| | |
| | |
| • Um potenzielle Fehler zu vermeiden, ist es sinnvoll den verwendeten Input bzw. Output direkt umzubenennen. Dazu muss lediglich doppelt auf die Bezeichnung des DIO (bspw. DIO20) im Projektexplorer geklickt werden und der gewünschte Name eingetragen und durch die Enter-Taste bestätigt werden.
| |
| | |
| | |
| [[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 wird durch einen Rahmen dargestellt, in den entsprechende Operationen eingefügt werden können. Der Inhalt des Rahmens entspricht dann dem Teil des Programmes, welches entsprechend der Laufzeit der Schleife wiederholt wird. Als Abbruchbedingung für die Schleife kann beispielsweise ein Bedienelement auf dem VI dienen oder es kann eine Laufzeit der Schleife analog zu anderen Programmiersprachen vorgegeben werden.
| |
| | |
| Eine Eingabemöglichkeit im VI, die dann auf das Programm im Blockdiagramm Einfluss nimmt, lässt sich folgendermaßen umsetzen: Man fügt zunächst ein Bedienelement im Blockdiagramm ein. Dieses erscheint dann 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". Die Funktion dieses Bausteins ist es, die entsprechenden Operationen, die in der Sequenz angegeben werden, zyklisch zu wiederholen. Nachdem der Baustein auf die Arbeitsfläche gefügt wird, besteht dieses Bauteil nur aus einer Sequenz in Form eines Rahmens. Da wir für die Ansteuerung des Schrittmotors jedoch zwei unterschiedliche Zustände (1/0) benötigen, kann man über ein Rechtsklick der Sequenz "einen Rahmen danach einfügen" wählen. Um die Zustände der jeweiligen Sequenz zu definieren, wird über "Programmierung" => "Boolesch" eine "True"- bzw. "False-Konstante" eingefügt. Die Länge der einzelnen Zustände werden über Wartezeiten ("Warten auf ein Vielfaches von…") bestimmt ("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 VI Einfluss auf diese Zeiten und damit die Fahrgeschwindigkeit des Schrittmotors genommen werden kann, ist ein Regler einzufügen, welcher außerhalb der „flachen Sequenzen“ liegt. Dieser kann mit beiden Warteelementen verbunden werden, da die Wartezeiten beider Zustände immer identisch sein sollte. (High- / Low-Flanken jeweils 50%)
| |
| | |
| [[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 VI 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 VI zu bedienen ist, in das Blockdiagramm eingefügt werden. Für die Übergabe des Signals an die Hardware ist der jeweilige DIO-Port (Hier DIO-1) aus dem Projekt-Explorer in das bestehende Programm zu involvieren. Da dies eine einmalige Abfrage beim Start des Programmes ist, ist der Befehl außerhalb der While-Schleife zu positionieren. Je nach Schaltlage gibt dieser ein Highpegel(5V) oder Lowpegel (0V) an den zuvor definierten Output des NI Controllers, welcher mit dem Input "Direction" des Gecko Drive verbunden ist. Damit ist die Drehrichtung des Motors definiert. In diesem Beispiel wird mittels LED´s die aktuell gefahrene Richtung visualisiert.
| |
| | |
| [[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. 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 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“. 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 and 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]] | |
| | |
| =====Einbindung der automatischen Richtungsänderung in Abhängigkeit der Absolutposition=====
| |
| | |
| Mittels eines Vergleichs von der aktuellen Absolutwertposition und des Vorgabewertes wird die Richtung ermittelt, in die der Schrittmotor verfahren muss. Ist der Vorgabewert größer als der Absolutwert, hat die boolsche Variable (Data) den Zustand "true". Im anderen Fall wird der Zustand auf "false" gesetzt. Eine Case-Struktur sorgt zustandsabhängig für eine Addition bzw. Subtraktion der Werte von Verfahrweg und Absolutposition. Nach jeder Rechenoption wird der Wert der Variable (abs_pos) überschrieben und kann über ein Anzeigeelement im Host-VI dargestellt werden.
| |
| | |
| | |
| [[Datei:directioncase.jpg]]
| |
| | |
| =====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. Bei Unterschreitung dieser kritischen Periodendauer war kein klar definiertes Ausgangssignal mehr zu erkennen. Die Folge war ein ebenso undefiniertes Verhalten des Schrittmotors. 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.
| |
| | |
| '''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.
| |
| | |
| '''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 seriell übertragen werden. Es wurde sich entschieden eine definierte Zahlen/Buchstabenfolge (String) zu übertragen.
| |
| 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. Beispielsweise muss die Z-Achse den String auf den Buchstaben "Z" hin durchsuchen. Ist der Buchstabe gefunden, wird die folgende Folge von Ziffern eingelesen und in eine Variable geschrieben, welche die Absolutposition der Z-Achse vorgibt. Nach Einlesen des Buchstaben E (E = Ende des Strings) kann die Achse daraufhin mit dem Anfahren der Sollposition geginnen.
| |
| | |
| == Zentraler Steueralgorithmus ==
| |
| === Aufgabenstellung ===
| |
| Die Aufgabe des Steuerungsalgorithmus soll es sein, aus einer CAM-Datei die benötigten Informationen zu lesen um damit Sollbahnen des Fräsers zu generieren und die Achsen der Maschine so anzusteuern, dass das CAD-Modell Maßstabsgetreu erzeugt wird.
| |
| | |
| Um den Umfang der Aufgabe übersichtlicher zu machen haben wir die Aufgabe in fünf Phasen unterteilt.
| |
| | |
| * In Phase eins soll eine manuelle Verfahrweise der Maschine erstellt werden, um einen ersten Einstieg zu bekommen und den möglichen Signalfluss zu testen. Dazu sollen von Hand die Koordinaten jeder Achse eingestellt und diese dann auf einen Befehl an die Maschine gesendet werden. Dies soll als Grundgerüst für alle weiteren Arbeiten an dem Steuerungsalgorithmus dienen.
| |
| * Wenn das Versenden einzelner Koordinaten gelingt, wird in Phase zwei die Umsetzung einer mit Excel erstellten Probesollbahn angestrebt. Hier soll ein möglichst schnelles Versenden der Koordinaten an die Maschine erreicht werden.
| |
| * In Phase drei werden die Sollbahnen aus einer CAM-Datei generiert. Die Datei soll mit Hilfe von Matlab eingelesen werden. Der Inhalt muss vom Steuerungsalgorithmus immer richtig interpretiert werden, um ein maßstabsgetreues Erzeugnis zu erhalten.
| |
| * Wenn die Sollbahngenerierung funktioniert, müssen die Werkzeuge der Maschine (Frässpindel, Werkzeugmagazin) noch in den Steuerungsalgorithmus eingebunden werden. Es muss während des Bearbeitungsvorgangs unterschieden werden, ob der Fräser momentan im Eingriff ist oder nicht. Dies geschieht in Phase vier.
| |
| * Sollten diese Funktionen alle gegeben sein, wird in Phase fünf die komplette Automatisierung der Maschine angestrebt. Es muss dabei eine Überwachung der Achsen (Position erreicht/nicht erreicht, Störungen, …) eingebunden werden. Darüber hinaus müssen auch alle Endschalter und sonstige Sicherheitseinrichtungen mit in der Überwachung eingebunden werden.
| |
| | |
| === Manuelle Verfahrweise ===
| |
| In den Überlegungen zur manuellen Ansteuerung der Achsen wurden verschiedene Methoden angedacht. Es gab die Idee, mit Hilfe eines Arduinos drei analoge Eingänge an denen je ein Potenziometer angeschlossen ist einzulesen. Die eingelesenen Werte repräsentieren dabei je eine Koordinate. Diese wären dann zu der definierten Koordinatenform (z.B. x00100y00125z00045e) zusammengefasst worden und als String über die serielle Schnittstelle an die Achsen versendet worden. Diese Idee wurde aber wegen mangelnder Flexibilität für spätere Aufgaben verworfen.
| |
| | |
| Für die manuelle Verfahrweise haben wir uns für eine mit Matlab erstellte grafische Benutzeroberfläche entschieden. Diese bietet den Vorteil, eines sehr einfachen Aufbaus. Es wird lediglich ein USB- Kabel für die Verbindung des PCs mit der entsprechenden Hardware an der Maschine benötigt.
| |
| | |
| [[Datei:Manuell_GUI_Ablauf.gif|200px|thumb|Ablaufprinzi der grafischen Benutzeroberfläche]]
| |
| | |
| Beim Start der grafischen Benutzeroberfläche wird mit einem Mausklick auf einen Pushbutton die serielle Kommunikation zwischen PC und der Hardware der Maschine gestartet. Danach kann mit der Maus über drei Slider Die gewünschte Koordinate eingestellt werden. Diese wird zu Kontrolle der eigenen Einstellungen in einem Schriftfeld angezeigt. Durch einen Mausklick auf einen zweiten Pushbutton wird aus den drei einzelnen Koordinaten die oben erwähnte Koordinatenform gebildet und dieser String dann über die serielle Schnittstelle an die Achsen gesendet. Dieser Vorgang kann beliebig oft wiederholt werden. Mit einem Mausklick auf einen dritten Pushbutton wird die serielle Kommunikation mit den Achsen gestoppt und die grafische Benutzeroberfläche geschlossen.
| |
| | |
| === Handhabung der grafischen Benutzeroberfläche ===
| |
| Für den Gebrauch der grafischen Benutzeroberfläche (GUI) müssen folgenden Vorraussetzungen erfüllt sein.
| |
| | |
| * Für eine serielle Verbindung müssen beide Geräte eingeschaltet sein.
| |
| * Der PC muss über ein USB- Kabel mit der Achssteuerung an der Maschine (z.B. Arduino Mega) verbunden sein.
| |
| * Der entsprechende COM- Port an dem die Achsteuerung angeschlossen ist, muss mit dem zu öffnenden COM- Port im Quellcode der GUI übereinstimmen. Die Nummer des COM- Ports kann im Gerätemanager des PCs eingesehen werden.
| |
| | |
| Wenn diese Bedingungen erfüllt sind kann eine serielle Kommunikation zwischen PC und Achssteuerung hergestellt werden.
| |
| | |
| | |
| [[Datei:GUI_Aufbau_inaktiv.gif|200px|thumb|Aufbau der grafischen Benutzeroberfläche nach dem Öffen.]]
| |
| | |
| Um die GUI zu öffnen, muss die entsprechende Matlab- Funktion unter der die GUI ausgeführt wird mit dem Befehl „run Dateiname“ im Command window von Matlab oder mit dem Runbutton direkt aus dem Editor von Matlab aufgerufen werden.
| |
| | |
| Nach dem Aufruf der Datei öffnet sich die GUI. Die GUI ist in drei Bereiche unterteilt.
| |
| | |
| * Im oberen Bereich befinden sich zwei Pushbutton zum Starten und Stoppen der seriellen Kommunikation bzw. schließen der GUI.
| |
| * Im mittleren Bereich befinden sich drei Slider für das manuelle Einstellen der Koordinaten der drei Achsen. Rechts neben den Slidern befindet sich auf gleicher Höhe je ein Schriftfeld, welche die aktuell eingestellt Koordinate anzeigt.
| |
| * Im unteren Bereich der GUI befindet sich ein weiterer Pushbutton, der bei einer Betätigung durch einen Mausklick die eingestellten Koordinaten an die Achsen der Maschine sendet.
| |
| | |
| Bevor eine Koordinate eingestellt und zur Maschine geschickt werden kann, muss die serielle Kommunikation gestartet werden. Dazu genügt ein Mausklick auf die grüne Schaltfläche mit der Aufschrift „Start“.
| |
| | |
| [[Datei:GUI_Aufbau_aktiv.gif|200px|thumb|Aufbau der grafischen Benutzeroberfläche nach erfolgreich hergestellter Verbindung mit der Achssteuerung.]]
| |
| | |
| Nach einer vom Programm vorgegebenen Wartezeit zum Verbinden der Kommunikationspartner und zur Initialisierung der Achssteuerung werden die vorher ausgeblendeten Slider nun angezeigt. Mit einem Mausklick auf die Pfeile an den Enden der Slider kann der Wert um +1 oder -1 verstellt werden. Mit einem Mausklick rechts oder links vom Balken auf dem Slider kann der Wert um +100 bzw. -100 verstellt werden. Der Wert der Slider kann aber auch per drag and drop mit der Maus über die gesamte Breite der Slider verstellt werden.
| |
| | |
| Nachdem die Koordinaten eingestellt sind, können mit einem Mausklick auf der blauen Schaltfläche mit der Aufschrift „senden“ die Koordinaten an die Maschine verschickt werden.
| |
| | |
| | |
| '''Achtung:'''
| |
| | |
| Wenn der/die Benutzer/in die GUI nicht mehr verwenden möchte, so muss die GUI unbedingt mit einem Mausklick auf der roten Schaltfläche mit der Aufschrift „Stop“ beendet werden. Damit wird nicht nur die GUI geschlossen, sondern auch die Verbindung zu der Achssteuerung ordnungsgemäß getrennt.
| |
| | |
| === Matlab Quellcode der grafischen Benutzeroberfläche ===
| |
| | |
| Die grafische Benutzeroberfläche (GUI) ist als eigene Matlabfunktion geschrieben worden. Die wichtigsten Inhalte im Quellcode werden hier Stück für Stück von oben nach unten erläutert.
| |
| | |
| Am Anfang der Funktion werden die üblichen Befehle zum Löschen von Variablen, Schließen von offenen Fenstern und Bereinigen des Commandwindows ausgeführt. Danach werden drei Variablen angelegt, die den Wertebereich der Slider in der GUI festlegen.
| |
| | |
| <pre>%Einstellen des Wertebereichs der Slider
| |
| Max_Slider_x = 1000;
| |
| Max_Slider_y = 1000;
| |
| Max_Slider_z = 200;
| |
| </pre>
| |
| | |
| In folgenden Schritt werden die Varialblen "s" und "f" angelegt. "s" stellt hier die die Varialble für die serielle Kommunikation und "f" die Variable der aktuellen figure dar.
| |
| | |
| <pre>%Definition des COM-Ports und der Größe und Position der figure
| |
| s = serial('COM7','baudrate',9600);
| |
| f = figure('Visible','off','Position',[360,500,500,400],'NumberTitle','off');
| |
| </pre>
| |
| Der Befehl '''serial('COM7','baudrate',9600);''' stellt die serielle Konmmunikation auf den COM-Port "COM7" mit einer Übertragungsrate von 9600 Bits pro Sekunde ein.
| |
| | |
| Der Inhalt der Klammer hinter '''figure''' stellt die Parameter für das Fenster der GUI ein. Es bleibt beim Start der Funktion noch unsichtbar, die Postion der linken unteren Ecke des Fensters wird auf Pixel 360 vom linken Bildrand und 500 vom unteren Bildrand eingestellt, die Größe des Fensters wird mit 500 x 400 Pixel definiert und die Nummer in der Titelzeile des Fensters wird ausgeschaltet.
| |
| | |
| | |
| Die nun folgenden Zeilen im Quellcode sind lediglich Kosmetik für die GUI. Ihr Größter Nutzen besteht darin das Fenster sauber in drei Bereiche mit eigener Überschrift zu unterteilen.
| |
| <pre>
| |
| %Panel für Slider, Anzeige und Beschriftungen
| |
| %Panel_1 stellt die Bedienelemente für die Sollwertvorgabe bereit
| |
| %Panel_2 stellt die Bediebelemente zum Starten und Stoppen der Seriellen
| |
| %Kommunikation bereit
| |
| %Panel_3 stellt den Pushbutton zum senden der Koordinaten an die Serielle
| |
| %Schnittstelle bereit.
| |
| | |
| Panel_1 = uipanel('Title','Sollwertvorgabe','Position',[0 .33 1 .33]);
| |
| Panel_2 = uipanel('Title','Kommunikation Starten/Stoppen','Position',[0 .66 1 .33]);
| |
| Panel_3 = uipanel('Title','Koordinaten senden','Position',[0 0 1 0.33]);
| |
| </pre>
| |
| Die Variablen "Panel_1", "Panel_2" und "Panel_3" werden mit dem Befehl '''uipanel''' zu farblich vom Hintergrund abgehobenen Flächen mit eingenem Titel, definierter Größe und Position im Fenster.
| |
| | |
| Als Nächstes folt der Aufbau einer der wichtigsten Komponenten der GUI. Hier werden die Slider für die Einstellung der Sollwerte bzw. der Soll-Koordinaten aufgebaut.
| |
| | |
| Der Aufbau erfolgt, indem einer Variablen mit dem Befehl '''uicontrol''' ein neues Bedienelement zugeordnet wird. Die Parameter in der Klammer dahinter haben folgende Bedeutung:
| |
| | |
| * Mit dem Parameter ''' 'Parent' ''' wird jeweils eines der oben angelegten Panels ausgewält. Damit bleibt der Slider immer innerhalb dieses Panels.
| |
| * Der Parameter ''' 'Style' ''' mit dem nachfolgenden Befehl ''' 'slider' ''' bewirkt, dass das Bedienelement als Slider angelegt wird.
| |
| * Mit dem Parameter ''' 'String' ''' wird der Titel des Bedienelements festgelegt. In diesem Fall "XYZ-Achse".
| |
| * Mit dem Parameter ''' 'Position' ''' wird die Position im Panel und die Größe des Sliders bestimmt.
| |
| * Die Parameter ''' 'Min' ''' und ''' 'Max' ''' stellen den Wertebereich der Silder ein. Für den Maximalwert der Slider ist die ober angelete Variable wiederzufinden.
| |
| * Mit dem Parameter ''' 'SliderStep' ''' wird eingestellt wie die Wertänderung der Slider bei Betätigung der Pfeile und beim Klicken neben dem Balken ablaufen soll.
| |
| * Der Parameter ''' 'Callback' ''' definiert den Namen der Funktion, die ausgeführt werden soll, wenn eine Wertänderung am Slider vorgenommen wird.
| |
| <pre>
| |
| %Aufbau der Slider
| |
| Achse_x = uicontrol('Parent',Panel_1,'Style','slider','String','X-Achse',...
| |
| 'Position',[100,80,300,20],...
| |
| 'Min',0,'Max',Max_Slider_x,...
| |
| 'SliderStep',[0.001 0.1],...
| |
| 'Callback',{@achse_x_callback});
| |
| | |
| Achse_y = uicontrol('Parent',Panel_1,'Style','slider','String','Y-Achse',...
| |
| 'Position',[100,50,300,20],...
| |
| 'Min',0,'Max',Max_Slider_y,...
| |
| 'SliderStep',[0.001 0.1],...
| |
| 'Callback',{@achse_y_callback});
| |
| | |
| Achse_z = uicontrol('Parent',Panel_1,'Style','slider','String','Z-Achse',...
| |
| 'Position',[100,20,300,20],...
| |
| 'Min',0,'Max',Max_Slider_z,...
| |
| 'SliderStep',[0.001 0.1],...
| |
| 'Callback',{@achse_z_callback});
| |
| </pre>
| |
| | |
| Es folgen weitere Bedienelemente und Anzeigen die in Ähnlicher Weise wie die Slider aufgebaut und parametriert werden. Diese Elemente dienen der besseren Übersicht und zur Visualisierung der eingestellten Werte an den Slidern.
| |
| <pre>%Aufbau der Beschriftungen der Slider
| |
| text_1 = uicontrol('Parent',Panel_1,'Style','Text','String','X-Achse',...
| |
| 'Position',[25,80,60,20]);
| |
| | |
| text_2 = uicontrol('Parent',Panel_1,'Style','Text','String','Y-Achse',...
| |
| 'Position',[25,50,60,20]);
| |
| | |
| text_3 = uicontrol('Parent',Panel_1,'Style','Text','String','Z-Achse',...
| |
| 'Position',[25,20,60,20]);
| |
| | |
| %Aufbau der Koordinatenanzeige
| |
| Koor_x = uicontrol('Parent',Panel_1,'Style','Text','String','',...
| |
| 'Position',[420,80,50,20],...
| |
| 'BackgroundColor','w');
| |
| | |
| Koor_y = uicontrol('Parent',Panel_1,'Style','Text','String','',...
| |
| 'Position',[420,50,50,20],...
| |
| 'BackgroundColor','w');
| |
| | |
| Koor_z = uicontrol('Parent',Panel_1,'Style','Text','String','',...
| |
| 'Position',[420,20,50,20],...
| |
| 'BackgroundColor','w');
| |
| </pre>
| |
| | |
| Die nun folgenden Bedienelemente werden zum Starten bzw. Stoppen der seriellen Kommunikation und zum Senden der Koordinate verwendet. Es werden hier für jede Funktion jeweils ein Pushbutton angelegt. Die Parametrierung erfolgt auf ähnliche Weise wie oben beschrieben.
| |
| <pre>%Aufbau der Bedienelemente zum Starten und Stoppen der Seriellen
| |
| %Kommunikation
| |
| Starten = uicontrol('Parent',Panel_2,'Style','Pushbutton','String','Start',...
| |
| 'Position',[25,30,100,50],...
| |
| 'BackgroundColor','green','FontWeight','bold','FontSize',10,...
| |
| 'Callback',{@starten_callback});
| |
| | |
| Stoppen = uicontrol('Parent',Panel_2,'Style','Pushbutton','String','Stop',...
| |
| 'Position',[150,30,100,50],...
| |
| 'BackgroundColor','red','FontWeight','bold','FontSize',10,...
| |
| 'Callback',{@stoppen_callback});
| |
| | |
| %Aufbau des Pushbuttons zum Senden der Koordinaten an die Serielle
| |
| %Schnittstelle.
| |
| Senden = uicontrol('Parent',Panel_3,'Style','Pushbutton','String','senden',...
| |
| 'Position',[25,30,100,50],...
| |
| 'BackgroundColor',[0.5 0.7 1],'FontWeight','bold','FontSize',10,...
| |
| 'Callback',{@senden_callback});
| |
| </pre>
| |
| | |
| | |
| Nach dem Aufbau der Bedienelemente wird die GUI nun Initialisiert. Dazu wird mit dem Befehl '''set''', einem Vektor mit den benötigten Varialbel als Inhalt, einem Parmeter z.B. ''' 'Units' ''' und dem dazugehören Wert (hier ''' 'normalized' ''') die aktuellen Eigenschaften der Bedienelemente verändert.
| |
| <pre>%Initialisierung der GUI
| |
| set([f,Panel_1,Achse_x,Achse_y,Achse_z,...
| |
| text_1,text_2,text_3,...
| |
| Koor_x,Koor_y,Koor_z,...
| |
| Starten,Stoppen,...
| |
| Senden],...
| |
| 'Units','normalized');
| |
| | |
| set(f,'Name','Sollwertvorgabe mit Slider')
| |
| | |
| movegui(f,'center')
| |
| | |
| set(f,'Visible','on');
| |
| set(Achse_x,'Visible','off');
| |
| set(Achse_y,'Visible','off');
| |
| set(Achse_z,'Visible','off');
| |
| set(Senden,'Visible','off');
| |
| </pre>
| |
| Die weiteren Funktionen der Befehle sorgen dafür, dass das Fenster sichtbar ist und sich in der Mitte des Monitors befindet ('''movegui'''), dass das Fenster einen Namen bekommt und dass die Slider unsichtbar sind (zu welche Zweck wird später erklärt).
| |
| | |
| | |
| | |
| In den nun folgenden Zeilen befinden sich die Callback-Funktionen der Slider, des Startbuttons und des Stopbuttons. Jede Callback-Funktion ist wie eine normale Funktion in Matlab aufbebaut. Sie starten mit '''function''', dem Funktionsnamen und den Inputargumenten in Klammern dahinter. Da es sich hier um Callback-Funktionen von Bedienelementen einer Benutzeroberfläche handelt, müssen als Inputargumente '''source''' und '''eventdata''' eingetragen werden um die Funktion zu ermöglichen. Das Inputargument '''source''' repräsentiert dabei die Werte des Sliders.
| |
| | |
| Innherhalb der Callback-Funktionen der Slider wird mit dem Befehl '''get''' aus '''source''' der aktuelle Wert des Sliders entnommen. Dieser Wert wird standardmäßig als Datentyp double ausgeführt. Da wir aber ausschließlich mit positven ganzen Zahlen arbeiten wollen, wir dieser Wert in einen 16 bit integer umgewandelt. Dieser wird anschließend von einer Zahl in einen String umgewandelt. Der Zahlenwert wird zu Schluss der Callback-Funktion in dem neben dem Slider befindlichen Schriftfeld angezeigt.
| |
| | |
| Die Callback-Funktion des Startbuttons bewirtkt bei Ausführung, dass die seielle Schnittstelle mit '''fopen(s)''' ge
| |
| | |
| == 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.
| |
| | |
| [[Datei:Portalfest.png]]
| |
|
| |
| 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 stabil ausgeführt werden muss, als dies bei einem feststehenden Portal nötig wäre. Besonders die Anbindung des Portals an die Linearführungen muss verwindungssteif erfolgen. nach Möglichkeit ist das Portal nur so hoch zu wählen, wie für den späteren Einsatzzweck zwingend notwendig. Durch eine Verringerung der Portalhöhe ergibt sich ein kürzerer Hebelarm und damit ein geringeres Drehmoment auf die Linearachsen.
| |
| 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.
| |
| | |
| [[Datei:Portalfahrbar.png]]
| |
| | |
| === 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.
| |
| | |
| | |
| [[Datei:Montage24.png]]
| |
| | |
| | |
| [[Datei:Montage23.png]]
| |
| | |
| === Ausblick ===
| |
| | |
|
| |
|
| Im Rahmen des Praktikums Produktionstechnik WS2013/2014 konnte die 3D-Bearbeitungsmaschine fertig auskonstruiert werden. Außerdem wurde mit dem Aufbau begonnen, welcher zu 80% fertiggestellt ist. Die Endschalter für die einzelnen Achsen müssen noch montiert werden. Außerdem müssen die Motorleitungen verlängert und an die Steuerung angeschlossen werden. Das Verdrahten der Steuerung ist ebenfalls noch zu erledigen.
| | = 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]] |
|
| |
|
| Nach Fertigstellung der Montagearbeiten und einem erfolgreichen Umzug in die finalen Räumlichkeiten müssen die einzelnen Achsen rechtwinklig zueinander ausgerichtet werden. Dazu ist weiteres Messequipment notwendig (Fühlhebelmessgerät, Messstativ, Flachwinkel DIN875-II, Fühlerlehrenband).
| | =Fachthemen für die Kleingruppen = |
|
| |
|
| Der nachfolgende Link führt zur Aufbauanleitung der Fräsmaschine "GP10050" der Firma Auracher Lasertechnik. Die Kapitel 5 und 6 (ab S.44ff) zeigt dabei das Ausrichten dieser Maschine und können analog auf die HSHL-Bearbeitungsmaschine übertragen werden.
| | ==Ansteuerung:== |
|
| |
|
| http://auracher-lasertechnik.de/Forum/GP10050/Bauanleitung_Mechanik_GP10050.pdf
| | *[[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)]] |
|
| |
|
| == Broadcast mit der RS232-Kommunikationsschnittstelle == | | ==Konstruktion:== |
| [[Boradcast mit RS232]] | | *[[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)]] |
| | *[https://www.igus.de/energieketten/wiki/montage/grosse-energieketten igus Energiekette Montageanleitung] |
|
| |
|
| =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/] |
| | * Tolle Aufstellung G-Codes: |
| | ** https://www.maschinfo.de/CNC-G-Code |
| | ** https://www.machiningdoctor.com/gcodes/ |
| | ** https://www.rapiddirect.com/de/blog/g-and-m-codes/ |
| | * "open-hardware"-Projekt [http://www.shapeoko.com/wiki/index.php/Main_Page] |
| | * Tipps fürs die Holzverarbeitung [https://www.holzwerken.net/tipps-tricks] |
