Dauerkalender

Schrittmotor mit Feedback

Die Schrittmotoren weisen eine ganze Reihe von Vorteilen auf. Sie eignen sich hervorragend für Positionierungsaufgaben, haben eine lange Lebensdauer, sind kostengünstig und wartungsarm. Es gilt jedoch auch einige Nachteile der Schrittmotoren, wie z.B. hohe Wärmeentwicklung im Stillstand durch den konstanten Haltestrom, aufzuzählen. Das wichtigste negative Merkmal der Schrittmotoren ist der bedingte Schrittverlust. Sobald das Problem auftaucht, kann der Schrittmotor seine Positionierungsaufgaben nicht mehr erfüllen. Die Gründe der Schrittverluste können verschiedene Ursachen haben. Dazu zählen die Überlast bei mechanisch bedingten Problemen, starke Vibrationen, Schwankungen im Stromversorgungskreis, starker Drehmomentabfall bei hohen Drehzahlen, zu steil eingestellte Beschleunigungs- und Bremsrampen. Die Schrittmotoren arbeiten grundsätzlich in einem offenen Regelkreis, dh. es gibt keine Rückmeldung darüber, an welcher Position der Motor sich gerade befindet. Das kann bei Schrittverlusten zu Fehlfunktionen oder fehlerhaften Herstellungsteilen führen.
Eine Abhilfe für die Probleme kann die Einführung eines Motor-Encoders sein. Der Drehgeber wird an der Achse des Motors montiert, oder auf anderem Wege mit der Achse fest verbunden und überwacht ihr Drehverhalten. Bei jeder Drehung liefert der Drehgeber Signale, die der Steuerung mitteilen, ob der Motor seine Aufgaben fehlerfrei erledigt. In unserem Beispiel kommt ein Inkrementalgeber zum Einsatz. Bei einer vollen Umdrehung liefert er 500 Impulse, die gezählt und mit den Schritten des Schrittmotors abgeglichen werden. Stimmt die Rechnung nicht, wird ein Alarm ausgelöst und der laufende Prozess angehalten.

Motor und Motortreiber

Die Schrittmotoren werden gewöhnlich mithilfe eines Motortreibers, der eine Schnittstelle zwischen der Steuerung (zB. Mikrocontroller) und dem Motor darstellt, betrieben. In den meisten Fällen ist es nicht ratsam, einen Motor direkt an einen Mikrocontroller anzuschließen. Dies kann zur Beschädigung des Mikrocontrollers führen. In der Schaltung kommen der Motor 17HS08-1004S und der Motortreiber DRV8825 zum Einsatz. Einige Experimente mit dem Pärchen haben wir bereits hinter uns. Die Beschreibung ist unter folgender Adresse zu finden:

Für diese Schaltung merken wir uns lediglich, dass es sich um einen 1,8°-Schrittmotor handelt. Das bedeutet, dass er im Vollschrittmodus 200 Schritte ausführen muss, um eine volle Drehung zu absolvieren (200 * 1,8° = 360°). Wir verfahren in dem Versuch im Achtelschrittmodus, was dazu führt, dass 1600 Schritte zurückgelegt werden müssen, um eine volle Drehung der Achse zu erreichen. Die Schrittmodus-Einstellung wird auf dem Treiber vorgenommen.

Drehgeber

Bei dem Inkrementalgeber handelt es sich um ein Produkt der Firma Baumer. Die Bezeichnung des Gebers lautet BDK 16.24k500. Der Sensor liefert bei einer vollen Umdrehung 500 Inkremente. Er arbeitet mit einer Spannung im Bereich von 10–30 V DC. Bei unserem einfachen Versuch wird nur die Spur A des Gebers abgefragt. Das bedeutet, dass wir mit unserer Kontrolle nicht in der Lage sind, die Drehrichtung des Motors zu überwachen. Das ist auch nicht gewollt. Wir wollen den Motor nur auf eventuellen Schrittverlust überwachen. Der Geber arbeitet in unserer Schaltung mit 12 V. Da ein so starkes Signal den Mikrocontroller beschädigen könnte, wird das Signal mit einem Spannungsteiler in den Bereich von 5V herabgesetzt (Spannungsteiler R1/R2).

Mikrocontroller

Als Rechner tritt in der Schaltung der Arduino Uno auf. Seine Aufgaben werden in einem kurzen Programm zusammengefasst. Eine Übersicht über Programmierung findet man hier:

Viele Aufgaben hat der Mikrocontroller nicht. Grundsätzlich stammen von ihm die Befehle, die den Motor zum Drehen veranlassen. Bei jeder Bewegung werden gleichzeitig die Signale vom Drehgeber registriert und gezählt. Entspricht der Vergleich der Schritte und Inkremente nicht der zugrunde gelegten Formel, wird als Warnung eine rote Leuchtdiode eingeschaltet.

Schaltplan

Testschaltung

Programm

