Ansteuerung einer Schrittmotor-Achse mit Mikrocontrollern am Beispiel eines Arduino-Mega: Unterschied zwischen den Versionen
| Zeile 293: | Zeile 293: | ||
Drei davon senden die Schrittsignale für die drei Achsen an die Schrittmotortreiber. Dabei handelt es sich um Rechtecksignale, das zwischen High (5V) und Low (0V) schaltet. Die Dauer eines Pulses entscheidet über die Drehgeschwindigkeit der Motoren. Je kürzer ein Puls, desto schneller fährt der Motor. <br/> | Drei davon senden die Schrittsignale für die drei Achsen an die Schrittmotortreiber. Dabei handelt es sich um Rechtecksignale, das zwischen High (5V) und Low (0V) schaltet. Die Dauer eines Pulses entscheidet über die Drehgeschwindigkeit der Motoren. Je kürzer ein Puls, desto schneller fährt der Motor. <br/> | ||
Zur Vorgabe der Drehrichtung werden drei weitere digitale Ausgänge des Arduinos genutzt. Ein Low-Signal lässt den Motor im Uhrzeigersinn fahren, ein High-Signal gegen den Uhrzeigersinn. | Zur Vorgabe der Drehrichtung werden drei weitere digitale Ausgänge des Arduinos genutzt. Ein Low-Signal lässt den Motor im Uhrzeigersinn fahren, ein High-Signal gegen den Uhrzeigersinn. | ||
Version vom 7. Januar 2020, 08:43 Uhr
Zurück zum übergeordneten Projekt: 3-D-Bearbeitungsmaschine (Projekt des Schwerpunkts GPE im Studiengang MTR)
Kategorie: 2019/ 2020_WS_MTR7_Praktikum_GPE
Autoren: Felix Bruchhage, Leon Lieshek
Einleitung
Das Modul Global Production Engineering 3 im 7. Semester des Studiengangs Mechatronik beinhaltet das Praktikum Produktionstechnik. Dabei soll den Studierenden ein Einblick in die praktische Automatisierungstechnik gegeben werden. Die Praktikumsaufgabe ist Teil des Hauptprojektes „Aufbau einer 3-D-Bearbeitungsmaschine“ und beinhaltet die Ansteuerung von 3 CNC Achsen mit Hilfe des Microcontrollerboards Arduino Mega.
Im Jahrgang 2016/ 2017 wurden Teile des Projekts von Kuete Tetsop Anicet bearbeitet mit der Aufgabe eine Schrittmotor-Achse anzusteuern. Im Jahrgang 2019/ 2020 wird das Projekt von Felix Bruchhage und Leon Lieshek übernommen und auf die simultane Ansteuerung von drei Schrittmotor-Achsen erweitert.
Dazu wurden die folgenden Anforderungen als Aufgabe gestellt:
Aufgabenstellung
Die Aufgabe des Teilprojektes war es, drei Achsen der selbstgebauten CNC-Bearbeitungsmaschine mit Hilfe eines Arduino Mega 2560 Microcontrollerboards anzusteuern. Die drei Achsen werden von Igus Nema 23 Schrittmotoren angetrieben, die mit jeweils einem Geckodrive G201X Schrittmotortreiber gesteuert werden.
Die anzufahrenden Koordinaten werden durch einen zentralen Steuerungsalgorithmus mit der Software MATLAB aus dem G-Code des CAD/ CAM-Programms in Form eines Strings an den Microcontroller gesendet. Es sind grundsätzlich zwei Arten von Strings zu unterscheiden. Das Muster „U1000V1000W1000“ stellt eine Referenzposition dar. Diese gibt die Position des Fräsers zu Programmstart an und bildet eine absolute Position von Koordinaten-Ursprung der Fräsmaschine. Eine Anfahrtsposition wird nach dem Muster „X1111Y2222Z3333F4444" übermittelt. Auch sie enthält die Absolutkoordinaten des Zielpunktes, auf den der Fräser gefahren werden soll. Zusätzlich wird eine Verfahrgeschwindigkeit, der sogenannte Vorschub (F) in mm/min angegeben.
Zu Beginn der Aufgabenbearbeitung wurden folgende Projektanforderungen aufgestellt:
• Aufbau/ Hardware
- Schaltpläne erstellen mit den verwendeten Komponenten und Schnittstellen definieren
- Gehäuse für Arduino und Platine entwickeln und herstellen (Zugänglichkeit der Schnittstellen RS232, Spannungsversorgung, D-Sub-Stecker vorsehen)
- Kommunikationsschnittstelle mit D-Sub-Stecker kurzschlusssicher umsetzen (in Gehäuse integriert)
- Verdrahtung nach Schaltplan zwischen Arduino und D-Sub-Stecker
• Software
- String einlesen über RS232-Schnittstelle
- Unterscheidung zwischen Referenz- und Anfahrkommando
- Zahlenwerte für Positionen und Vorschub aus String extrahieren
- Umrechnung von absoluten Positionswerten in inkrementale Verfahrwege
- Umrechnung von Positionswerten [mm] in Schrittwerte zur Übergabe an Schrittmotortreiber
- Ableitung von relativen Geschwindigkeiten für alle drei Achsen in Abhängigkeit der Verfahrwege und Vorschubgeschwindigkeit
- Übergabe von Schritt- und Richtungswerten an die drei Schrittmotortreiber
- Simultane Ansteuerung von drei Motoren
• Funktionstest
- Verdrahtung zwischen Arduino und Schaltschrank prüfen
- Einlese- und Umrechnungs-Funktionen der Strings testen
- Verfahrtests mit verschiedenen Stings und Genauigkeit bestimmen
- Kommunikation zwischen Matlab-Steuerungsalgorithmus testen
- Finaler Test an der Maschine
Technologien
Hardware
Microcontroller: Arduino Mega 2560
| Microcontroller | ATmega2560 |
| Betriebsspannung | 5V DC |
| Eingangsspannung (empfohlen) | 7-12V DC |
| Eingangsspannung (Grenzwerte) | 6-20V DC |
| maximale Stromaufnahme | 500 mA |
| maximaler Strom je In-/ Output Pin | 40 mA |
| maximaler Strom des 3,3V Pins | 50 mA |
| Flash Speicher | 256 KB (8 KB genutzt durch Bootloader) |
| SRAM | 8 KB |
| EEPROM | 4 KB |
| Analoge Eingänge | 16 |
| Digitale Pins | 54 (konfigurierbar als In- oder Outputs), 14 als PWM-Outputs konfigurierbar |
| Anschlüsse | USB, serielle Schnittstelle, Spannungsversorgung |
Weitere Daten zum Arduino Mega 2560 Mikrocontroller: [1]
Schrittmotortreiber: GeckoDrive G201X
| Eingangsspannung | 18-80 VDC |
| maximale Stromaufnahme des angeschl. Motors | 7 A |
| Induktivität des Motors | 1-50 mH |
| Eingangsfrequenz des Step-Input | 0-200 kHz |
| Spannung der Inputs | 3,3-5 VDC |
| Inputs | Spannungsversorgung, Disable, Direction, Step, Common, Current Set |
| Outputs | Winding A+B (1 Schrittmotor) |
Datenblatt Geckodrive G201X Schrittmotortreiber: Datei:Betriebsanleitung Schrittmotortreiber.pdf
Schrittmotor: Igus NEMA 23
| Nennspannung | 24-48 V DC |
| max. Eingangsspannung | 60 V DC |
| Nennstrom | 4,2 A |
| Haltemoment | 2,0 Nm |
| Schrittwinkel | 1,8° |
| Widerstand pro Phase | 0,5 Ω ± 10% |
| Induktivität pro Phase | 1,9 mH ± 20% |
| Pin 1 | Signal A/ (braun) |
| Pin 2 | Signal A (weiß) |
| Pin 3 | Signal B/ (blau) |
| Pin 4 | Signal B (schwarz) |
| Pin 5 | PE |
| optionale Bauteile | Encoder, Bremse |
Datenblatt Igus Nema23 Schrittmotor: Datei:Motordatenblatt DE.pdf
Software
• Arduino IDE
Die Arduino IDE (Integrated Development Environment) ist eine kostenfreie Programmierumgebung zur Erstellung von Anwendungen für Arduino Mikrocontroller. Die Programmiersprache ist angelehnt an C und C++ mit einigen speziellen Anforderungen an die Struktur. Zusätzlich zur eigentlichen Programmierungen werden Bibliotheken angeboten, die viele Softwareprobleme bereits abdecken und Funktionen bereitstellen.
• HTerm
Die kostenfreie Software HTerm ermöglicht eine serielle Kommunikation über die RS232-Schnittstelle. Mit dieser wurde die serielle Schnittstelle eingerichtet und auf Ihre Funktion geprüft. Das Senden eines Strings an den Arduino ist ebenfalls mit der IDE möglich. Der Funktionstest wurde allerdings mit dieser Software durchgeführt, um sicherzustellen, dass die Kommunikation auch über ein externes Programm ohne Komplikationen funktioniert.
• Fritzing
Firtzing ist eine freie Software der Fachhochschule Potsdam, die es ermöglicht elektronische Schaltungen am Computer zu entwerfen. Dazu stehen viele vorkonfigurierte Bauteile zur Verfügung, die durch eigen erstellte Bauteile ergänzt werden können. Das Sortiment ist primär auf die Arduino-Plattform abgestimmt, sodass speziell Arduino-Projekte einfach dokumentiert werden können. Insgesamt stehen drei verschiedene Entwicklungsansichten zur Verfügung (Steckplatine, Schaltplan und Platine). In diesem Projekt wurde die Schaltplanansicht ausgewählt.
Funktionaler Systementwurf
Der funktionale Systementwurf dient dazu, um die Struktur des Systems lösungs- und hardwareneutral zu ermitteln. Zunächst wurde eine Gesamtübersicht der gesamten CNC-Bearbeitungsmaschine erstellt.
Das erstellte CAD-Modell wird in ein CAM-Programm eingeladen, das aus dem Volumenkörper Verfahrbefehle in Form von G-Code erzeugt. Mit dem Steuerungsprogramm wird dieser in Positionswerte für die X-, Y- und Z-Achsen und in Vorschubgeschwindigkeiten umgerechnet. Diese Strings erhält der Achs-Controller, um die Schrittmotortreiber und schließlich die Achsen anzusteuern.
Im Detail für den Achscontroller ergibt sich folgender Entwurf:
Technischer Systementwurf
Der technische Systementwurf detailliert die Systemübersicht dahingehend, dass die Schnittstellen der einzelnen Komponenten definiert werden:
Hier ist zu erkennen, dass der String als Systeminput über die serielle RS-232 Schnittstelle des Arduino Mega 2560 übergeben wird. Dieser bildet das Herzstück des Achscontrollers, verarbeitet die Eingaben und steuert die Schrittmotoren an. Zur Ansteuerung werden insgesamt 6 digitale Ausgänge des Microcontrollers benötigt. Die Verbindung zwischen Arduino und Schaltschrank, bzw. Eingängen der Schrittmotortreiber, wird über den 25-poligen D-Sub-Stecker hergestellt.
Drei davon senden die Schrittsignale für die drei Achsen an die Schrittmotortreiber. Dabei handelt es sich um Rechtecksignale, das zwischen High (5V) und Low (0V) schaltet. Die Dauer eines Pulses entscheidet über die Drehgeschwindigkeit der Motoren. Je kürzer ein Puls, desto schneller fährt der Motor.
Zur Vorgabe der Drehrichtung werden drei weitere digitale Ausgänge des Arduinos genutzt. Ein Low-Signal lässt den Motor im Uhrzeigersinn fahren, ein High-Signal gegen den Uhrzeigersinn.
Zusätzlich wird im technischen Systementwurf der Programmablauf übersichtlich dargestellt:
Nach Initialisierung der Variablen und Festlegung der seriellen Datenübertragungsgeschwindigkeit (Baudrate) wird der String eingelesen. Über das erste Zeichen wird entschieden, ob es sich um ein Referenzkommando (1. Zeichen = „U“) oder ein Anfahrtskommando (1. Zeichen = „X“) handelt. Zum Auslesen der Anfahrten und Referenzen werden zwei Funktionen aufgerufen, die im String nach den Zahlenwerten für die jeweiligen Absolutpositionen bzw. Vorschubgeschwindigkeiten suchen und diese in Arrays speichern. Liegt ein Referenzkommando vor, wird wieder an den Programmanfang gesprungen und ein neuer String eingelesen.
Bei einem Anfahrtskommando wird nach Einlesen der Koordinaten aus dem absoluten Verfahrweg ein inkrementaler Weg berechnet. Dies geschieht durch Subtraktion der Anfahrtswerte von den Referenzwerten.
• Schaltplan
Im nachfolgenden Bild ist der Schaltplan der Schrittmotoransteuerung zu sehen. Dieser enthält die Komponenten Netzteil, Mikrocontroller, Schrittmotortreiber sowie den Schrittmotor selbst. Bei dem Netzteil handelt es sich um ein 230VAC/24VDC Standardnetzteil, auf welches hier nicht genauer eingegangen werden muss. Das zentrale Bauteil der Schaltung stellt der Arduino Mega 2560 Mikrocontroller dar, der mit der Masse des Netzteils verbunden werden muss. Die 5V-Versorgungsspannung wird über ein USB-Kabel realisiert, dass mit einem PC verbunden sein sollte, um das Programm auf den Mikrocontroller übertragen zu können. Des Weiteren ist zur Vorgabe der Drehrichtung der Digitalausgang Nr.8 mit dem Pin 8 des Schrittmotortreibers (Direction-Pin) verbunden. Zuletzt wird zur Schrittvorgabe der Digitalausgang Nr.9 mit dem Pin 9 des Schrittmotortreibers (Step-Pin) verbunden. Im Anschluss ist die weitere Verdrahtung des Schrittmotortreibers zu betrachten. Hier ist die Spannungsversorgung (Pin 1 und 2), der Anschluss der Motorwicklungen (Pin 3 bis Pin 6) und die Freigabebedingung (Pin 7) anzuschließen. Im störungsfreien Zustand (Endschalter sind nicht betätigt) ist der Pin 7 über die beiden Endschalter mit dem 5V-Signal verbunden. Wird einer der Endschalter betätigt, so liegt die Spannung von 5V nicht mehr am Disable-Pin an. Nun ist dieser Pin über den Pulldown-Widerstand mit der Masse verbunden und der Schrittmotortreiber wird abgeschaltet.
Hier ist die originale Fritzing-Datei des Schaltplans zu finden: Datei:Schaltplan Arduino Schrittmotortreiber Schrittmotor FRITZING.fzz
• Pinbelegungsplan
In der untenstehenden Tabelle ist die Pinbelegung der Steckverbindung zwischen Arduino und Schaltschrank einzusehen (Datei:Steckerbelegungsplan Arduino-CNC.xlsx).
| Pin Arduino | Pin serieller Stecker | Beschreibung |
| / | 1 | / |
| DO 13 | 2 | Y-Richtung Schritte |
| DO 12 | 3 | Y-Richtung Richtung |
| DO 11 | 4 | Z-Richtung Schritte |
| DO 10 | 5 | Z-Richtung Richtung |
| DO 09 | 6 | X-Richtung Schritte |
| DO 08 | 7 | X-Richtung Richtung |
| DO 07 | 8 | Fräser, Sauger EIN |
Software
• Quellcode Mikrocontroller
Der Quellcode des Arduino-Programms besteht aus 5 Teilen, welche im nachfolgenden erläutert werden.
- Deklarierung/Initialisierung der Variablen und Funktionen
Hier werden alle im Programm genutzten Variablen und Funktionen deklariert und initialisiert.
// MTR GPE
// WS 15/16
// David Hötzel
// Test-String-Verfahren: X2000Y0000Z0000F9999 // Test-String-Referenzierung: U4000V0000W0000
// Endschalter der Endlagen links und rechts sind nur zur hardwaretechnischen Sicherheitsabschaltung (Not-Endlage) vorgesehen, nicht in diesem Programm zur Referenzierung!
#include <AccelStepper.h> // Libary für Schrittmotoransteuerung
// Infos: http://www.airspayce.com/mikem/arduino/AccelStepper/classAccelStepper.html
AccelStepper Achse_X(1,9,8), Achse_Y(1,9,8), Achse_Z(1,9,8); // Funktion zur Ansteuerung der jeweiligen Achse erstellen (Interface, Output-Pin für Step, Output-Pin für Direction)
double X_Schritte = 0.0, Y_Schritte = 0.0, Z_Schritte = 0.0, F_Geschw = 0.0, U_Schritte = 0.0, V_Schritte = 0.0, W_Schritte = 0.0; // Variablen zur Berechnung der Anzahl der Schritte
double X_Soll = 0.0, Y_Soll = 0.0, Z_Soll = 0.0, F_Soll = 0.0; // Variablen zur Berechnung der Sollposition in mm
double U_Referenz = 0.0, V_Referenz = 0.0, W_Referenz = 0.0; // Variablen zur Referenzierung
char Zeichen; // Variable zur Identifizeriung der Achsebezeichnung im String
double Sollposition = 0; // Variable zum Zwischenspeichern des Sollwerts (aller Achsen) in der Funktion "string_auslesen"
double Schrittverhaeltnis = 0.033; // Verhältnis zur Eingabe absoluter Wege
// Verhältnis Verfahrweg pro Umdrehung in mm/Schritte: 66/200 = 0,33 (Umdrehung besteht bei 1,8° pro Schritt aus 200 Schritten)
// Verhältnis Schrittmotortreiber zu Schrittmotor: 1/10
- void setup()
Die Funktion void setup() wird zum Programmstart jeweils nur einmal ausgeführt. Hier wird die serielle Kommunikation aufgebaut, die Logik der Digitalpins zur Ansteuerung des Schrittmotortreibers festgelegt und die maximale Geschwindigkeit der Achsen begrenzt.
{
Serial.begin(115200); // Serielle Kommunikation starten
Serial.println(""), Serial.println("");
Serial.print("Initialisiere...");
Achse_X.setPinsInverted(false,true,true); // Direction: false=rechts, stepInvert, enableInvert
Achse_X.setMaxSpeed(1000); // Begrenzung maximale Geschwindwigkeit der Achse
Achse_Y.setPinsInverted(false,true,true);
Achse_Y.setMaxSpeed(1000);
Achse_Z.setPinsInverted(false,true,true);
Achse_Z.setMaxSpeed(1000);
Serial.println("fertig.");
Serial.println(""), Serial.println("");
}
- void loop()
Die Funktion void loop() enthält das Hauptprogramm. Hier wird zu Beginn geprüft, ob Daten am seriellen Port verfügbar sind. Danach wird der String vom seriellen Port auf die Zeichen X,Y,Z,F,U,V oder W untersucht und die nach den Buchstaben stehenden Zahlen werden eingelesen. Die Sollwerte und Referenzpositionen der Achsen werden berechnet und an die zuständigen Funktionen zur Ansteuerung der Achsen übergeben. Zuletzt wird den Achsen die Geschwindigkeit vorgegeben und die Bewegung der Achsen eingeleitet.
{
if (Serial.available() > 0) // Prüfen ob Daten am seriellen Port verfügbar sind
{
Serial.println("Neue Werte empfangen:");
Zeichen = Serial.read(); // erstes Byte (=erstes Zeichen) des seriellen Ports einlesen
if(Zeichen == 'X') // Prüfen ob das Zeichen ein X,Y,Z oder F ist (Sollwertvorgaben der jeweiligen Achsen)
{
X_Soll = string_auslesen(); // Aufruf der Unterfunktion zum Auslesen des Strings vom seriellen Port
Serial.print("X-Soll [mm]:"), Serial.print(X_Soll);
Zeichen = Serial.read();
}
if(Zeichen == 'Y')
{
Y_Soll = string_auslesen();
Serial.print(" | Y-Soll [mm]:"), Serial.print(Y_Soll);
Zeichen = Serial.read();
}
if(Zeichen == 'Z')
{
Z_Soll = string_auslesen();
Serial.print(" | Z-Soll [mm]:"), Serial.print(Z_Soll);
Zeichen = Serial.read();
}
if(Zeichen == 'F')
{
F_Soll = string_auslesen();
Serial.print(" | F-Soll [mm/min]: "), Serial.println(F_Soll), Serial.println("");
Zeichen = Serial.read();
}
if(Zeichen == 'U') // Prüfen ob das Zeichen ein U,V oder W ist (Übergabe eines neuen Referenzpunkt der jeweiligen Achse)
{
U_Referenz = string_auslesen();
U_Schritte = U_Referenz/Schrittverhaeltnis; // Berechnung der Anzahl der Schritte für die Referenzposition
Achse_X.setCurrentPosition(U_Schritte); // Übergabe der Anzahl der Schritte für die Referenzposition
X_Soll = 0; // Sollwert der Achse gleich Null setzen, damit sie in der Referenzposition stehen bleibt
Serial.print("X-Achse-Referenz gesetzt [mm]: "), Serial.print(U_Referenz);
Zeichen = Serial.read();
}
if(Zeichen == 'V')
{
V_Referenz = string_auslesen();
V_Schritte = V_Referenz/Schrittverhaeltnis;
Achse_Y.setCurrentPosition(V_Schritte);
Y_Soll = 0;
Serial.print(" | Y-Achse-Referenz gesetzt [mm]: "), Serial.print(V_Referenz);
Zeichen = Serial.read();
}
if(Zeichen == 'W')
{
W_Referenz = string_auslesen();
W_Schritte = W_Referenz/Schrittverhaeltnis;
Achse_Z.setCurrentPosition(W_Referenz);
Z_Soll = 0;
Serial.print(" | Z-Achse-Referenz gesetzt [mm]: "), Serial.println(W_Referenz), Serial.println("");
Zeichen = Serial.read();
}
}
X_Schritte = X_Soll/Schrittverhaeltnis; // Berechnung der Anzahl der Schritte zur Übergabe an den Schrittmotortreiber der jeweiligen Achse
Y_Schritte = Y_Soll/Schrittverhaeltnis;
Z_Schritte = Z_Soll/Schrittverhaeltnis;
F_Geschw = (F_Soll/(60*Schrittverhaeltnis)); // Berechnung der Anzahl der Schritte pro Sekunde für die Geschwindigkeitsvorgabe der Achsen
Achse_X.moveTo(X_Schritte); // Übergabe der Anzahl der Schritte an den jeweiligen Schrittmotortreiber
Achse_Y.moveTo(Y_Schritte);
Achse_Z.moveTo(Z_Schritte);
Verfahren(); // Aufruf der Unterfunktion zur Ansteuerung der Achsen und zur Geschwindigkeitsvorgabe
}
- double string_auslesen()
Beim Aufruf der Funktion string_auslesen() wird 4 mal nacheinander ein Zeichen vom seriellen Port eingelesen, in eine dezimal Zahl umgewandelt und aufaddiert. Danach wird aus der 4-stelligen Zahl eine 3-stellige Zahl mit einer Nachkommastelle gebildet.
{ // Unterfunktion zum Auslesen des Strings vom seriellen Port
Sollposition = 0;
int i=0;
while(i<=3) // Schleife wird 4 mal durchlaufen, um die 4 Zeichen nach dem X,Y,Z oder F einzulesen
{
Zeichen = Serial.read();
if(Zeichen >= '0' && Zeichen <= '9') {Sollposition = (Sollposition * 10) + (Zeichen - '0');} // Umwandeln (in dezimal Zahl) und Aufaddieren der Zeichen vom seriellen Port
i++;
}
Sollposition = Sollposition / 10.0; // durch bilden der Kommastelle wird aus der 4-stelligen Wert ein 3 stelliger Wert plus Kommstelle
return Sollposition;
}
*'' void Verfahren() ''
Der Aufruf der Funktion Verfahren() übergibt die vorgegebene Geschwindigkeit an die Funktionen der jeweiligen Achsen. Danach wird mit der Unterfunktion runSpeedToPosition() die Bewegung der Achse eingeleitet.
{ // Unterfunktion zur Ansteuerung der Achsen und zur Geschwindigkeitsvorgabe
Achse_X.setSpeed(F_Geschw); // Vorgabe der festen Geschwindigkeit an die Achse
Achse_X.runSpeedToPosition(); // Verfahren der Achse zum Sollwert mit der zuvor vorgegebenen Geschwindigkeit
Achse_Y.setSpeed(F_Geschw);
Achse_Y.runSpeedToPosition();
Achse_Z.setSpeed(F_Geschw);
Achse_Z.runSpeedToPosition();
}
Hier ist der komplette Arduino-Programmcode als .ino-Datei zu finden: Datei:Arduino Code X-Y-Z+Referenz.ino
Zusammenfassung
Eine Einführung und Einarbeitung mit dem Mikrocontroller Arduino Mega 2560 Mikrocontrollers, des Geckodrive G201X Schrittmotortreiber und des Igus Nema23 Schrittmotors bilden eine solide Grundlage zur Bearbeitung des Projekts. Des Weiteren sollte man sich vor Beginn der Programmierung des Mikrocontrollers gründlich mit der AccelStepper-Bibliothek zur Ansteuerung von Schrittmotoren befassen (Tipp: Informationen AccelStepper-Funktionen).
Ausblick
Laut der Aufgabestellung sollte man die 3 Achsen ansteuern. im Quellcode bezüglich einer "eleganteren" Programmierung lediglich der Bereich der Buchstabenerkennung des Strings könnte eine Verbesserung werden. es könnte anhand einer einzelnen Funktion die Erkennung der Buchstaben X,Y,Z,F und U,V,W realisiert werden. Es wurde auch schon anhang des Pinbelegungsplans die Steckerverbindung zwischen Steuer- und Lastteil der Maschine hersgestellt. Diese ist aber auf der 3-D-Bearbeitungsmachine nicht ausprobiert worden. Eine Erweiterung um Endschalter der Achsenendlagen bleit noch offen.
Literaturverzeichnis
• http://www.cansat.de/Doks/Arduino_Handzettel.pdf
• http://www.roboternetz.de/community/threads/52783-Arduino-Uno-Multitasking-und-Serielle-Befehle
• http://wiki.attraktor.org/images/d/d4/Arduino_stammtisch-serielle_kommunikation_spi.pdf
• http://fkainka.de/befehlsliste-arduino/
• http://www.mikrocontroller.net/topic/336231
• http://www.arduino-tutorial.de/2010/06/serielle-kommunikation/
• http://www.oreilly.de/catalog/arduinockbkger/chapter/ch04.pdf
• http://blog.openptv.org/?p=513
• https://www.arduino.cc/en/Serial/Available
• https://www.cs.auckland.ac.nz/references/unix/digital/AQTLTBTE/DOCU_078.HTM
• https://de.wikipedia.org/wiki/American_Standard_Code_for_Information_Interchange
Korrektur/Rückmeldungen
Zurück zum übergeordneten Projekt: 3-D-Bearbeitungsmaschine (Projekt des Schwerpunkts GPE im Studiengang MTR)