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)
Einleitung
• Aufgabenstellung und Ziel
Mithilfe eines Arduino Mega 2560 Mikrocontrollers und einem Geckodrive G201X Schrittmotortreiber soll ein Igus Nema23 Schrittmotor, der eine Achse einer CNC-Maschine antreibt, angesteuert werden. Von einer externen Quelle wird dem Mikrocontroller mittels der seriellen Schnittstelle ein String nach dem Muster "X1111Y2222Z3333F4444" übergeben. Dieser String enthält 4 Sollwerte. Die 4 Ziffern nach den ersten 3 Buchstaben stehen für den jeweiligen Sollwert einer Achse in Millimetern (X-Achse: 111,1 mm; Y-Achse: 222,2 mm; Z-Achse: 333,3 mm). Die 4 Ziffern nach dem 4. Buchstaben stehen für die Vorschubgeschwindigkeit der Achsen (444,4 mm/min). Aufgabe des Mikrocontroller ist es nun die Sollwerte einzulesen und dem Schrittmotortreiber die zu fahrenden Schritte vorzugeben. Des Weiteren soll dem Mikrocontroller ein String zur Referenzierung vorgegeben werden, falls die Achse bei einem Neustart des Mikrocontrollers nicht am Nullpunkt steht. Dieser wird nach dem Muster "U4000V0000W0000" übermittelt (U->X; V->Y; W->Z).
Stand der Technik
Hardware
• Arduino Mega 2560 Mikrocontroller
| Mikrocontroller | ATMega 2560 |
| Eingangs-/Betriebsspannung | 6-20/5 VDC |
| maximale Stromaufnahme | 500 mA |
| maximaler Strom je In-/Output-Pin | 40 mA |
| Anzahl digitale In-/Output-Pins (davon PWM-Output) | 54 (15) |
| Anzahl analoge Input-Pins | 16 |
| Anschlüsse | USB, serielle Schnittstelle, Spannungsversorgung |
Hier sind weitere Daten zum Arduino Mega 2560 Mikrocontroller zu finden: [1]
• Geckodrive G201X Schrittmotortreiber
| 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) |
Das Datenblatt des Geckodrive G201X Schrittmotortreibers ist hier einzusehen: Datei:Betriebsanleitung Schrittmotortreiber.pdf
• Igus Nema23 Schrittmotor
| max. Eingangsspannung/Nennspannung | 60/24-48 VDC |
| 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% |
| optionale Bauteile | Encoder, Bremse |
Die Informationen des Datenblatts des Igus Nema23 Schrittmotors sind hier zu finden: Datei:Motordatenblatt DE.pdf
• 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.
</nowiki>
// 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
</nowiki>
*'' 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("");
}
</nowiki>
*'' 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
}
</nowiki>
*'' 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 und Ausblick
Eine ausführliche Einarbeitung in die technischen Unterlagen des 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).
Im Hinblick auf die Aufgabenstellung kann gesagt werden, dass die Ansteuerung aller 3 Achsen nach den Tests reibungslos und zuverlässig funktioniert. Verbessert werden könnte im Quellcode bezüglich einer "eleganteren" Programmierung lediglich der Bereich der Buchstabenerkennung des Strings. Die Erkennung der Buchstaben X,Y,Z,F und U,V,W könnte anhand einer einzelnen Funktion realisiert werden.
Zurück zum übergeordneten Projekt: 3-D-Bearbeitungsmaschine (Projekt des Schwerpunkts GPE im Studiengang MTR)