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.
Die einfachste Art, einen Gleichstrommotor anzusteuern ist mit einem Potentiometer und einem Transistor; in unserem Fall der N-Channel MOSFET IRF540.
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:
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
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.
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);
}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.
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.
| 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.
#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);
}
}
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 |
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);
}
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.
| 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. |
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);
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.
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.
Hier können alle obigen Schaltpläne (und Sketches) verwendet werden.
zurück