Ansteuerung einer Schrittmotor-Achse mit Mikrocontrollern am Beispiel eines Arduino-Mega

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 Schrittmotrtreiber 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

Schaltplan für Arduino, Schrittmotortreiber, Schrittmotor und Netzteil

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