Dauerkalender

Schranke mit DRV8825

In dem Versuch wird mit einem Schrittmotor und Motortreiber eine einfache Schranke gesteuert. Zusätzlich untersuchen wir einige Funktionen des hier eingesetzten Motortreibers DRV8825. Zwischen der eigentlichen Schrankensteuerung und Testprogrammen wird mit dem Schalter S3 umgeschaltet. Im Experimentiermodus (Schalterstellung S3=ON) wird der Motor manuell links und rechts bewegt, die Drehgeschwindigkeit wird mit einem Potentiometer eingestellt. Zusätzlich werden einfache Positionierungsaufgaben mit unterschiedlicher Schrittweite absolviert.
Im Automatikmodus wird die eigentliche Schrankensteuerung aktiviert (Schalterstellung S3=OFF).  Die Motorbewegungen werden mit einem Impulssignal, das mit dem Taster S1 generiert wird, eingeleitet.
Welche Bewegung der Motor ausführt, hängt von der aktuellen Position der Schranke ab. Eine Position der Schranke, und zwar „Schranke oben“, wird mit einem Sensor (Gabellichtschranke) markiert. Wenn die Steuerung einen Start-Impuls empfängt und die Schranke die „Position oben“ angenommen hat, erfolgt eine Rechtsbewegung. Schranke wird geschlossen. Andernfalls dreht der Motor links, bis die Schranke öffnet und den Sensor „Position oben“ erreicht.
Da die Schrankenbewegung nach rechts mit einem Schrittmotor realisiert wird, wobei die Schritte gezählt werden, wird ein weiterer Sensor für die „Position unten“ nicht benötigt. Auf dem Weg nach oben wird auf die Schrittzählung verzichtet. Die Schranke fährt nach oben, bis der Positionssensor erreicht wurde. Diese Vorgehensweise ist wichtig für den Fall eines Stromausfalls. Nach Spannungswiederkehr könnte die Schranke falsche Endpositionen anfahren.

Motor

Der 17HS08 hat eine Schrittweite von 1,8°, was bedeutet, dass er im Vollschrittmodus 200 Schritte ausführen muss, um eine volle Umdrehung zu drehen. In unserer Schaltung wird er mit dem Motortreiber DRV8825D gesteuert. Seine nominale Stromaufnahme beträgt 1A. Ein direkter Anschluss an Mikrocontroller, würde zu seiner Zerstörung führen. Der Spulenanchluss:

A+ - Schwarz
A/ - Grün
B+ - Rot
B/ - Blau

Motortreiber

Die direkte Ansteuerung des Motors übernimmt der Schrittmotor-Treiber DRV8825D. Bei dem Chip handelt es sich um eine Entwicklung von Texas Instruments. In der Schaltung kommt der Baustein in Form eines Moduls zum Einsatz. Der Treiber ermöglicht eine einfache Schrittsteuerung eines Schrittmotors. Bei Bedarf können gleichzeitig zwei Gleichstrommotoren angesteuert werden. Es können Motoren bis zu 1,7 A angeschlossen werden. Bei ausreichender Kühlung können Motoren bis zu 2,2 A gesteuert werden. Strombegrenzung kann mit einem Trimmer, der sich auf dem kleinen Modul befindet, eingestellt werden. Der Treiber arbeitet mit einer Motorspannung von 8,2 V bis 45 V. Logikspannung liegt im Bereich von 3,3 bis 5 V. Er verfügt über Überstrom- und Übertemperaturschutz. Der Treiber bietet sechs verschiedene Schritteinstellungen: Vollschritt, Halbschritt, 1/4-Schritt, 1/8-Schritt, 1/16-Schritt und 1/32‑Schritt.

DRV8825 Modul

DRV8825 Modul mit Kühlkörper

Pinbelegung

Stromeinstellung

Bevor der Motor zum Drehen gebracht werden kann, soll der maximale Spulenstrom eingestellt werden. Auf dem Treiber-Modul DRV8825 befindet sich ein kleines Potenziometer, mit dem diese Einstellung realisiert werden kann. Auf diese Weise wird verhindert, dass die Motorspulen mit einem zu großen Strom belastet werden. Man geht hier wie folgt vor:
- Aus dem Datenblatt des Schrittmotors den Nennstrom des Motors ablesen und festhalten. Bei dem in der Schaltung verwendeten Motor handelt es sich um einen Schrittmotor mit der Bezeichnung 17HS08 mit einem nominalen Strom von 1A.
- Durch externe Parametrierung wird an dem Motortreiber der Vollschrittmodus eingestellt. Dabei werden die Pins MS1 bis MS3 nicht an Versorgungsspannung angeschlossen.
- In Reihe mit einer Spule des Motors wird ein Strommessgerät zur Strommessung angeschlossen.
- Der STEP-Eingang wird an HIGH Level geschaltet.
- Mit einem Schraubendreher wird der Potentiometer so eingestellt, dass der vom Hersteller angegebene Nennstromwert erreicht wird.

