Ansteuerung einer Schrittmotor-Achse mit Mikrocontrollern am Beispiel eines Arduino-Mega
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 (s. Abb. 1).
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:
Die Originaldateien der Fotos des funktionalen Systementwurfs sind hier zu finden: Datei:Funktionaler Systementwurf Original.pptx
Technischer Systementwurf
Der technische Systementwurf (s. Abb. 3) 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.
Die Originaldatei des technischen Systementwurfs ist hier zu finden: Datei:Technischer Systementwurf Original.pptx
![](/wiki/images/thumb/2/24/Step_Direction_Signal.jpg/300px-Step_Direction_Signal.jpg)
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 (s. Abb. 4). 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 (s. Abb. 4). Ein Low-Signal lässt den Motor im Uhrzeigersinn fahren, ein High-Signal gegen den Uhrzeigersinn.
Zusätzlich wird im technischen Systementwurf der Programmablauf (s. Abb. 5) ü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 (s. Abb. 6). Dies geschieht durch Subtraktion der Anfahrtswerte von den Referenzwerten.
Die Originaldatei des Programmablaufs ist hier zu finden: Datei:Programmablauf Original.pptx
Eine Absolutbemaßung bezieht sich stets auf den Ursprung des Koordinatensystems und wird von diesem aus angegeben. Es wird nun angenommen, dass der Fräser an Punkt P1 steht. Als Referenz wurde dementsprechend und vorgegeben. Wenn im Anschluss zum Punkt P2 gefahren werden soll, werden die Anfahrtswerte und übergeben. Den Schrittmotoren muss allerdings die Differenz zwischen beiden Punkten, also dx und dy übergeben werden, um auf P2 zu fahren. Diese Differenz wird als inkrementales Maß bezeichnet. In diesem Programmschritt wird dieses Maß von mm in Schritte für die Motoransteuerung umgerechnet. Dies geschieht durch Division des Inkrementalmaßes mit einem Schrittverhältnis:
Die Originaldatei des Bildes zur Erklärung der absoluten und inkrementalen Bemaßung ist hier zu finden: Datei:Absolut Inkremental Original.pptx
Danach wird die neue Referenzposition als altes Anfahrtskommando gesetzt, um beim nächsten Verfahren erneut ein inkrementales Maß berechnen zu können.
Außerdem werden aus der übergebenen Vorschubgeschwindigkeit relative Geschwindigkeiten für alle drei Achsen in Abhängigkeit ihrer Verfahrwege berechnet. Dies ist zwingend erforderlich, damit der Fräser in Schrägen verfahren kann, bei denen eine Achse einen längeren Weg zurücklegen muss als die andere. Würden dann die Motoren gleich schnell angesteuert, wird eine 45°-Schräge verfahren und die Achse mit dem längeren Weg würde länger angesteuert werden als die andere.
Zunächst wird der dreidimensionale Pythagoras (s. Abb. 7) verwendet, um die Hypotenusenlänge zu berechnen:
Wird eine Achse nicht verfahren, so ist dieser Wert gleich null und c oder c‘ wird berechnet. Die resultierenden Geschwindigkeiten ergeben sich schließlich, indem man den inkrementellen Weg der Achse zur Hypotenusenlänge ins Verhältnis setzt und mit der übergebenen Vorschubgeschwindigkeit (F) multipliziert. Die Berechnung ist beispielhaft für die X-Achse angegeben:
Am Schluss des Programms werden alle drei Achsen mit den Schritt- und Richtungssignalen angesteuert.
Die Originaldatei des Bildes zur Erklärung der Berechnung der relativen Achsengeschwindigkeiten ist hier zu finden: Datei:3D Pythagoras Original.pptx
Entwicklung
Schaltplan
Die Entwicklung begann damit, die Systemübersicht des technischen Systementwurfs in einen Schaltplan zu überführen. Dazu wurde das Programm Fritzing verwendet. Der Arduino bekommt seine Versorgungsspannung von 5V DC über das USB-Kabel über den angeschlossenen PC, mit dem auch der String übergeben wird. Alternativ kann der Arduino auch über ein externes Netzteil bestromt werden. Ein weiteres Netzteil dient zur Bestromung der Schrittmotortreiber. Es ist darauf zu achten, eine gemeinsame Masse zwischen Arduino und Schrittmotortreibern herzustellen, damit sich alle Komponenten in einem gemeinsamen Bezugssystem befinden. Daher werden die Common Eingänge mit der Masse des Arduinos verbunden. Die weiteren Verbindungen zwischen Arduino und Schrittmotortreibern sind äquivalent wie bereits im technischen Systementwurf beschrieben.
Medium:Schaltplan_Arduino_3Schrittmotoren.jpg
Hier ist der originale Schaltplan zu finden: Datei:Schaltplan CNC Arduino.zip
Pinbelegungsplan
Als Schnittstelle zwischen Fräse und Microcontroller dient der 25-polige D-Sub-Stecker. Die Belegung von diesem und die Verbindung zum Arduino ist übersichtlich in der folgenden Tabelle dargestellt:
Pin D-Sub-Stecker | Belegung im Schaltschrank | Belegung am Arduino |
---|---|---|
2 | Step x-Achse | DO 09 |
3 | Direction x-Achse | DO 08 |
4 | Step y-Achse | DO 13 |
5 | Direction y-Achse | DO 12 |
6 | Step z-Achse | DO 11 |
7 | Direction z-Achse | DO 10 |
21 | Common x-Achse | Ground |
22 | Common y-Achse | Ground |
23 | Common z-Achse | Ground |
Gehäuse
![](/wiki/images/thumb/8/8a/Geh%C3%A4use_Explosionsdarstellung.png/200px-Geh%C3%A4use_Explosionsdarstellung.png)
Durch die Wahl eines additiven Fertigungsverfahrens, das Selektive Lasersintern (kurz: SLS), war ein hohes Maß an Freiheiten bei der Konstruktion gegeben. Daher sind keine konstruktiven Restriktionen durch das gewählte Fertigungsverfahren gegenüber konventionellen subtraktiven Fertigungsverfahren wie beispielsweise dem Fräsen gegeben.
Hier sind die originalen CAD-Daten des Gehäuses zu finden: Datei:Baugruppe Gehäuse Arduino.zip
Hardwareaufbau
Um die Verdrahtung entsprechend des Schaltplans umzusetzen, wurde eine Lochrasterplatine verwendet. Auf der Unterseite wurde eine Stiftleiste eingelötet, damit die Platine auf den Arduino gesteckt werden kann. Die Verbindung zwischen Lochrasterplatine und der D-Sub 25 Buchse wurde durch starre Leitungen mit einem Leitungsquerschnitt von 0,75mm² realisiert. Um Fehlkontaktierungen und Kurzschlüsse zu vermeiden, wurden die verschiedenen Signale mithilfe von Schrumpfschläuchen gegeneinander isoliert. Der Arduino Mega wird durch M3 Kunststoffschrauben in dem Gehäuse montiert. Die 25 polige D-Sub Buchse wird durch eine Nut im Unterteil des Gehäuses eingeschoben und durch den Deckel festgeklemmt.
![](/wiki/images/thumb/8/8d/Hardwareaufbau_im_Geh%C3%A4use.jpg/300px-Hardwareaufbau_im_Geh%C3%A4use.jpg)
Programmierung
Die Programmierung des Arduinos wurde mit der Arduino IDE durchgeführt. Der grundlegende Programmablauf wurde bereits beim technischen Systementwurf erläutert. Daher soll in den folgenden Ausführungen nur auf einzelne Abschnitte eingegangen werden. Zur Ansteuerung der Achsen wir die Accel-Stepper-Bibliothek verwendet.
Die Originaldatei des Programms ist hier zu finden: Datei:20190510 Verfahren mit Bib.zip
Deklarierung der Variablen
Am Anfang des Programms werden, wie in jedem C-Programm die benötigten Variablen deklariert und die Bibliotheken einbezogen.
#include <AccelStepper.h> //Einbeziehung der AccelStepper Bibliothek
AccelStepper Achse_X(1,9,8); //(Interface, Step Pin, Direction Pin)
AccelStepper Achse_Y(1,13,12); //(Interface, Step Pin, Direction Pin)
AccelStepper Achse_Z(1,11,10); //(Interface, Step Pin, Direction Pin)
double Anfahrten[4]={0.0,0.0,0.0,0.0}; //Array für die Anfahrtspositionen (X_Pos, Y_Pos, Z_Pos, F)
double Referenzen[3]={0.0,0.0,0.0}; //Array für die Referenzpositionen (X_Pos, Y_Pos, Z_Pos)
char Zeichen; //zum Einlesen des ersten Zeichens
double String_Umrechnung=0.1; //Umwandlung ins richtige Format
double Schrittwinkel=1.8; //Motor 1,8°/Schritt
double Distanz=40; //Pro Umdrehung werden 40mm zurueckgelegt 66mm bei der Zahnriemenachse
double Treiberverhaeltnis=0.1; //Verhälnis Treiber/ Motor 1/10=0.1
double Schrittverhaeltnis=((Distanz*Schrittwinkel)/360)*Treiberverhaeltnis;
//Übergabewerte an die Schrittmotoren
double X_Schritte ;
double Y_Schritte ;
double Z_Schritte ;
double F_Geschw;
double c; //Zwischenvariable zur Speicherung des Ergebnisses des Pythagoras
//Relative Achsengeschwindigkeiten
double Speed_X;
double Speed_Y;
double Speed_Z;
//Variablen zur Ueberpruefung der Positionen im String
int x_pos=999;
int y_pos=999;
int z_pos=999;
int f_pos=999;
int u_pos=999;
int v_pos=999;
int w_pos=999;
//Variablen zur Zwischenspeicherung der extrahierten Strings
String string1;
String subs1;
String subs2;
String subs3;
String subs4;
In einem Arduino Programm wird eine setup-Schleife zum Programmstart ein Mal durchlaufen. Darin werden serielle Datenübertragungsgeschwindigkeit und weitere Vorgaben eingestellt. Zur Sicherheit werden hier eine maximale Vorschubgeschwindigkeit und Achsenbeschleunigung eingestellt.
void setup() {
// Maximalgeschwindigkeiten der Achsen einstellen in Schritte/Sekunde
Achse_X.setMaxSpeed(10000);
Achse_Y.setMaxSpeed(10000);
Achse_Z.setMaxSpeed(10000);
// Beschleunigungen der Achsen einstellen in Schritte/Sekunde^2
Achse_X.setAcceleration(10000.0);
Achse_Y.setAcceleration(10000.0);
Achse_Z.setAcceleration(10000.0);
//Baudrate zur Datenübertragung über Serielle Schnittstelle
Serial.begin(9600);
}
Funktion zum Auslesen der Anfahrtskommandos
Die Funktion erhält einen Zeiger auf das Anfahrtenarray. Zu Beginn wird der gesamte String eingelesen bis ein Zeilenumbruch vorliegt. Die Länge eines Strings ist bekannt. Diese liegt bei insgesamt 20 Zeichen. Da am Anfang des Programms jedoch das erste Zeichen bereits eingelesen wurde, um zu prüfen, ob ein Anfahrs- oder Referenzkommando vorliegt, ist ein gültiger String der Anfahrtskommandos 19 Zeichen lang. Falls ein zu kurzer oder zu langer String vorliegt, handelt es sich um eine ungültige Eingabe und es folgt kein weiteres Einlesen. Im Anschluss wird nach den Indizes der Buchstaben Y, Z und F gesucht und in Variablen gespeichert. Diese dienen dazu, um festzustellen, ob die geforderten Zeichen im String vorliegen. Ist dies nicht der Fall, bleiben die vorherigen Werte dieser Kommandos bestehen und es liegt eine ungültige Eingabe vor. Am Ende der Funktion werden die Zahlenwerte, die zwischen den jeweiligen Buchstabenpositionen liegen extrahiert, in einen Integer umgewandelt und an die jeweilige Arrayposition des Anfahrten-Arrays geschrieben.
void string_Anfahrten_auslesen(double* Anfahrten )
{
string1= Serial.readStringUntil('\n'); //Auslesen des Strings bis zum Zeilenumbruch
if(string1.length()==19) //Überprüfung, ob der String die richtige Länge hat, sonst ungültige Eingabe
{
//Positionswerte der einzelnen Buchstaben im String werden gesucht
x_pos=0;
y_pos=string1.indexOf('Y');
z_pos=string1.indexOf('Z');
f_pos=string1.indexOf('F');
//Überprüfung, ob der String die Buchstaben enthält, sonst ungültige Eingabe
if(x_pos!=999 && y_pos!=999 && z_pos!=999 && f_pos!=999)
{
//Extrahieren der Substrings
subs1=string1.substring(x_pos, y_pos);
subs2=string1.substring(y_pos+1, z_pos);
subs3=string1.substring(z_pos+1, f_pos);
subs4=string1.substring(f_pos+1);
//Umwandlung der Substrings in Integer-Werte
Anfahrten[0]=subs1.toInt();
Anfahrten[1]=subs2.toInt();
Anfahrten[2]=subs3.toInt();
Anfahrten[3]=subs4.toInt();
//Auf ursprüngliche Werte setzen
x_pos=999;
y_pos=999;
z_pos=999;
f_pos=999;
}
else
{
Serial.println("Ungueltige Eingabe");
}
}
else
{
Serial.println("Ungueltige Eingabe");
}
}
Funktion zum Auslesen der Referenzkommandos
Diese Funktion ist äquivalent zu der Auslesefunktion von Anfahrtskommandos mit der Ausnahme, dass hier der String kleiner ist, nach anderen Buchstaben gesucht werden muss und nur drei Zahlenwerte in das Referenz-Array gespeichert werden.
Main Programm
Das Main Programm wird bei dem Arduino in der sog. void loop implementiert. Diese läuft kontinuierlich durch, solange der Arduino mit Strom versorgt wird. Am Anfang des Hauptprogramms wird abgefragt, ob Daten am seriellen Eingang verfügbar sind (Serial.available() > 0). Ist dies der Fall, wird das erste Zeichen eingelesen. Dies wird dazu genutzt, um zu prüfen, ob es sich um ein Anfahrts- oder Referenzkommando handelt. Ist das erste Zeichen ein „U“, liegt ein Referenzkommando vor und die Funktion zum Referenzen auslesen wird aufgerufen. Bei einem „X“ handelt es sich um ein Anfahrtskommando und die Funktion zum Auslesen der Anfahrten wird aufgerufen. Wird ein anderes Zeichen empfangen, liegt eine fehlerhafte Übergabe vor und es wird zum Programmanfang gesprungen. Danach finden die Berechnungen statt, wie bereits im technischen Systementwurf beschrieben. Die Achsengeschwindigkeiten werden mit der Funktion Achse_X.setSpeed(Geschw_X) gesetzt, die Entfernungen mit Achse_X.move(X_Schritte). Die simultane Ansteuerung wird über eine while-Schleife realisiert. Diese wird so lange durchlaufen bis alle Achsen ihre finale Position erreicht haben. Dies wird mit der Bibliotheksfunktion Achse_X.distanceToGo()!= 0 durchgeführt. In der Schleife wird allen Achsen der Befehl übergeben, dass die die eingestellte Geschwindigkeit verfahren sollen (Achse_X.runSpeed()). Danach muss erneut die gewünschte Geschwindigkeit eingestellt werden, da sonst die Geschwindigkeit von der Bibliotheksfunktion vergessen wird.
void loop() {
if (Serial.available() > 0) //Überprüfen, ob Daten am seriellen Port vorhanden
{
Serial.println(" Werte empfangen:");
Zeichen = Serial.read(); //Erstes Zeichen einlesen, um zu ueberpruefen, was eingelesen werden muss
if (Zeichen == 'X') //Falls X, dann Anfahrtswerte
{
string_Anfahrten_auslesen(Anfahrten); //Funktionsaufruf Anfahrten auslesen
//Ausgabe der Anfahrtswerte zur Kontrolle
Serial.println("Anfahrtswerte:");
Serial.print("X: ");
Serial.print(Anfahrten[0]);
Serial.println(" mm");
Serial.print("Y: ");
Serial.print(Anfahrten[1]);
Serial.println(" mm");
Serial.print("Z: ");
Serial.print(Anfahrten[2]);
Serial.println(" mm");
Serial.print("F: ");
Serial.print(Anfahrten[3]);
Serial.println(" mm/min");
//Inkrementalwerte berechnen und von mm in Schritte
X_Schritte=(Anfahrten[0]-Referenzen[0])/Schrittverhaeltnis;
Y_Schritte=(Anfahrten[1]-Referenzen[1])/Schrittverhaeltnis;
Z_Schritte=(Anfahrten[2]-Referenzen[2])/Schrittverhaeltnis;
//Neue Referenzwerte sind Anfahrtswerte
Referenzen[0]=Anfahrten[0];
Referenzen[1]=Anfahrten[1];
Referenzen[2]=Anfahrten[2];
//Berechnung der abgeleiteten Vorschubgeschwindigkeiten für die Achsen
F_Geschw=Anfahrten[3]/(Schrittverhaeltnis*60); //Vorschubgeschwindigkeit von mm/min in Schritte/ Sekunde
c=sqrt(pow(X_Schritte, 2)+pow(Y_Schritte, 2)+pow(Z_Schritte, 2)); //Hypotenuse berechnen
Speed_X=round((X_Schritte/c)*F_Geschw); //Relative Geschwindigkeiten berechnen
Speed_Y=round((Y_Schritte/c)*F_Geschw); //Relative Geschwindigkeiten berechnen
Speed_Z=round((Z_Schritte/c)*F_Geschw); //Relative Geschwindigkeiten berechnen
//Ausgabe der Schritte und Geschwindigkeiten nach Umrechnung zur Kontrolle
Serial.println("Schrittwerte:");
Serial.print("X: ");
Serial.print(X_Schritte);
Serial.println(" Schritte");
Serial.print("Y: ");
Serial.print(Y_Schritte);
Serial.println(" Schritte");
Serial.print("Z: ");
Serial.print(Z_Schritte);
Serial.println(" Schritte");
Serial.print("FX: ");
Serial.print(Speed_X);
Serial.println(" Schritte/sek");
Serial.print("FY: ");
Serial.print(Speed_Y);
Serial.println(" Schritte/sek");
Serial.print("FZ: ");
Serial.print(Speed_Z);
Serial.println(" Schritte/sek");
//Geschwindigkeiten und Verfahrwege an Treiber schicken
Achse_X.move(X_Schritte);
Achse_Y.move(Y_Schritte);
Achse_Z.move(Z_Schritte);
Achse_X.setSpeed(Speed_X);
Achse_Y.setSpeed(Speed_Y);
Achse_Z.setSpeed(Speed_Z);
//So lange verfahren bis die Soll-Position erreicht ist
while(Achse_X.distanceToGo()!= 0 || Achse_Y.distanceToGo()!= 0 || Achse_Z.distanceToGo()!= 0)
{
Achse_X.runSpeed();
Achse_X.setSpeed(Speed_X);
if(Achse_Y.distanceToGo() != 0)
{
Achse_Y.runSpeed();
Achse_Y.setSpeed(Speed_Y);
}
if(Achse_Z.distanceToGo() != 0)
{
Achse_Z.runSpeed();
Achse_Z.setSpeed(Speed_Z);
}
}
}
else
{
if(Zeichen == 'U') //Falls U --> Referenzkommando auslesen
{
string_Referenzen_auslesen(Referenzen); //Funktion Referenzen auslesen aufrufen
//Ausgabe der Referenzwerte zur Kontrolle
Serial.println("Referenz:");
Serial.print("U: ");
Serial.print(Referenzen[0]);
Serial.println(" mm");
Serial.print("V: ");
Serial.print(Referenzen[1]);
Serial.println(" mm");
Serial.print("W: ");
Serial.print(Referenzen[2]);
Serial.println(" mm");
}
}
}
}
Test des Systems
Die Funktionsüberprüfung unterteilt sich in vier Teile. Im Komponententest werden die einzelnen Programmteile einzeln überprüft. Der Integrationstest zielt darauf ab, ob der Zusammenbau funktioniert. Der Systemtest soll gewährleisten, dass das gesamte System seine Funktion erfüllt. Der Abnahmetest ist die Kundenübergabe, in denen der Kunde das Produkt auf die gewünschten Funktionen überprüft.
Die Ergebnisse der einzelnen Tests wurden in Excel-Listen zusammengefasst, um einen Nachweis darüber zu haben, dass das System wie gewünscht funktioniert und Verbesserungen aufzudecken.
Komponententest
Hier wurden die Funktionen zum Anfahrten und Referenzen auslesen sowie die Umrechnungen überprüft. Für die Auslesefunktionen wurden verschiedene Teststrings übergeben, um sicherzustellen, dass nur korrekt gesendete Strings ausgewertet werden und dass die Übergabewerte wie gewünscht gespeichert werden. Die Berechnungen wurden nach erfolgreichem Test der Einlesefunktionen getestet. Auch hier wurden verschiedene Kommandos gesendet, die berechneten Werte in einer Konsole ausgegeben und mit manuell berechneten Ergebnissen verglichen.
Hier ist das Protokoll des Komponententests zu finden: Datei:Komponententest.xlsx
Integrationstest
Ein erster Zusammenbau wurde an einer einzelnen Linearachse getestet. Dabei wurde zunächst nur geprüft, ob eine Achse in die gewünschten Richtungen verfährt und ob sie die korrekte Distanz zurücklegt. Auch hier wurden diverse Strings übergeben und über eine Messung des zurückgelegten Weges verifiziert, dass die Achse korrekt verfährt. Außerdem wurde bei verschiedenen Geschwindigkeiten eine saubere, ruckelfreie Fahrt der Achse beobachtet.
Hier ist das Protokoll des Datei:Integrationstests zu finden: Datei:Integrationstest.xlsx
Systemtest
Beim Systemtest wurde die Ansteuerung aller Achsen an der CNC-Fräse getestet. Hier wurde am Anfang für alle drei Achsen die korrekte Verfahrrichtung und Strecke überprüft. Daraufhin wurde über eine Weg-Zeit-Messung die Verfahrgeschwindigkeit getestet. Dabei ist aufgefallen, dass obwohl die richtig umgerechnete Geschwindigkeit an die Achsen gesendet wurde, ein zu langsames Verfahren stattfindet. Dieses Problem konnte nicht gelöst werden. Im nächsten Schritt wurde das simultane Verfahren von zwei und drei Achsen geprüft. Für das Verfahren der X- und Y-Achse wurde ein Stift an dem Fräskopf befestigt und ein Blatt Papier auf dem Maschinentisch befestigt. Das Aufzeichnen der Schräge und anschließende Vermessen hat gezeigt, dass verschiedene Fahrten, in denen die Achsen unterschiedlich schnell verfahren müssen, mit einer guten Genauigkeit vollzogen werden.
Hier ist das Protokoll des Datei:Integrationstests zu finden: Datei:Systemtest Protokoll.pdf
Bewertung des Arduinos bzw. der Arduino IDE für die Anwendung
Vorteile | Nachteile |
---|---|
Einfache, übersichtliche Programmierumgebung | Kein Debuggen möglich |
Vertrautes System durch Elektrotechnik Praktikum | Ansteuerung der CNC-Achsen simultan kompliziert |
C-ähnliche Programmiersprache | Bibliothek zur Ansteuerung der Achsen schlecht dokumentiert |
Spannungsoutput der digitalen Pins passend zu Schrittmotortreibern | Steuerung ausschließlich über Strings; Joystick denkbar |
Einlesen des Strings sehr simpel | |
Kompakt; einfache Anbindung an die CNC-Fräse möglich | |
Viele vorimplementierte Bibliotheken |
Zusammenfassung und Ausblick
Im Rahmen dieses Projektes konnte die 3D CNC Bearbeitungsmaschine erfolgreich mit einem Arduino Mega 2560 angesteuert werden. Durch die konsequente Anwendung des V-Modells konnten alle Meilensteine fristgerecht fertig gestellt werden.
Über die RS232-Schnittstelle kann der Arduino Strings einlesen. Anschließend wird zwischen Referenz- und Anfahrkommando unterschieden. Die Werte für Position und Vorschub werden ebenfalls aus dem String extrahiert. Die absoluten Positionswerte werden in inkrementelle Verfahrwege umgerechnet. In Abhängigkeit der Verfahrwege und der Vorschubgeschwindigkeit werden relative Geschwindigkeiten für alle drei Achsen durch den dreidimensionalen Satz des Pythagoras berechnet. Anschließend werden die Achsen durch Schrittmotortreiber angesteuert. Dazu wird jedem Schrittmotortreiber die Anzahl der Schritte und die Richtung übergeben.
Nach der Entwicklungsphase wurde gemäß des V-Modells vom Komponententest bis hin zum Abnahmetest das Projekt schrittweise getestet und entsprechende protokolliert.
Nach Abschluss des Projektes wird eine vollständig funktionsfähige Baugruppe hinterlassen. Für die Komponenten Arduino-Mega2560, die 25-polige D-Sub Buchse, die Platine und die Verdrahtung wurde ein Gehäuse konstruiert und mithilfe des additiven Fertigungsverfahrens Selektives Lasersintern gefertigt.
Für eine eventuelle nachfolgende Gruppe wäre ein Test des Gesamtsystems durch den Matlab-Algorithmus durchzuführen. Des Weiteren wäre die Integration von Steuerungstasten für jede Achse oder eines Joysticks in den Gehäusedeckel eine sinnvolle Erweiterung, um die gesamte CNC-Fräse auch manuell über den Arduino steuern zu können.
Weblinks und Literatur
- ↑ "Signale des Schrittmotors" https://knowledge.ni.com/KnowledgeArticleDetails?id=kA00Z0000019ZTySAM&l=de-DE (Aufgerufen am 07.01.2020)
- ↑ "Absolute und inkrementale Bemaßung" www.helmancnc.com (Aufgerufen am 07.01.2020)
Tutorials zum Einstieg mit einem Arduino: Arduino Tutorials
Arduino Bibliothek zur Ansteuerung von Schrittmotoren: AccelStepper-Bibliothek
Funktionen zur seriellen Kommunikation mit einem Arduino: Serielle Kommunikation Arduino
Korrektur/Rückmeldungen
Zurück zum übergeordneten Projekt: 3-D-Bearbeitungsmaschine (Projekt des Schwerpunkts GPE im Studiengang MTR)