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

Einleitung

• Aufgabenstellung und Ziel

Stand der Technik

Hardware

• Arduino Mega 2560 Mikrocontroller

• Geckodrive G201X Schrittmotortreiber

• Igus Nema23 Schrittmotor

• Schaltplan

Software

• Quellcode Mikrocontroller

• Deklarierung/Initialisierung der Variablen und Funktionen

// 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()

{
    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()

{              
    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()

{                                                                                // 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() // 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();
}