Schrittweite

Mit der Schrittweite (Schrittwinkel) wird angegeben, um wie viel Grad sich der Schrittmotor bei einem elektrischen Impuls dreht. Mit der Einstellung der Schrittweite kann die Präzision des Motors festgelegt werden. In unserem Fall (Motor 17HS08-1004S) beträgt die Schrittweite 1,8°. Das bedeutet, dass für eine volle Umdrehung des Motors 200 Schritte benötigt werden (360° / 1,8° = 200). Bei einer Wahl eines Viertelschritts würde der Motor 800 Schritte ausführen müssen, um eine volle Umdrehung zu absolvieren. Der Treiber DRV8025 stellt drei Pins, die es ermöglichen, die Schrittweite zu beeinflussen, zur Verfügung. Es gibt insgesamt sechs mögliche Einstellungen:

Lichtschranke

Um die Startposition der Schranke zu markieren, wird die Schaltung mit einer Gabel-Lichtschranke, die auf einem Infrarotsensor basiert, ausgestattet. Sie markiert die Position: Schranke oben, Weg frei. Dabei handelt es sich um ein Modul, das u.a. den Komparator LM393 enthält. Das Modul liefert ein analoges und ein digitales Signal. Die Betriebsspannung des Sensors liegt im Bereich von 3,3V bis 5V. Er eignet sich sehr gut für die Geschwindigkeitsmessung einer Drehachse mithilfe einer Lochscheibe.

Schaltplan

Testschaltung

Mikrocontroller

Die Koordination der Signale, vor allem jedoch die Zählung der Schrittanzahl, was für eine exakte Positionierung unerlässlich ist, übernimmt ein Mikrocontroller. In unserem Fall ist das Arduino Nano. Seine Aufgabe wird dadurch erleichtert, dass nicht alle Signale, die der Motortreiber DRV8825 benötigt, von ihm bedient werden müssen. Die meisten Parameter des Treibers werden mit fester Verdrahtung festgelegt. Neben den Tastern und Schaltern, die für diverse Funktionen benötigt werden, muss der Mikrocontroller die Signale der Gabellichtschranke und des Potentiometers auswerten.

Programm

int Taster_Start = 5;                // S1-Motor drehen (HAND+AUTO)
int Taster_200 = 4;                  // S2-200 Schritt - Bewegung
int Schalter_Programm_um = 3;        // S3-Programm-Umschaltung
int Schalter_Richtung = 2;           // S4-Drehrichtung ändern (HAND)
int Position_oben = 6;               // Lichtschranke Sensor Position oben
int Poti_Tempo = A0;                 // Geschwindigkeit Einstellung

int Step = 7;                        // Schritt Impuls
int Richtung = 8;                    // Ausgang Drehrichtung

int MikroSek;                        // Schritt-Umschaltzeit in Mikrosekunden

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

    pinMode(Taster_Start, INPUT_PULLUP);           // Eingang
    pinMode(Taster_200, INPUT_PULLUP);             // Eingang
    pinMode(Schalter_Programm_um, INPUT_PULLUP);   // Eingang
    pinMode(Schalter_Richtung, INPUT_PULLUP);      // Eingang
    pinMode(Position_oben, INPUT_PULLUP);          // Eingang
    pinMode(Step, OUTPUT);                         // Ausgang
    pinMode(Richtung, OUTPUT);                     // Ausgang
}