Im setup()-Abschnitt werden zunächst wie gewöhnlich die I/Os entsprechend als Eingänge oder Ausgänge definiert. Der wichtigste Eingang ist der Pin 2 (Eingang_Inkrementalgeber). Hier kommen die Signale des Drehgebers an. Bei jedem Wechsel des Pegels am Eingang von LOW auf HIGH wird ein Interrupt ausgelöst. Das bedeutet, dass bei jedem HIGH am Eingang 2 das Hauptprogramm unterbrochen wird und das kurze Unterprogramm Inkrement() ausgeführt wird. In dem kurzen Programm wird der aktuelle Stand der Variable Inkremente um 1 erhöht. Auf diese Weise werden die Signale des Drehgebers registriert und gezählt.
Im Hauptprogramm werden in drei Programmabschnitten die drei Taster S1, S2 und S3 abgefragt. Mit S1 und S2 kann der Motor manuell in beiden Richtungen bewegt werden. Mit dem Taster S3 wird eine doppelte Bewegung ausgelöst. Der Motor dreht einmal um 360° in eine Richtung und anschließend, auch um 360°, zurück. Diese Bewegung fällt in den Bereich der Positionierung.
In allen drei Fällen wird die Ausführung der Drehbefehle mit dem Drehgeber überwacht. Dabei gehen wir wie folgt vor:

Der Motor muss 1600 Schritte ausführen, um eine volle Umdrehung zu absolvieren.
Der Drehgeber liefert bei einer vollen Umdrehung 500 Impulse.
Die Motorschritte und Signale des Drehgebers werden gezählt.
Pro Impuls des Drehgebers fallen 3,2 Schritte des Motors an.

So kann man annehmen, dass nach vier Schritten des Motors mindestens ein Impuls von dem Geber registriert werden müsste. Ist das der Fall, werden die Zähler genullt und die Zählung beginnt von neuem. Andernfalls signalisiert die rote Warnung-Leuchtdiode, dass der Motor einige oder alle Schritte verliert und untersucht werden muss.

int Step = 3;                                  // Ausgang Schritt Impulse
int Richtung = 4;                              // Ausgang Drehrichtung
int Taster_Vorlauf = 7;                        // Pin 7 manuell Rechtsdrehung
int Taster_Ruecklauf = 8;                      // Pin 8 manuell Linksdrehung
int Taster_Automatik = 9;                      // Pin 9 automatisch 1 x drehen
int Leuchtdiode_Stoerung = 10;                 // Meldeleuchte Störung
int Eingang_Inkrementalgeber = 2;              // Inkrementalgeber Spur A
int Inkremente, Schritte;
int MikroSek_manuell = 1500;                   // Schritt-Umschaltzeit in Mikrosekunden
int Mikrosek_Auto = 500;


// **************************************************************************************
void setup() {

    pinMode (Taster_Vorlauf , INPUT_PULLUP);    // Pin 7 als Eingang
    pinMode (Taster_Ruecklauf, INPUT_PULLUP);   // Pin 8 als Eingang
    pinMode (Taster_Automatik, INPUT_PULLUP);   // Pin 9 als Eingang
    pinMode (Eingang_Inkrementalgeber, INPUT);  // Pin 2 als Eingang (Interrupt)
    pinMode (Leuchtdiode_Stoerung, OUTPUT);     // Pin 10 als Ausgang
    pinMode (Step, OUTPUT);                     // Pin 3 als Ausgang
    pinMode (Richtung, OUTPUT);                 // Pin 4 als Ausgang

                                                // Interrupt Aufruf
    attachInterrupt(digitalPinToInterrupt(Eingang_Inkrementalgeber), Inkrement, RISING);
}

// **************************************************************************************
void loop() {
        
    if (digitalRead (Taster_Vorlauf) == LOW) {     // Handsteuerung drehen vorwärts
        digitalWrite (Richtung, LOW);              // Motor Drehrichtung festlegen
        Schritt (MikroSek_manuell);                // Tempo
        Kontrolle ();                              // Auf Schrittverlust untersuchen
    }
    if (digitalRead (Taster_Ruecklauf) == LOW) {   // Handsteuerung drehen rückwärts
        digitalWrite (Richtung, HIGH);             // Motor Drehrichtung festlegen
        Schritt (MikroSek_manuell);                // Tempo
        Kontrolle ();                              // Auf Schrittverlust untersuchen
    }    
             
    if (digitalRead (Taster_Automatik) == LOW) {
        digitalWrite (Richtung, LOW);              // Motor Drehrichtung festlegen
        for (int i=0; i<1600; i++) {            
            Schritt (Mikrosek_Auto);               // Tempo
            Kontrolle ();                          // Auf Schrittverlust untersuchen
        }        
        delay (1000);
        digitalWrite (Richtung, HIGH);             // Motor Drehrichtung festlegen
        for (int i=0; i<1600; i++) {            
            Schritt (Mikrosek_Auto);               // Tempo
            Kontrolle ();                          // Auf Schrittverlust untersuchen
        }
    }
}

// **************************************************************************************
void Inkrement() {

    Inkremente++;                                  // Inkremente addieren    
}

// **************************************************************************************
void Kontrolle() {                                 // Auf Schrittverlust untersuchen
   
        Schritte++;
        if (Schritte > 4) {
            if (Inkremente > 0) {
                Schritte = 0;
                Inkremente = 0;
            } else {
                digitalWrite (Leuchtdiode_Stoerung, HIGH);  // Leuchtdiode Störung EIN
                delay(5000);
            }
        }
}

// **************************************************************************************
void Schritt (int MikroSek) {                      // Einen Motorschritt ausführen

    digitalWrite(Step, HIGH);
    delayMicroseconds(MikroSek);
    digitalWrite(Step, LOW);
    delayMicroseconds(MikroSek);
}

// **************************************************************************************  
         

Kurzvideo

Kurzvideo

Weitere Themen: