DC-Motoren steuern

Gleichstrommotor

Gleichstrommotoren erzeugen durch ständige drehwinkelabhängige Umpolung ein wechselndes Magnetfeld im Rotor (Magnetspulen um eine drehbare Achse). Im feststehenden Gehäuse sind Dauermagnete abwechselnd in Nord- und Südpol-Richtung untergebracht.

Elektromotoren benötigen je nach Größe hohe Ströme und induzieren auch selbst Strom. Deshalb benötigt man an den Anschlüssen des Motors Dioden, die den induzierten Strom wieder ableiten. Dadurch wird die restliche Schaltung vor zu hohen Stromspitzen geschützt.

Zusätzlich erzeugen Elektromotoren hochfrequente Störungen, die z.B. Funksignale im Umfeld stören können. Um dies zu vermeiden, sollte man drei kleine Keramikkondensatoren direkt am Elektromotor anbringen. Die Kapazität sollte zwischen 10nF und 100nF liegen. Zwei Kondensatoren werden von jeweils einem Motoranschluss an das Motorgehäuse gelötet, der Dritte überbrückt beide Anschlüsse.

Ein Elektromotor kann entweder einfach ein- oder ausgeschalten werden (mit Relais oder Transistoren), oder auch in seiner Geschwindigkeit und Laufrichtung beeinflusst werden. Dazu verwendet man eine H-Brückenschaltung (H-Bridge), die man mit Relais oder FETs realisieren kann.

Eine H-Bridge gibt es auch fertig als IC: L293D. Bei dieser Ausführung sind die Dioden zum Ableiten der Induktion sogar schon integriert. Bei der Verwendung des L293D sollte man unbedingt darauf achten, dass der genug gekühlt wird. Dieser Chip kann einen Motor mit maximal 600mA versorgen.

Motorsteuerung mit Transistor

Die einfachste Art, einen Gleichstrommotor anzusteuern ist mit einem Potentiometer und einem Transistor; in unserem Fall der N-Channel MOSFET IRF540.

Verwendete Bauteile

Aufbau

Schaltplan für den Betrieb eines DC-Motors mit N-Channel MOSFET
Abb.: Schaltplan für den Betrieb eines DC-Motors mit N-Channel MOSFET

Langsames Starten von DC-Motoren

Manchmal will man, dass die Motoren nicht sofort mit ihrer volle Umdrehungsleistung starten, sondern langsam anfangen. Dies lässt sich mit einem einfachen Aufbau bewerkstelligen:

Verwendete Bauteile

Schaltplan für einen langsam startenden DC-Motor
Abb.: Schaltplan für einen langsam startenden DC-Motor

Motorsteuerung mit Arduino und Transistor

Da der Arduino nur sehr kleine Ströme (<=20mA; Spitzen: 40mA) pro DigitalOut zulässt, können auch nur kleine Motoren (z.B. Vibrationsmotoren aus Handys) gesteuert werden.
Mit einem Transistor können wir aber auch einen kleineren Gleichstrommotor (3-6V) betreiben

Verwendete Bauteile

Aufbau

Schaltplan für den Betrieb eines DC-Motors mit Arduino und Transistor
Abb.: Schaltplan für den Betrieb eines DC-Motors mit Arduino und Transistor

Die Diode dient als Sicherung gegen induktive Stromspitzen, wenn der Motor abgeschaltet wird. So werden keine anderen Bauteile (z.B. der Mikrocontroller) beschädigt. Evtl. ist hier eine Schottky-Diode besser geeignet, da sie schneller schaltet.
Der Keramikkondensator glätte Spannungsspitzen (hier kann man mit den Werten etwas variieren: 1pF, 1nF, ...)
Die Kombination aus Widerstand und Transistor sollte passend gewählt werden. Wichtig zu wissen ist, dass beim Arduino ca. 20mA (max. 40mA) an einem Pin fließen können. Durch den Widerstand R1 wird dieser Strom, welcher durch die Basis fließt, entsprechend gemindert. Dann müssen wir noch den Verstärkungsfaktor des Transistors kennen und können damit die den maximalen Strom ausrechnen, der durch Kollektor-Emitter fließt. Der Transistor sollte auf diese Strommenge ausgelegt sein, ansonsten führt es zur Überhitzung und zur Zerstörung des Transistors.

Sketch

Der folgende Sketch erhöht die Drehzahl des angeschlossenen Motors in 10er Schritten und sobald er beim Maximum von 255 angekommen ist, fährt er die Drehzahl wieder bis auf 0 zurück:

#define PIN_MOTOR 3

void setup()
{
    pinMode(PIN_MOTOR, OUTPUT);
    Serial.begin(9600);
}

void loop()
{
    for(byte i=0; i<250; i+=10) {
        Serial.println("up:   " + String(i));
        analogWrite(PIN_MOTOR, i);
        delay(500);
    }
    analogWrite(PIN_MOTOR, 255);
    delay(3000);

    for(byte i=250; i>0; i-=10) {
        Serial.println("down: " + String(i));
        analogWrite(PIN_MOTOR, i);
        delay(500);
    }
    analogWrite(PIN_MOTOR, 0);
    delay(3000);
}

Motorsteuerung mit Arduino und H-Brücke (IC L293)

Da viele Bauteile für eine selbst gebaute H-Brücke benötigt werden, bietet es sich an, einen IC zu verwenden. Ein gängiges Modell ist der L293, der zwei Motoren unabhängig von einander steuern kann.

IC L293

Die H-Bridge L293D hält einen kurzzeitigen Strom von 1,2A und einen dauerhaften Strom von 600mA pro Kanal aus.
Ein großer Vorteil der L293D sind die integrierten Dioden, die Induktionsströme abfangen, welche beim Nachdrehen des Motors entstehen.
Sollten höhere Ströme benötigt werden, sollte man auf die Verwendung eines alternativen ICs zurückgreifen, z.B. der L6205N.

Verwendete Bauteile

Anschlüsse des L293

Anschlüsse des L293
Pin Nr. Funktion Beschreibung
1 Enable 1-2 HIGH: Anschlüsse 1 und 2 sind aktiv
LOW: Anschlüsse 1 und 2 sind inaktiv
2 Input 1 HIGH: Strom fließt durch Output 1
3 Output 1 Anschluss für Motor 1
4, 5 GND Masse (auch für Hitzeableitung)
6 Output 2 Anschluss für Motor 1
7 Input 2 HIGH: Strom fließt durch Output 2
8 Vcc 2 Stromversorgung für Motoren (4,5V - 36V)
9 Enable 3-4 HIGH: Anschlüsse 3 und 4 sind aktiv
LOW: Anschlüsse 3 und 4 sind inaktiv
10 Input 3 HIGH: Strom fließt durch Output 3
11 Output 3 Anschluss für Motor 2
12, 13 GND Masse (auch für Hitzeableitung)
14 Output 4 Anschluss für Motor 2
15 Input 4 HIGH: Strom fließt durch Output 4
16 Vcc 1 Interne Stromversorgung (5V)

Normalerweise fließen beim Betrieb von Motoren recht hohe Ströme und dadurch wird auch Wärme erzeugt. Daher besitzt der L293 4 GND-Pins, die nicht nur als Masse- Anschlüsse dienen, sondern auch die Wärme ableiten können. Daher sollte man alle diese GND-Pins an recht große Pads auf der späteren Platine löten, damit die Wärme dorthin übergeleitet werden können und somit eine größere Oberfläche entsteht.

Beispiel für die Wärmeabführung auf einer Platine für den L293
Abb.: Beispiel für die Wärmeabführung auf einer Platine für den L293

Aufbau

Aufbau mit dem L293 und einem DC-Motor
Abb.: Aufbau mit dem L293 und einem DC-Motor

Sketch

#define PIN_MOTOR_INPUT3 11
#define PIN_MOTOR_INPUT4 10
#define PIN_MOTOR_ENABLE 9

void setup()
{
    pinMode(PIN_MOTOR_INPUT3, OUTPUT);
    pinMode(PIN_MOTOR_INPUT4, OUTPUT);
}

void loop()
{
    for (int i=0; i<256; i+=5) {
        // A = HIGH and B = LOW means the motor will turn right
        digitalWrite(PIN_MOTOR_INPUT3, HIGH);
        digitalWrite(PIN_MOTOR_INPUT4, LOW);

        // speed counts from 0 to 255
        analogWrite(PIN_MOTOR_ENABLE, i);
        delay(70);
    }
    for (int i=255; i>0; i-=5) {
        digitalWrite(PIN_MOTOR_INPUT3, HIGH);
        digitalWrite(PIN_MOTOR_INPUT4, LOW);
        analogWrite(PIN_MOTOR_ENABLE, i);
        delay(70);
    }

    // turn other direction
    for (int i=0; i<256; i+=5) {
        digitalWrite(PIN_MOTOR_INPUT3, LOW);
        digitalWrite(PIN_MOTOR_INPUT4, HIGH);
        analogWrite(PIN_MOTOR_ENABLE, i);
        delay(70);
    }
    for (int i=255; i>0; i-=5) {
        digitalWrite(PIN_MOTOR_INPUT3, LOW);
        digitalWrite(PIN_MOTOR_INPUT4, HIGH);
        analogWrite(PIN_MOTOR_ENABLE, i);
        delay(70);
    }
}

Motorsteuerung mit Arduino und H-Brückenmodul HG7881

Verwendete Bauteile

H-Brückenmodul HG7881
Schaltplan des H-Brückenmoduls HG7881
Abb.: Schaltplan des H-Brückenmoduls HG7881

Steuerung des H-Brückenmoduls

Es wird empfohlen am Eingang IA ein PWM-Signal für die Motor-Geschwindigkeit und am Eingang IB ein digitales Signal für die Drehungs-Richtung zu verwenden.

IA IA Motor
LOW LOW aus
HIGH LOW vorwärts
LOW HIGH rückwärts
HIGH HIGH aus

Sketch

Der folgende Code dreht den Motor zunächst nach rechts dann nach links (je nachdem, wie der Motor angeschlossen wurde. Zwischen den Drehungen pausiert der Motor für eine 1 Sekunde.

#define PIN_IB 12 // direction
#define PIN_IA 11 // speed

void setup()
{
    pinMode(PIN_IB, OUTPUT);
    pinMode(PIN_IA, OUTPUT);
}

void loop()
{
    turnMotor(1);
    stopMotor();
    turnMotor(2);
    stopMotor();
}

void turnMotor(int direction)
{
    if(direction== 1) {
        digitalWrite(PIN_IB, HIGH);
        digitalWrite(PIN_IA, LOW);
    } else {
        digitalWrite(PIN_IB, LOW);
        digitalWrite(PIN_IA, HIGH);
    }
    delay(1000);
}

void stopMotor()
{
    digitalWrite(PIN_IB, LOW);
    digitalWrite(PIN_IA, LOW);
    delay(1000);
} 

Motorsteuerung mit Arduino und Dual-H-Brückenmodul DRV8833

Der DRV8833 ist ein Motortreiber mit geringer Verlustleistung und einem maximalen Laststrom von 1,5A im Dauerbetrieb. Er integriert zwei H-Brücken zur Steuerung von Gleichstrommotoren. Pro Motor werden zwei Anschlüsse (IN1+IN2 bzw. IN3+IN4) verwendet, um die entsprechenden Betriebsmodi einzustellen.
Der DRV8833 hat eine Betriebsspannung von 2,7V bis ~10V und kann 1,5A Laststrom (Dauerlast) und 2A bei kurzzeitiger Spitzenlast aushalten. Es gibt zusätzlich eine automatische Abschaltfunktion bei zu großen Lastströmen, Kurzschluss, zu geringer Betriebsspannung oder beim Überschreiten der Maximaltemperatur.

Verwendete Bauteile

Anschlüsse

Anschlüsse des DRV8833-Modul
Pin Bedeutung
GND 0V/GND
VCC Betriebspannung 2,7V bis 10V
IN1 + IN2 bzw. IN3 + IN4 Eingänge für Motor #1 bzw. Motor #2
OUT1 + OUT2 bzw. OUT3 + OUT4 Ausgänge für Motor #1 bzw. Motor #2
EEP Sleep-Modus-Schalter (HIGH: Modul aktiv; LOW: Low-power Sleep)
ULT "Fault"-Output: Ist normalerweise LOW und wird im Fehlerfall auf HIGH geschaltet, z.B. Überhitzung oder zu hoher Stromstärke.

Sketch

Der folgende Sketch schaltet im Abstand von 2s die verschiedenen Modi des Moduls durch:

#define PIN_IN1 5
#define PIN_IN2 6

void setup()
{
    pinMode(PIN_IN1, OUTPUT);
    pinMode(PIN_IN2, OUTPUT);
}

void loop()
{
    // Vorwärtslauf des Motors
    digitalWrite(PIN_IN1, 1);
    digitalWrite(PIN_IN2, 0);
    delay(2000);

    // Freilauf des Motors
    digitalWrite(PIN_IN1, 0);
    digitalWrite(PIN_IN2, 0);
    delay(2000);

    // Rückwärtslauf des Motors
    digitalWrite(PIN_IN1, 0);
    digitalWrite(PIN_IN2, 1);
    delay(2000);

    // Motorbremse
    digitalWrite(PIN_IN1, 1);
    digitalWrite(PIN_IN2, 1);
    delay(2000);
}

Falls man den Motor nicht nur mit voller Umdrehungszahl betreiben will, so kann man an den entsprechenden Stellen des Vorwärts- bzw. Rückwärtslaufs das digitalWrite durch ein analogWrite ersetzen. Natürlich müssen dann PWM-Anschlüsse des Arduino benutzt werden.


    analogWrite(PIN_IN1, 150);
    // ...
    analogWrite(PIN_IN2, 150);

Fertige Motorsteuerung für den Arduino

Für den Arduino gibt es ein fertiges Motor-Shield zur Ansteuerung von Gleichstrommotoren, Schrittmotoren oder Servos.
Dies ist im Projekt #144 näher beschrieben.

Getriebemotor GA12-N20 (6V)

Getriebemotor GA12-N20

Eine weitere Art von Motoren, die auf die obige Art betrieben werden können, sind Getriebemotoren. Diese besitzen ein Zahnradgetriebe, welches -in dem hier verwendeten Modell- zur Untersetzung der Drehgeschwindigkeit verwendet wird.

Abmessungen des Getriebemotors GA12-N20
Abb.: Abmessungen des Getriebemotors GA12-N20
Getriebemotor GA12-N20
Tab.: Leistungsdaten der Reihe der N20-Getriebemotoren

Aufbau und Sketch

Hier können alle obigen Schaltpläne (und Sketches) verwendet werden.

zurück