// **************************************************************************************
void loop() {

                                  // (Handbetrieb) Experimente mit DRV8825
    if (digitalRead(Schalter_Programm_um) == LOW) {
        
        int Poti_Wert = analogRead(Poti_Tempo);              // Zeit für Geschwindigkeit
        MikroSek = map(Poti_Wert, 0, 1023, 300, 1200);
        
        if (digitalRead (Schalter_Richtung) == LOW) {        // Drehrichtung einstellen
            digitalWrite (Richtung, LOW);                    // Rechtsdrehung
        } else {
            digitalWrite (Richtung, HIGH);                   // Linksdrehung
        }

        if (digitalRead (Taster_Start) == LOW) {             // Taster S1 betätigt / Start
            Schritt ();
        }

        if (digitalRead (Taster_200) == LOW) {               // 200-Schritte Bewegung
            digitalWrite (Richtung, HIGH);                   // Rechtsdrehung
            for (int i=0; i<200; i++) {
                Schritt ();
            }
            delay(1000);
            digitalWrite (Richtung, LOW);                    // Linksdrehung
            for (int i=0; i<200; i++) {
                Schritt ();
            }            
        }        
    }

    if (digitalRead(Schalter_Programm_um) == HIGH) {         // Schranke Steuerung
        if (digitalRead (Taster_Start) == LOW) {             // Taster S1 betätigt / Start
            MikroSek = 2000;
            int Position = 2;                                // Merker Schranke unten
            if (digitalRead(Position_oben) == HIGH) {        // Schranke oben
                Position = 1;                                // Merker Schranke oben
            }
            switch (Position) {
                case 1: {
                    digitalWrite (Richtung, HIGH);           // Rechtsdrehung                
                    for (int i=0; i<400; i++) {              // 400 Schritte
                        Schritt ();
                    }
                    delay (1000);
                    break;
                } 
                case 2: {
                    digitalWrite (Richtung, LOW);            // Linkssdrehung                  
                    while (digitalRead (Position_oben) == !(HIGH)) {
                        Schritt ();                          // Bis Positionssensor
                    }
                    delay (1000);
                    break;
                }   
            }         
        } 
    }    
}

// **************************************************************************************
void Schritt () {

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

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

Das Programm besteht aus zwei Teilen. Im ersten Teil werden einige Eigenschaften des Motortreibers untersucht. Das zweite Teil ist das eigentliche Programm, mit dem die Schranke gesteuert wird.

Experimente mit dem Schrittmotor und Motortreiber DRV8025:

In dem Teil des Programms können je nach Einstellung diverse Funktionen des Treibers getestet werden. Die Umschaltung in den Testmodus erfolgt mit dem Schalter S3. Mit dem Taster S1 kann der Motor manuell geführt werden. Er dreht, solange der Taster gedrückt gehalten wird. Mit dem Schalter S3 kann die Drehrichtung des Motors eingestellt werden. Und schließlich kann mit dem Taster S2 eine automatische Bewegung eingeleitet werden. Wenn der Taster betätigt wird, wird der Motor dazu veranlasst, 200 Schritte in eine Richtung zu absolvieren. Anschließend erfolgt automatisch eine Bewegung mit ebenfalls 200 Schritten in die entgegengesetzte Richtung. Mit den Schaltern S5, S6 und S7 werden jeweils andere Schrittweiten eingestellt. Im Vollschrittmodus macht der Motor bei 200 Schritten eine volle Umdrehung. Im Halbschrittmodus erfolgt nur eine halbe Drehung (180°) usw. Es können auf diese Weise alle möglichen Schrittmodis ausprobiert werden. Mit einem Potentiometer kann für jede Schritteinstellung die Drehgeschwindigkeit eingestellt werden. Mit dem Taster S8 wird die Funktion Enable getestet.

S1 – HAND: Motor drehen / AUTO: Schranke Start
S2 – HAND: 200 Schritte – Bewegung
S3 – Programm Umschaltung
S4 – Richtung ändern
S5-S6-S7: Schrittweite
S8 – Enable

Schranke Steuerung

Sobald der Schalter S3 auf die eigentliche Schrankensteuerung umgeschaltet wird, wird das zweite Teil des Programms aktiviert. Die Schranke wird hier mit einem einzigen Signal gesteuert. Das Signal wird mit dem Taster S1 simuliert. Wenn die Schranke oben ist und das Signal empfangen wird, wird die Schranke geschlossen. Wenn sie geschlossen ist, wird sie dann entsprechend geöffnet. Beim Schließen der Schranke absolviert der Motor im Halbschrittmodus 400 Schritte. Beim Öffnen fährt der Motor ohne Schrittzählung in entgegengesetzte Richtung, bis die Position „Oben“ erreicht wird. Diese Stellung wird mit der Gabellichtschranke A3 markiert.
Bei Neueinschaltung, sollte die Schranke nicht in der Position „Oben“ stehen, fährt sie zuerst nach oben, bis der Positionssensor „Oben“ erreicht wird.

Kurzvideo

Kurzvideo

Weitere Themen: