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

Aufgabenstellung

Die Aufgabe bestand darin anfangs eine der drei Achsen unserer CNC Maschine anzusteuern indem ein String ausgelesen wird, und die dort erlangten Werte mithilfe eines über den Ardunino angesteuerten Schrittmotors angefahren werden. Dann wurde die Aufgabe ausgeweitet, und nun galt es alle drei Achsen anzusteuern und die fertige Programmierung durch zusammenfassen mit Fuktionen übersichtilicher zu gestalten.

Innerhalb dieses HSHL-Wikipedia Eintrags wird nun die Automatisierung einer Achse mit dem µC „Arduino Mega“ als Steuerungskonzept vorgestellt. Auch wird ein Konzept zur Ansteuerung aller drei Achsen mit einem Programm und einem Arduino Mega vorgestellt.

Autoren: Stefan, Hünemeier; Mario, Saake; Christoph, Dörner;

Regelkreis

Als Regelkreis bezeichnet man ein Wirkungsgefüge, das aus einem Steuerungsprozess mit eingeschalteter Gegenkoppelung besteht.

In unserem Fall wird als Sollgröße ein zuvor definierter Weg vorgegeben, der innerhalb des Arduino-Programmes in digitale Signale übersetzt wird. Diese digitalen Signale bzw. Steps nutzt der Schrittmotorcontroller (Geckodrive G201X) um den Schrittmotor der Linearachse anzusteuern. Die rotatorische Bewegung des Antriebes wird mittels Inkrementalgeber erfasst und durch die Programmierung in absolute Distanzen umgerechnet, sodass diese Werte als Rückführgröße übergeben werden können. Die Regeldifferenz errechnet Abweichungen dieser Rückführgröße zum Sollwert, sodass ggf. der Arduino die Maßabweichung ausgleicht. Ziel ist es, dass die Regeldifferenz Null wird. Die folgende Abbildung visualisiert die beschriebenen Zusammenhänge.

Belegungsplan

Bei der Ansteuerung der Bauteile muss zwischen einem Last- und einem Steuerkreis unterschieden werden. Der Steuerkreis besteht aus einem µc Arduino Mega welcher den Motorcontroller Geckodrive G201X mit den Signalen „step“ für die Schrittanzahl und „direction“ für die Richtungsvorgabe der Bewegung ansteuert. Die Spannungsversorgung des Arduino Megas wird über USB bzw. ein Festspannungsnetzteil sichergestellt. Der Geckodrive wird durch eine externe Spannungsquelle versorgt. Diese Nennspannung von 24 Volt wird durch den Geckodrive derart geschaltet, sodass der Schrittmotor nach Steuervorgaben betrieben wird. Die Bremsvorrichtung des Schrittmotors wird präventiv als Sicherheitseinrichtung bei Spannungsverlust eingesetzt. Deshalb wird diese bei Betrieb der Linieareinheit mit Energie versorgt und damit gelöst bzw. entriegelt.

Aus sicherheitstechnischen Gründen müssen beidseitig je ein Endschalter verwendet werden. Die Endschalter registrieren das Erreichen des maximalen Hubweges des Motorschlittens und erzeugen ein Steuersignal welches den Motorschlitten zum Stillstand zwingt und einen definierten Weg in die entgegengesetzte Richtung fahren lässt. Der Pulldown-Widerstand wird dazu verwendet um den Eingang bei Nichtbeschaltung auf GND zu „ziehen“ um damit Störsignale zu unterbinden. Zur Sicherheit wird beidseitig je ein weiterer Endschalter benötigt, der am Motorcontroller direkt, durch Verbinden der Anschlusspins 7 und 12, die Spannungsversorgung des Motors zu unterbindet. Hierbei wird allerdings keine Rückmeldung an die Steuerung geliefert, allerdings ist die Stromversorgung sofort unterbrochen, falls die davor installierten Endschlater nicht auslösen.

Nachfolgend ist eine mögliche Beschaltung der unterschiedlichen Komponenten detailliert aufgeführt. Die Datei des Schaltplans liegt zur weiteren Bearbeitung der angefühten zip-Datei bei.

Aufbau

Der Aufbau des Projektes besteht aus vier Hauptkomponenten welche die eigentliche Achse mit dem Schrittmotor ist, einem GeckoDrive, einem Microkontoller (dem Arduino MEGA) und einem Netzteil. Jedes dieser Komponenten spielt eine wichtige Rolle. Sie müssen alle miteiander verbunden sein und nur durch den richtigen Aufbau und Anschluss dieser Teil kann das Projekt so funktionieren wie es von uns geplant wurde.

Microkontorller

Den Microkontroller welchen wir verwenden ist der Arduino MEGA er hat sowohl Analoge als auch Digitale Ein- und Ausgänge, eine externe Strom versorgung, eine ,,resettaste und einen Anschluss für eine USB-Schnittstelle. Auf den Arduino MEGA wird unser Programm welches mit hilfe der dazugehörigen Software ,,Arduino, welche aus dem Opensource Bereich stammt und daher kostenlos ist aufgespielt. Den Microkontroller könnte man als das ,,Gehirn unseres Aufbaus nennen, da von hier alles gesteuert wird. Der Arduino Mega wurde mit dem Shield von SparkFun versehen um auch flexible Kabel mit ihm verbinden zu können.

]

GeckoDrive

Der GeckoDrive ist ein zwischen stück welches zwischen dem Arduino MEGA und dem Schrittmotor so wie zwischen dem Netzteil und dem Schrittmotor ist. Man kann es sich wie ein Verteiler vorstellen welches die Informationen und den Stromfluss wie durch Ventile für den Schrittmotor aufteilt und ihn so vorgibt wie er sich bewegen soll (Richtung und Geschwindigkeit).

Netzteil

Das Netzteil versorgt unseren Versuchsaufbau mit Strom. Die einzige Komponente die nicht vom Netzteil mit Strom versorgt wird, ist unser Arduino MEGA, da dieser über die USB-Schnittstelle schon mit Strom versorgt wird.

Achse mit Schrittmotor

Unsere Achse besteht aus einer Aluschine mit einer Führungsschine oben und unten worauf der Schlitten entlang fährt. Der Schlitten wird mit einem Gummiriemen in Bewegung gesetzt welcher von einem Schrittmotor gezogen wird. Der Schrittmotor ist am Ende der Achse montiert.

Kombinieren der Komponenten

Alle Komponenten müssen miteinander verbunden werden. Zur besseren Erklärung fangen wir die Verbingung unserer Komponenten von hinten an. Am Ende steht unsere Achse mit dem montierten Schrittmotor welcher über den mit ihm Verbundenen Geckodrive mit Strom und Befehlen versorgt wird. Der GeckoDrive welcher die Befehle und den Strom an unseren Schrittmotor weiterleitet wird einerseits mit dem Netzteil verbunden welches die Stromversorgung darstellt. Auf der anderen Seite ist der GeckoDrive mit dem Arduino MEGA verbunden die von ihm gesendeten Befehle werden vom GeckoDrive umgewandelt und an den Schrittmotor weitergegeben.

Software

Kompatibilitätsermittlung für den Betrieb mit Geckodrive G201 REV-6

Mittels Oszilloskop muss zunächst die Schrittweite des Ausgangssignals vom Ardunio analysiert werden. Mit Betracht auf den folgenden Auszug des Datenblattes vom Geckodrive, kann festgestellt werden, ob die angegebende Mindestperiodendauer von 3,5us (mit der Annahme, dass GND am Common-Terminal des Geckodrives angeschlossen ist) einhalten wird.

STEP AND DIRECTION INPUTS

TERMINAL 8: Direction Connect the DIRECTION line to this terminal.

TERMINAL 9: Step Connect the STEP line to this terminal.

TERMINAL 10: Common Connect the controller’s +3.3VDC, +5VDC or GND to this terminal.

These inputs are optically isolated from the rest of the drive. Terminal 10 is the common connection for the opto-isolators and must be connected to the +3.3VDC, +5VDC or GND of your indexer or pulse generator.

These inputs are meant to be driven by 3.3V to 5.5V logic capable of sourcing or sinking 2.5mA of current. The minimum logic “0” time is .5uS while the minimum logic “1” time is 3uS with 3.3V – 5V connected on the COMMON terminal. The minimum logic “0” time is 3uS while the minimum logic “1” time is 0.5uS when connected to GND on the COMMON terminal. Microstepping occurs on the falling edge of the step input when COMMON is a positive voltage and on the rising edge when COMMON is connected to GND and on the rising edge when connected to 3.3V – 5V.

Quelle: Datenblatt: Geckodrive Motor Controls, G201X / G210X User Manual, 2011, Tustin CA (USA)

Zusammenfassung: Eine Mindestperiodendauer von 3,5 µs wird durch die Festelegeung der Parameter im Programm eingehalten, was mit den oben gezeigten Abbildungen visualisiert wird.

Analyse der Vorwärts- und Rückwärtsbewegung des Hubschlittens

Die folgenden Abbildungen zeigen die Ermittlung des Vorwärts- Rückwärtssignals mittels Oszilloskop.

Zusammenfassung: Wird ein Directionsignal high am Arduino Mega ausgegeben, so verfährt der Hubschlitten in positive Richtung (vorwärts). Wird hingegen ein Directionsignal low am Arduino Mega ausgegeben, so verfährt der Hubschlitten in negative Richtung (rückwärts).

Quellcode für die Ansteuerung der x-Achse

Die in diesem Kapitel vorgestellten Quellcodes werden zur weiteren Bearbeitung mit der angefügten zip-Datei zur Verfügung gestellt. Es werden zunächst die Aspekte und der Umfang des Programmes aufgelistet und im Folgenden durch weiterführende Gedanken ergänzt.

Statusübersicht des Quellcodes für die Ansteuerung der x-Achse:

• Kommunikation des Arduino Mega mit dem seriellen Monitor (RS232-Kommuniaktion) zur Eingabe des Sollweges. Hierbei wird eine Umwandlung von ASCII-Code in Dezimal durchgeführt.

• Es wird bei einer Referenzposition gestartet, auf welche sich alle weiteren Sollwegangeben in Relation beziehen. Das heißt, dass weitere Sollwegeingaben Vielfache der ursprünglich eingegebenen Sollwegangabe sind.

Beispiel: Eine Eingabe des Sollweges von 50 mm zu Beginn der Dateneingabe verfährt den Hubschlitten 50 mm in positive Richtung. Diese Sollposition "merkt" sich die Programmierung. Bei einer weiteren Sollwegeingabe von z.B. 40 mm verfährt der Hubschlitten 10 mm zurück.

• Einbindung Endschalter in Programmablauf. Bei der Auslösung der Endschalter wird ein kurzer Weg in inverse Richtung verfahren. Innerhalb des Monitors wird eine entsprechende Fehlermeldung ausgegeben.

Weiterführende Gedanken:

• Einbindung eines Inkrementalgebers zur Überprüfung des Sollweges

• Einbindung festen Referenzpunktes bei Programmstart:

Vorschlag: Bei Programmstart wird solange in eine Richtung verfahren, bis z.B. eine Lichtschranke ausgelöst wird. Damit ist der Referenzpunkt erreicht, z.B. Koordinatenursprung Null. Hierdurch ist gleichzeitig ein begrenztes Intervall zur Sollwegeingabe geschaffen.

Anbei ist der gesamte Quellcode für die Ansteuerung eines Linearmotors mit dem Mikrocontroller Arduino mega abgebildet. Der Quellcode ist mit ausreichenden Kommentaren versehen, welche jeweilige Programmzeilen nachhaltig erläutern.

Angemerkt werden muss, dass die Bibliothek "Accelstepper" für die Arduino-Software vorinstalliert werden muss. Die Bibliothek liegt der zip-Datei dieses Artikels bei oder kann kostenfrei aus dem Internet geladen werden. Der Order „AccelStepper“ wird komplett in das Verzeichnis der Ardunino Software unter „libraries“ kopiert. Die Bibliothek kann nach Neustart der Software im Ardunio Programm genutzt werden.

Bibliothekseinbindung:

#include <AccelStepper.h> //vordefinierte Bibliothek

Parameter und Variablendefinition:

AccelStepper stepper(1,9,8);          // 1 = Treiberboard(definiert), Schritt, Richtung, (vorwärts fahren = 1, rückwärts fahren = 0 (über Directionsignal), autom. Umsetzung durch Bibliothek)

int EndschalterPinlinks = 22;         // Eingang 22 für Kontakt links
int EndschalterPinrechts = 23;        // Eingang 23 für Kontakt rechts
int sollweg = 0;                      // sollweg in mm
int zielweg = 0;
int Vorzeichen = 1;                   // wird bei der ASCII Umwandlung benötigt
double Schritt = 0.033;               // Verhältnis, um absolute Distanzen anzufahren 66/200 = 0,33 (Übersetzung = 66 mm/Umdrehung -> ZLW/-OD-1040Basic Datenblatt, 
                                      // 200 = Auflösung bei 1,8° Schrittwinkel, Gecko: Verhältnis 1 zu 10 --> 0,033
double Verfahr = 0;                   // Zuordnen des Verfahrweg --> Verfahr = Anzahl der Schritte für den gewünschten Weg
                                      

Initilaisierung:

void setup()
{
        Serial.begin(9600);                    // Port für serielle Kommunikation auf 9600 baud Rate Übertragungsgeschwindigkeit setzen  
        stepper.setAcceleration(24000000);     // Beschleunigung,Geschwindigkeit --> Frequenzänderung
        stepper.setCurrentPosition(0);         // Referenzposition = 0 setzen   
        pinMode(EndschalterPinlinks,  INPUT); 
        pinMode(EndschalterPinrechts, INPUT);    
        Serial.println("Initialisierung abgeschlossen");  
}

Hauptprogramm:

void loop()
{              
    if(Serial.available()>0)                           // Koordinaten einlesen 
        {
          char ascii = Serial.read();
          //Serial.println(ascii, DEC);
          
          if (ascii == '-')                            // feststellen, ob Minusvorzeichen gesetzt wurde
          {
            Vorzeichen = -1;
          }
          
          if(isDigit (ascii))                          // Prüfen, ob ASCII-Zeichen zw. 0 und 9 liegt (Dezimalzahlen 48 bis 57)
          {
           
            zielweg = (zielweg*10) + (ascii - '0');    // der ASCII Wert 48 entspricht der 0 (Synonym: 'ascii - 48') --> es wird aus dem ASCII Wert der Variablen ein Dezimalwert gebildet 
                                                       // die Multiplikation mit 10 erfolgt nach jeder zusätzlich eingegeben Zeichen in einer Zeile, um so auch mehrstellige Dezimalzahlen 
                                                       // darstellen zu können eine Zahleneingabe endet mit dem NewLine Befehl, dieser entspricht dem ASCII-Code '10'
          }
         
          else if(ascii == 10 ) //feststellen, ob Zahleneingabe komplett, d.h NewLine Befehl (ASCII=10)
          {
           zielweg = zielweg*Vorzeichen;               // Wert mit Vorzeichen multiplizieren
           Serial.print("Bekommener Wert: ");
           Serial.println(zielweg, DEC);
           sollweg = zielweg;
           zielweg = 0;
           Vorzeichen = 1;
          }
         }      
        
    if (digitalRead(EndschalterPinlinks) == LOW && digitalRead(EndschalterPinrechts) == LOW) // Sicherheitsabfrage
      {
        Verfahr = sollweg/Schritt;                     // Umrechnen des eingegebenen Koordinatenwertes in Anzahl von Schritten
        stepper.moveTo(Verfahr);                       // Festlegen des Weges
        Verfahren();                                   // Unterprogramm Verfahren() ausführen
      }
      
    else if(digitalRead(EndschalterPinlinks) == HIGH)  // wenn Schalter belegt - rückfahren
       { 
         Serial.println("Endschalter_links");
         stepper.move(500);
         int diff =  stepper.currentPosition() + 500;         
         while(stepper.currentPosition() != diff)
         {
           stepper.run();
         }
           sollweg = stepper.currentPosition()*Schritt;
       } 
         
    else if(digitalRead(EndschalterPinrechts) == HIGH) // wenn Schalter belegt - rückfahren
       { 
         Serial.println("Endschalter_rechts");
         stepper.move(-500); 
         int diff =  stepper.currentPosition() - 500;         
         while(stepper.currentPosition() != diff)
         {
           stepper.run();
         }          
           sollweg = stepper.currentPosition()*Schritt;        
       }        
}
   

Funktion "Verfahren"

void Verfahren() 
{
   if (stepper.currentPosition() != Verfahr )      // solange bis Position erreicht "run"
   {
       stepper.run();
   }                
   stepper.setSpeed(0);
   stepper.moveTo(stepper.currentPosition());     // Beschreiben der aktuellen Position  
}

Quellcode für die die Duplizierung auf alle Achsen

Statusübersicht des Quellcodes für die Duplizierung der Programmierung auf alle drei Achsen (Zusatzaufgabe):

Die Duplizierung des Programmes auf alle Achsen hat zunächst Priorität gegenüber der Einbindung eines Inkrementalgebers. Es damit soll ein Ansprechen der gesamten Maschine per Steuerungsalgortihmus zum Ardunio realisiert werden. Folgende erreichte Aspekte lassen sich festhalten:

• Die Programmierung ist im Stande, alle drei Achsen anzusprechen

• Das Programm ist im Stande per Steuerungsalgorithmus angesprochen zu werden

• Eine eindeutige Zeichenkette (z.B.: x2000y0000z0000e) muss dem Programm vorgegeben werden, um die Achsen anzusteuern

Weiterführende Gedanken:

• Die sich wiederholende Programmabschnitte können mit allgemeingültigen Funktionen umgesetzt werden --> Idee: Einbinden von Switch-Case Anweisungen

Programmablaufplan für die Ansteuerung von drei Achsen mit dem ArduinoMega

Das im Programm eingesetzte Vorgehen, zum Einlesen und Verarbeiten der Koordinaten, soll mit dem abgebildeten Ablaufdiagramm verdeutlicht werden:

Repräsentativ bilden wir die wesentlichen Abschnitte des Programms ab. Hierbei konzentrieren wir uns auf die Abschnitte für die x-Achse. Die Abschnitte für die y- und z-Achse sind identisch, mit der Ausnahme der Beschriftung mit y- und z sowie dem Abbruchkriterium mit dem Buchstaben e für die z-Achse.

Bibliothekseinbindung:

#include <AccelStepper.h>                // vordefinierte Bibliothek

Parameter und Variablendefinition:

AccelStepper stepperx(1,9,8);           // 1 = Treiberboard(definiert), Schritt, Richtung 
int EndschalterPinlinksx = 22;          // Eingang 22 für Kontakt links
int EndschalterPinrechtsx = 23;         // Eingang 23 für Kontakt rechts
int sollwegx = 0;                       // Sollweg in mm
int Vorzeichen = 1;                     // wird bei der ASCII Umwandlung benötigt
double Schritt = 0.033;                 // Verhältnis, um absolute Distanzen anzufahren 
                                        // 66/200 = 0,33 (Übersetzung = 66 mm/Umdrehung -> ZLW/-OD-1040Basic Datenblatt, 
                                        // 200 = Auflösung bei 1,8° Schrittwinkel)
                                        // Gecko: Verhältnis 1 zu 10 --> 0,033
double Verfahrx = 0;                    // Zuordnen des Verfahrweg --> Verfahr = Anzahl der Schritte für den gewünschten Weg
int status_x = 0;
char ascii;

Initilaisierung:

void setup()
{
        Serial.begin(9600);                    // Port für serielle Kommunikation auf 9600 baud Rate Übertragungsgeschwindigkeit setzen  
        stepperx.setAcceleration(24000000);    // Beschleunigung,Geschwindigkeit --> Frequenzänderung
        stepperx.setCurrentPosition(0);        // Referenzposition = 0 setzen  
        pinMode(EndschalterPinlinksx,  INPUT); 
        pinMode(EndschalterPinrechtsx, INPUT);  
        Serial.println("Initialisierung abgeschlossen");
        Serial.flush();
}

Hauptprogramm (Ausschnitt):

 void loop()
{  
  if(Serial.available() > 0)                       // Koordinaten einlesen 
        {
          ascii = Serial.read();
          
     
          if (ascii == 'x')                         // feststellen, ob x gesetzt wurde
          {
            status_x = 1;
            while (status_x == 1)  
             {
               status_x = UmrechnungplusBerechnung(); 
             }
          }           

          if (ascii == 'y')
          {
           Serial.print("Bekommener Wertx: ");
           Serial.println(zielweg, DEC);
           sollwegx = zielweg;
           zielweg = 0;    
          }

Weiterführender Hauptteil (Ausschnitt):

if (digitalRead(EndschalterPinlinksx) == LOW && digitalRead(EndschalterPinrechtsx) == LOW)     // Sicherheitsabfrage
      {
        Verfahrx = sollwegx/Schritt;                   // Umrechnen des eingegebenen Koordinatenwertes in Anzahl von Schritten
        stepperx.moveTo(Verfahrx);                     // Festlegen des Weges
        Verfahrenx();                                  // Unterprogramm Verfahren() ausführen
      }        
    else if(digitalRead(EndschalterPinlinksx) == HIGH)           // wenn Schalter belegt - rückfahren
       { 
         Serial.println("Endschalter_linksx");
         stepperx.move(500);
         int diff =  stepperx.currentPosition() + 500;         
         while(stepperx.currentPosition() != diff)
         {
           stepperx.run();
         }
           sollwegx = stepperx.currentPosition()*Schritt;
       } 
         
    else if(digitalRead(EndschalterPinrechtsx) == HIGH)           // wenn Schalter belegt - rückfahren
       { 
         Serial.println("Endschalter_rechtsx");
         stepperx.move(-500); 
         int diff =  stepperx.currentPosition() - 500;         
         while(stepperx.currentPosition() != diff)
         {
           stepperx.run();
         }          
           sollwegx = stepperx.currentPosition()*Schritt;        
       }

Funktion Verfahren():

void Verfahrenx() 
{
 if (stepperx.currentPosition() != Verfahrx ) //solange bis Position erreicht "run"
 {
   stepperx.run();
 }                
  stepperx.setSpeed(0);
  stepperx.moveTo(stepperx.currentPosition()); //Beschreiben der aktuellen Position       
}

Funktion Umrechnung plus Berechnung:

  int UmrechnungplusBerechnung()
{
     ascii = Serial.read();
     if(isDigit(ascii))           //Prüfen, ob ASCII-Zeichen zw. 0 und 9 liegt (Dezimalzahlen 48 bis 57)
          {                     
             zielweg = (zielweg*10) + (ascii - '0'); // Erklärung siehe Quelltext oben
             return 1;
          }
          else 
          {
               return 0;
          }
}

Ausblick & Verbesserungen

Momentan ist es möglich den Schlitten auf der Achse zu bewegen und die Aktuelle Position in Echtzeit auszugeben. Die Bewegung können wir durch manuelle eingabe eines Wertes in dem Seriellen Monitor starten oder durch auslesen eines Strings. Hierbei müssen die ausgelesenen Werte jedoch noch in Milimeter umgerechnet werden. Es ist auch möglich einzelne Abschnitte aus dem String auszulesen und diese dann an eine bestimmte Achse zu senden. Hierzu steht schon die Grundprogrammierung welche aber noch überarbeiten werden muss wie folgt: - Ausgelesenen String wert in Milimeter umrechnen - Software Endschalter im Programm einbinden - Auf eine Grundposition zurück fahren nach Vollendung der Aufgabe - Fertiges Programm mithilfe von Funktionen kürzen und Zusammenfassen.

Zusammenfassung

Den einzelnen Teilkapiteln dieses Artikels sind die aktuellen Status der betrachteten und bearbeiteten Aspekte zu entnehmen. Insgesamt wurde es realisiert, Komponenten, deren Kompatibilität zueinander zunächst unbekannt war, miteinander kommunizieren zu lassen und mit diesen Komponenten schließlich das errichtete Bearbeitungsportal in Bewegung zu setzen. Das Ansprechen des Programmes über den, von einem anderen Team entwickelten Steuerungsalgorithmus, konnte ebenfalls umgesetzt werden. Die Einbindung weiterer Sensoren, wie z.B. die des Inkrementalgebers und einer Referenzpunktabfrage, stellen weiterführende Schritte des Projektes dar, welche zunächst aufgrund priorisierter Teilaufgabenergänzungen zurückgestellt wurden. Weiterführende Gedanken und Vorschläge sind bereits in den Teilkapiteln vorzufinden. Eine Weiterentwicklung des aktuellen Standes ist mit den bereitgestellten Dateien zu diesem Fachthema umsetzbar.

Anhang: Medium:Materialien_Ardunio.zip