DC-Motor, Servo und Schrittmotor: Unterschied und Auswahl

Der Unterschied zwischen DC-Motor, Servomotor und Schrittmotor lässt sich in einem Satz zusammenfassen: Ein DC-Motor dreht sich dauerhaft und schnell, solange er Strom bekommt, ein Servo fährt den gewünschten Winkel an und hält ihn, und ein Schrittmotor dreht sich in kleinen, zählbaren Schritten. Willst du also ein Rad antreiben, nimmst du einen DC-Motor; soll sich eine Klappe um 90 Grad öffnen, einen Servo; soll ein Teil auf einen Zehntelmillimeter genau verfahren werden, einen Schrittmotor. Überall, wo sich in einem Arduino-, ESP32- oder Raspberry-Pi-Pico-Projekt etwas bewegt, begegnet dir einer dieser drei Motoren.

In diesem Ratgeber vergleichen wir, was in den drei Motoren steckt, echte Werte für Drehzahl, Drehmoment und Positioniergenauigkeit beliebter Modelle (TT-Motor, SG90, MG996R, 28BYJ-48, NEMA 17), welchen Treiber jeder braucht (L298N, PWM-Signal, ULN2003, A4988), wie viel Strom sie ziehen und welcher Motor in welchem Projekt eingesetzt wird. Am Ende findest du Code für Arduino, ESP32 und Pico, der alle drei gleichzeitig ansteuert, eine kurze Einführung in bürstenlose Motoren (BLDC) und ESCs sowie die häufigsten Fehler.

Kurze Antwort: die drei Motoren in einer Tabelle

Die wichtigste Zeile der Tabelle ist die Rückmeldung. Ein Servo weiß dank seines Potentiometers, wo er steht, und kehrt in seine Position zurück, wenn ihn etwas wegdrückt. Ein Schrittmotor weiß nicht, wo er steht; du zählst nur, wie viele Schritte er gemacht hat, und diese Zahl stimmt, solange der Motor nicht überlastet wird und keine Schritte verliert. Ein DC-Motor weiß überhaupt nicht, wie weit er sich gedreht hat; brauchst du die Position, musst du einen Encoder an seiner Welle anbringen. Welchen Motor du wählst, hängt also stark davon ab, ob dein Projekt diese Information braucht.

Wie funktioniert ein DC-Motor?

Fast alle DC-Motoren in Bastelprojekten sind Bürstenmotoren. Im Inneren sitzen feste Magnete und eine drehende Spule (der Rotor); Kohlebürsten und ein Kommutator aus Kupfersegmenten polen den Strom beim Drehen um, sodass sich der Rotor ständig weiterdreht. Der Motor hat zwei Anschlüsse: Legst du Spannung an, dreht er sich, tauschst du die Anschlüsse, dreht er andersherum. Die Spannung bestimmt die Drehzahl, der Strom bestimmt das Drehmoment. Während der Motor läuft, entsteht in den Spulen eine Gegenspannung, die Gegen-EMK, die den Strom begrenzt; wird die Welle blockiert, fällt diese Gegenspannung weg und der Strom steigt auf den Blockierstrom.

Ein kleiner DC-Motor ohne Getriebe dreht mit tausenden Umdrehungen, hat aber sehr wenig Drehmoment; deshalb nutzen Roboter immer Getriebemotoren. Das 1:48-Getriebe im TT-Motor senkt rund 12.000 U/min an der Motorwelle auf 250 U/min am Rad und vervielfacht dabei das Drehmoment etwa um den Faktor 48 (abzüglich der Getriebeverluste). Die Drehzahl änderst du per PWM, die Richtung mit einer H-Brücke; Details findest du in DC-Motor mit dem L298N steuern. Die Schwäche des DC-Motors ist die Position: Derselbe PWM-Wert ergibt je nach Akkuspannung und Last eine andere Drehzahl, deshalb führt der Befehl "2 Sekunden vorwärts" jedes Mal zu einer anderen Strecke. Brauchst du eine exakte Strecke, kommt ein Encoder ans Rad.

Wie funktioniert ein Servomotor?

Ein Servomotor ist eigentlich ein komplettes System in einem kleinen Gehäuse: ein DC-Motor, ein Getriebe, das die Drehzahl senkt und das Drehmoment erhöht, ein Potentiometer an der Abtriebswelle und eine Steuerplatine. Der Arduino schickt dem Servo keinen Winkel, sondern einen Impuls mit 50 Hz (alle 20 ms); die Breite des Impulses beschreibt die gewünschte Position. Die Steuerplatine vergleicht diesen Sollwert mit der tatsächlichen Position, die sie vom Potentiometer liest, und treibt den Motor so lange in diese Richtung, bis die Abweichung null ist. Das nennt man Regelung im geschlossenen Regelkreis, und deshalb wehrt sich ein Servo, wenn du ihn von Hand verdrehen willst.

Der Standard-RC-Bereich ist 1–2 ms, doch die meisten günstigen Servos wie der SG90 brauchen für volle 180° etwa 0,5–2,4 ms; auch die Arduino-Servo-Bibliothek nutzt standardmäßig 544–2400 µs. Das Totband des SG90, also die kleinste Änderung, auf die er reagiert, liegt bei etwa 10 µs, was ungefähr 1° entspricht; die praktische Genauigkeit eines Servos liegt deshalb bei rund einem Grad. Ein endlos drehender Servo (FS90R) ist ein Servo mit abgeschalteter Rückmeldung: Du steuerst Drehzahl und Richtung statt des Winkels, die Positionsinformation geht verloren. Brauchst du mehr Kraft, ist der MG996R mit Metallgetriebe die Standardwahl; die Grundlagen findest du in Was ist ein Servomotor?

Wie funktioniert ein Schrittmotor?

Ein Schrittmotor hat keine Bürsten. Die Spulen im Gehäuse werden in einer festen Reihenfolge bestromt, und der magnetische Rotor macht jedes Mal einen einzigen Schritt zur nächsten Spule. Die gängigsten Hybrid-Schrittmotoren haben 200 Schritte pro Umdrehung, also 1,8° pro Schritt. Schickst du eine bestimmte Zahl an Impulsen, macht er genau so viele Schritte; schickst du sie schneller, dreht er schneller. Solange die Spulen bestromt sind, bleibt der Motor an seiner Stelle arretiert; das nennt man Haltemoment. Der entscheidende Unterschied: Ein Schrittmotor arbeitet im offenen Regelkreis. Übersteigt die Last sein Drehmoment, verliert er Schritte, und der Arduino bemerkt das nicht. Deshalb fahren 3D-Drucker beim Start jede Achse an einen Endschalter (Referenzfahrt).

Du triffst auf zwei Arten von Schrittmotoren. Unipolare Motoren (28BYJ-48, 5 Kabel) haben einen gemeinsamen Spulenanschluss und werden mit einem einfachen Transistor-Array wie dem ULN2003 angesteuert. Bei bipolaren Motoren (NEMA 17, 4 Kabel) muss die Stromrichtung in den Spulen umgekehrt werden; das übernehmen strombegrenzende Treiber wie A4988, DRV8825 oder TMC2209. Diese Treiber beherrschen auch Mikroschritte: Der A4988 teilt jeden Vollschritt in 16 Teile, erhöht so die Schritte pro Umdrehung auf 3200 und macht die Bewegung viel leiser und ruhiger. Mehr dazu in 28BYJ-48 und ULN2003 und A4988 Schrittmotortreiber.

Drehzahl, Drehmoment und Genauigkeit in Zahlen

Das Drehmoment wird meist in kg·cm angegeben: Ein Motor mit 1 kg·cm hält eine Last von 1 kg in 1 cm Abstand zur Welle, in 2 cm Abstand aber nur noch 0,5 kg (1 kg·cm ≈ 0,098 N·m). Ein MG996R liefert bei 6 V zum Beispiel 11 kg·cm; am Ende eines 15 cm langen Arms hält er theoretisch 11 / 15 ≈ 0,73 kg. Das ist allerdings das maximale Drehmoment im blockierten Zustand, und das Eigengewicht des Arms kommt noch zur Last hinzu. Eine gute Regel für eine lange Lebensdauer ist, unter der Hälfte dieses Werts zu bleiben; am Ende dieses Arms kannst du also praktisch einige hundert Gramm bewegen.

Bei der Drehzahl dreht sich die Reihenfolge um. Der DC-Motor ist mit Abstand der schnellste. Ein SG90 schafft eine 180°-Bewegung in etwa 0,3 Sekunden und kann nicht schneller. Beim Schrittmotor sinkt das Drehmoment mit steigender Drehzahl, weil der Spulenstrom pro Schritt keine Zeit hat, voll anzusteigen; ein 28BYJ-48 beginnt oberhalb von etwa 15 U/min Schritte zu verlieren. Versorgst du einen NEMA 17 am A4988 mit 24 V statt 12 V, bekommst du bei hohen Drehzahlen mehr Drehmoment, weil der Treiber den Strom ohnehin begrenzt. Bei der Genauigkeit liegt dafür der Schrittmotor vorn: Ein NEMA 17 bietet im Vollschritt 1,8° und auf dem Papier 0,1125° bei 1/16-Mikroschritt. Kleiner Hinweis: Das interne Getriebe des 28BYJ-48 hat nicht genau 1:64, sondern etwa 1:63,68; eine echte Umdrehung hat daher etwa 2038 statt 2048 Schritte. Bei dauerhaft drehenden Projekten wie Uhren summiert sich dieser Unterschied.

Welcher Motor braucht welchen Treiber?

Ein Arduino-Pin liefert höchstens 40 mA, die sichere Grenze liegt bei etwa 20 mA; selbst ein kleiner TT-Motor zieht im Leerlauf etwa das 7-Fache und blockiert mehr als das 70-Fache. Außerdem erzeugt eine Motorspule beim Abschalten eine hohe Gegenspannungsspitze, die einen ungeschützten Pin zerstören kann. Deshalb sitzt zwischen Motor und Board immer ein Treiber: Das Board liefert nur kleine Steuersignale, der Motorstrom fließt direkt von der Stromversorgung über den Treiber. In Treibern stecken Transistoren und Dioden, die die Gegenspannung abfangen. Für einen Lüfter oder eine Pumpe, die nur in eine Richtung laufen, reicht ein einzelner MOSFET.

Stromverbrauch: wie viel Strom zieht welcher Motor?

Beim Strom verhalten sich die drei Motoren sehr unterschiedlich, und danach musst du die Stromversorgung auswählen. Ein DC-Motor zieht mit steigender Last mehr Strom; beim Anlaufen und wenn ein Rad klemmt, nähert er sich dem Blockierstrom. Dimensioniere die Versorgung für diesen Spitzenstrom, nicht für den Leerlaufstrom. Ein Servo braucht im Stand sehr wenig, erzeugt aber bei jeder Bewegung kurze, harte Stromspitzen: Schon ein einzelner SG90 kann kurzzeitig über 0,5 A ziehen, ein MG996R unter Last bis zu 2,5 A. Diese Spitzen lassen die Spannung einbrechen und setzen den Arduino zurück oder lösen beim ESP32 einen Brownout-Fehler aus. Durch die Spulen eines Schrittmotors fließt dagegen auch dann Strom, wenn er sich gar nicht bewegt: Ein 28BYJ-48 zieht im Stillstand 150–200 mA und wird warm. Brauchst du in batteriebetriebenen Projekten kein Haltemoment, verlängert das Abschalten der Spulen (beim A4988 den EN-Pin auf HIGH setzen) die Akkulaufzeit erheblich.

• Getrennte Versorgung nutzen: Versorge Motoren nicht über den 5V-Pin des Arduino. Ein USB-Port liefert etwa 500 mA, und einen Teil davon braucht das Board selbst; außer einem einzelnen kleinen Servo braucht jeder Motor eine eigene Quelle.
• Masse verbinden: Der Minuspol der Motorversorgung muss unbedingt mit GND des Boards verbunden sein, sonst fehlt dem Steuersignal der Bezug (siehe gemeinsame Masse).
• Kondensatoren einbauen: Setze einen 470–1000-µF-Elko an die Servoversorgung, mindestens 47 µF an den VMOT-Eingang des A4988 und einen 100-nF-Keramikkondensator direkt an die Anschlüsse eines Bürstenmotors. Der erste verhindert Spannungseinbrüche, der letzte dämpft die Störungen der Bürsten.
• Versorgung nach dem Spitzenstrom wählen: Ein Roboterarm mit 4 Servos braucht zum Beispiel ein 5–6-V-Netzteil mit mindestens 3 A, ein Auto mit zwei TT-Motoren einen Akkupack, der 2 × 1,5 A verkraftet. Wie lange der Akku hält, berechnest du mit dem Akkulaufzeit-Rechner.
• Spannung richtig absenken: Brauchst du aus einem 7,4-V-Pack 5–6 V für die Servos, nimm einen Schaltregler wie den LM2596; Linearregler wie der 7805 werden bei Strömen im Ampere-Bereich sehr heiß.

Alle drei Motoren an einem Arduino: Schritt für Schritt

Am besten siehst du den Unterschied, wenn alle drei nebeneinander laufen. In der folgenden Schaltung wird ein TT-Motor vom L298N angesteuert, ein SG90 direkt von einem Pin und ein 28BYJ-48 von einer ULN2003-Platine. Die Pin-Tabelle passt zu allen drei Codebeispielen für Arduino Uno, ESP32 und Raspberry Pi Pico.

1. Zieh den ENA-Jumper am L298N ab; verbinde ENA, IN1 und IN2 mit den Pins aus der Tabelle und den DC-Motor mit den Klemmen OUT1 und OUT2. Schließe die Motorversorgung (zum Beispiel zwei 18650-Zellen in Reihe, 7,4 V) an die 12V-Klemme an.
2. Verbinde das braune Servokabel mit GND, das rote mit einer separaten 5–6-V-Quelle und das orange Signalkabel mit D9.
3. Steck den weißen Stecker des 28BYJ-48 in die ULN2003-Platine, verbinde IN1–IN4 mit D10–D13 und versorge den +-Anschluss der Platine mit 5 V.
4. Verbinde die Minuspole aller Quellen und GND des Arduino miteinander.
5. Lade den Code mit der Arduino IDE hoch; die Bibliotheken Servo und Stepper sind in der IDE enthalten und müssen nicht extra installiert werden.
6. Schalte die Motorversorgungen ein und beobachte, wie sich die drei Motoren nacheinander verhalten.

1#include <Servo.h>
2#include <Stepper.h>
3
4// DC motor (L298N): ENA=5, IN1=7, IN2=8
5const int ENA = 5;                 // PWM; Servo kütüphanesi 9 ve 10'un PWM'ini kapatır / Servo library disables PWM on 9 and 10
6const int IN1 = 7;
7const int IN2 = 8;
8
9const int SERVO_PIN = 9;           // servo sinyali / servo signal
10Servo servo;
11
12const int STEPS_PER_REV = 2048;    // 28BYJ-48 tam tur / full revolution
13Stepper stepper(STEPS_PER_REV, 10, 12, 11, 13);   // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
14
15void releaseStepper() {            // bobinleri bırak, boşta akım çekmesin / release coils, no idle current
16  for (int pin = 10; pin <= 13; pin++) {
17    digitalWrite(pin, LOW);
18  }
19}
20
21void setup() {
22  pinMode(ENA, OUTPUT);
23  pinMode(IN1, OUTPUT);
24  pinMode(IN2, OUTPUT);
25  servo.attach(SERVO_PIN);
26  stepper.setSpeed(10);            // devir/dakika, 28BYJ-48 için en fazla ~15 / RPM, max ~15 for 28BYJ-48
27}
28
29void loop() {
30  // 1) DC motor: hız ve yön, konum yok / speed and direction, no position
31  digitalWrite(IN1, HIGH);
32  digitalWrite(IN2, LOW);
33  analogWrite(ENA, 180);           // yaklaşık %70 güç / about 70% power
34  delay(2000);
35  analogWrite(ENA, 0);             // motoru serbest bırak / let the motor coast
36  delay(500);
37
38  // 2) Servo: açı ver, gidip orada kalsın / give an angle, it goes there and holds
39  servo.write(0);
40  delay(600);
41  servo.write(180);
42  delay(600);
43  servo.write(90);
44  delay(600);
45
46  // 3) Step motor: tam çeyrek tur ileri ve geri / exactly a quarter turn forward and back
47  stepper.step(STEPS_PER_REV / 4);   // 512 adım = 90° / 512 steps = 90°
48  delay(500);
49  stepper.step(-STEPS_PER_REV / 4);
50  releaseStepper();
51  delay(1000);
52}

Wenn du den Code startest, ist der Unterschied deutlich zu sehen: Der DC-Motor dreht zwei Sekunden lang, aber seine Welle bleibt jedes Mal an einer anderen Stelle stehen. Der Servo springt auf 0°, 180° und 90° und wehrt sich, wenn du ihn von Hand drehen willst. Der Schrittmotor fährt langsam genau eine Vierteldrehung und kehrt an denselben Punkt zurück; nach dem Aufruf von releaseStepper() lässt sich seine Welle leicht von Hand drehen. Die Funktion step() der Stepper-Bibliothek blockiert den Code, bis die Bewegung fertig ist; willst du mehrere Motoren gleichzeitig und mit sanfter Beschleunigung fahren, wechsle zur Bibliothek AccelStepper.

DC-Motor, Servo und Schrittmotor mit dem ESP32

Die Pins des ESP32 liefern 3,3 V; die Eingänge von L298N und ULN2003 erkennen diesen Pegel als HIGH, und auch Servos funktionieren mit einem 3,3-V-Signal. Die Motoren brauchen trotzdem eine eigene Versorgung. Der Unterschied liegt beim Servo: Die Standard-Servo-Bibliothek von Arduino unterstützt den ESP32 nicht. Entweder installierst du die Bibliothek ESP32Servo, oder du erzeugst das 50-Hz-Signal wie unten selbst mit der Hardware-PWM-Einheit des ESP32, LEDC. Da wir zwei verschiedene Frequenzen nutzen, 1 kHz für den DC-Motor und 50 Hz für den Servo, legen wir die Kanäle mit ledcAttachChannel auf getrennte Timer (Kanal 0 und 2); in manchen Core-Versionen teilen sich benachbarte Kanäle denselben Timer. Der Code ist für den ESP32 Arduino Core 3.x; in 2.x-Versionen nutzt du stattdessen ledcSetup und ledcAttachPin. Die Stepper-Bibliothek läuft auf dem ESP32 unverändert; bist du neu beim ESP32, schau dir Was ist der ESP32? an.

1#include <Stepper.h>
2
3// ESP32 Arduino çekirdeği 3.x / ESP32 Arduino core 3.x
4const int ENA = 25;                // L298N hız (PWM) / L298N speed (PWM)
5const int IN1 = 26;
6const int IN2 = 27;
7const int SERVO_PIN = 18;          // servo sinyali / servo signal
8
9const int STEPS_PER_REV = 2048;
10Stepper stepper(STEPS_PER_REV, 19, 22, 21, 23);   // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
11
12void motor(int speed) {            // -255 … 255
13  digitalWrite(IN1, speed > 0);
14  digitalWrite(IN2, speed < 0);
15  ledcWrite(ENA, abs(speed));
16}
17
18void servoWrite(int angle) {       // 0 … 180
19  int us = map(angle, 0, 180, 500, 2400);              // açı → darbe (µs) / angle → pulse (µs)
20  ledcWrite(SERVO_PIN, (uint32_t)us * 65535 / 20000);  // 20 ms içindeki pay / share of the 20 ms period
21}
22
23void setup() {
24  pinMode(IN1, OUTPUT);
25  pinMode(IN2, OUTPUT);
26  ledcAttachChannel(ENA, 1000, 8, 0);        // kanal 0: 1 kHz, 8 bit (0–255) / channel 0: 1 kHz, 8-bit
27  ledcAttachChannel(SERVO_PIN, 50, 16, 2);   // kanal 2, ayrı zamanlayıcı: 50 Hz, 16 bit / channel 2, separate timer: 50 Hz, 16-bit
28  stepper.setSpeed(10);                      // devir/dakika / RPM
29}
30
31void loop() {
32  motor(200);         delay(2000);   // DC: ileri / forward
33  motor(0);           delay(500);    // DC: dur / stop
34  servoWrite(0);      delay(600);    // servo: 0°
35  servoWrite(180);    delay(600);    // servo: 180°
36  servoWrite(90);     delay(600);    // servo: 90°
37  stepper.step(512);  delay(500);    // step: çeyrek tur / quarter turn
38  stepper.step(-512); delay(1000);
39}

MicroPython-Code für den Raspberry Pi Pico

Beim Pico kann jeder GP-Pin PWM ausgeben. In MicroPython stellst du mit duty_u16() die Drehzahl des DC-Motors zwischen 0 und 65535 ein und mit duty_ns() die Impulsbreite des Servos in Nanosekunden. Den Schrittmotor drehst du, indem du die Halbschrittfolge nacheinander auf vier Pins schreibst; im Halbschrittbetrieb hat eine Umdrehung des 28BYJ-48 4096 Schritte. Bist du neu beim Pico, beginne mit Was ist der Raspberry Pi Pico?

1from machine import Pin, PWM
2import time
3
4# DC motor (L298N): ENA=GP15, IN1=GP14, IN2=GP13
5ena = PWM(Pin(15))
6ena.freq(1000)
7in1 = Pin(14, Pin.OUT)
8in2 = Pin(13, Pin.OUT)
9
10# Servo: GP16, 50 Hz
11servo = PWM(Pin(16))
12servo.freq(50)
13
14# Step motor (ULN2003): IN1–IN4 = GP2–GP5
15coils = [Pin(n, Pin.OUT) for n in (2, 3, 4, 5)]
16SEQ = [(1,0,0,0), (1,1,0,0), (0,1,0,0), (0,1,1,0),
17       (0,0,1,0), (0,0,1,1), (0,0,0,1), (1,0,0,1)]   # yarım adım dizisi / half-step sequence
18
19def motor(speed):                    # -100 … 100
20    in1.value(speed > 0)
21    in2.value(speed < 0)
22    ena.duty_u16(int(abs(speed) * 655.35))
23
24def servo_angle(angle):              # 0 … 180
25    us = 500 + angle * 1900 // 180   # 500–2400 µs
26    servo.duty_ns(us * 1000)
27
28phase = 0                            # dizideki konum, çağrılar arasında korunur / position in the sequence, kept between calls
29
30def step(steps, delay_ms=2):         # yarım adımda 4096 adım = 1 tur / 4096 half-steps = 1 turn
31    global phase
32    d = 1 if steps > 0 else -1
33    for _ in range(abs(steps)):
34        phase = (phase + d) % 8
35        for pin, v in zip(coils, SEQ[phase]):
36            pin.value(v)
37        time.sleep_ms(delay_ms)
38    for pin in coils:
39        pin.value(0)                 # bobinleri bırak / release coils
40
41while True:
42    motor(70)                        # DC: %70 ileri / 70% forward
43    time.sleep(2)
44    motor(0)                         # DC: dur / stop
45    time.sleep(0.5)
46    for a in (0, 180, 90):           # servo: üç açı / three angles
47        servo_angle(a)
48        time.sleep(0.6)
49    step(1024)                       # step: çeyrek tur / quarter turn
50    time.sleep(0.5)
51    step(-1024)
52    time.sleep(1)

Welcher Motor für welches Projekt?

In manchen Projekten taugen beide Motoren, und die Wahl hängt von Details ab. Bei einem Roboterauto reichen DC-Motoren für die Räder; soll das Auto aber genau 50 cm fahren, rüstest du Encoder nach oder treibst die Räder mit Schrittmotoren an. Beim Roboterarm sind Servos der einfachste Weg; schwere und präzise Arme nutzen Schrittmotoren mit Getriebe in den Gelenken. Beim 3D-Drucker lässt sich leicht ausrechnen, wie viele Schritte eine Achse pro Millimeter braucht: Mit einem 200-Schritt-Motor, 1/16-Mikroschritt und einem GT2-Riemenrad mit 20 Zähnen (2 mm Teilung) ergibt sich 200 × 16 / (20 × 2) = 80 Schritte/mm; bei einer T8-Trapezgewindespindel mit 8 mm Steigung sind es 200 × 16 / 8 = 400 Schritte/mm. Bei Projekten mit einem Schwenk von 0–180° wie einem Radar oder einem Solartracker ist der Servo die günstigste und einfachste Lösung.

Kurze Einführung in bürstenlose Motoren (BLDC) und ESCs

Beim bürstenlosen Gleichstrommotor (BLDC) ist der Aufbau umgekehrt: Die Magnete sitzen am drehenden Teil, die Spulen im feststehenden Gehäuse. Ohne Bürsten und Kommutator gibt es keine Reibung, keine Funken und keinen Verschleiß; der Motor ist effizienter, leiser und hält viel länger. Der Preis dafür: Die Stromrichtung muss jetzt eine Elektronik umschalten statt der Bürsten. Deshalb haben BLDC-Motoren 3 Kabel und drehen sich nicht, wenn du sie direkt an einen Akku hängst. Bei Modellbaumotoren wird die Drehzahl über den KV-Wert angegeben, die Leerlaufdrehzahl pro Volt. Ein Motor mit 1000 KV (z. B. A2212) dreht an einem 3S-LiPo (11,1 V) ohne Last etwa 11.100 U/min. Drohnen, RC-Flugzeuge, E-Skateboards und E-Scooter, PC-Lüfter und Festplatten nutzen alle bürstenlose Motoren.

Um einen BLDC-Motor an den Arduino anzuschließen, brauchst du einen ESC (Electronic Speed Controller, elektronischer Drehzahlregler). Der ESC wandelt die Gleichspannung des Akkus in dreiphasige Impulse für den Motor um; sensorlose ESCs schätzen die Rotorposition aus der Gegen-EMK in der gerade unbestromten Spule. Das Schöne daran: Der Steuereingang des ESC ist derselbe wie beim Servo. Bei 50-Hz-Impulsen bedeuten 1000 µs Stopp und 2000 µs Vollgas. Die Strombelastbarkeit des ESC (z. B. 30 A) muss höher sein als der maximale Strom des Motors, und die meisten ESCs haben einen BEC-Ausgang, der 5 V liefert. Aus Sicherheitsgründen will ein ESC beim Einschalten zuerst Minimalgas sehen; das nennt man Arming (Scharfschalten), und ohne dieses Signal dreht er den Motor nicht. Im folgenden Code hängt das Signalkabel des ESC an D9 und der Schleifer des Potentiometers für das Gas an A0.

1#include <Servo.h>
2
3Servo esc;                         // ESC bir servo gibi sürülür / an ESC is driven like a servo
4const int POT_PIN = A0;            // gaz potansiyometresi / throttle potentiometer
5
6void setup() {
7  esc.attach(9, 1000, 2000);       // 1000–2000 µs aralığı / 1000–2000 µs range
8  esc.writeMicroseconds(1000);     // en düşük gaz: ESC'yi kur (arming) / minimum throttle: arm the ESC
9  delay(3000);                     // bip seslerini bekle / wait for the beeps
10}
11
12void loop() {
13  int throttle = map(analogRead(POT_PIN), 0, 1023, 1000, 2000);   // pot → gaz / pot → throttle
14  esc.writeMicroseconds(throttle);
15  delay(20);                       // bir servo periyodu / one servo period
16}

Häufige Fehler und Lösungen

• Der Arduino startet neu, sobald der Motor läuft: Motor oder Servo hängen am 5V-Pin des Boards. Nutze eine separate Quelle, verbinde die Massen und setze einen großen Kondensator an die Versorgung.
• Der Servo zittert oder springt: Die Quelle ist zu schwach, die Kabel sind dünn und lang oder die Masse ist nicht gemeinsam. Versorge den Servo aus einer 5–6-V-Quelle, die mindestens 1 A liefert.
• Mit Servo ändert sich die Drehzahl des DC-Motors nicht: ENA hängt beim Uno an Pin 9 oder 10, und die Servo-Bibliothek schaltet dort PWM ab. Leg ENA auf 3, 5, 6 oder 11.
• Der DC-Motor dreht bei niedrigen PWM-Werten nicht, er brummt nur: Die Leistung reicht nicht, um die Haftreibung zu überwinden. Starte den Motor kurz mit einem hohen Wert und senke dann die Drehzahl, oder halte den Mindestwert bei etwa 80–100. Denk auch an den Spannungsabfall des L298N von etwa 2 V.
• Der Schrittmotor vibriert, dreht sich aber nicht: Die Spulenreihenfolge ist falsch oder die Drehzahl zu hoch. Nutze für den 28BYJ-48 die Reihenfolge Stepper(2048, IN1, IN3, IN2, IN4) und bleib unter 15 U/min.
• Der Schrittmotor verliert Schritte: Die Last ist zu schwer, die Beschleunigung zu hart oder die Strombegrenzung des A4988 zu niedrig. Stell Vref mit der Formel I = Vref / (8 × Rcs) ein, wobei Rcs der Strommesswiderstand auf der Platine ist, und nutze mit AccelStepper eine sanfte Beschleunigung.
• Der A4988 ist durchgebrannt: Das Motorkabel wurde bei eingeschaltetem Treiber ein- oder ausgesteckt, Vref war zu hoch oder am VMOT-Eingang fehlte der Kondensator. Schließe den Motor immer im stromlosen Zustand an.
• Der ESC dreht den Motor nicht und piept ständig: Beim Einschalten kam kein Minimalgas-Signal. Achte darauf, dass setup() writeMicroseconds(1000) sendet und einige Sekunden wartet; kalibriere den ESC bei Bedarf wie in seiner Anleitung beschrieben.

Kurz gesagt steht der DC-Motor für Drehzahl, der Servo für Winkel und der Schrittmotor für Position; kombinierst du den richtigen Motor mit dem richtigen Treiber, ist dein Projekt schon halb gelöst. Am leichtesten lernst du alle drei, wenn du mit einem SG90 und einem TT-Motor anfängst und danach zum Schrittmotor wechselst. In der BlueGrays-App findest du Projekte zu Servo-Grundlagen, Servosteuerung per Potentiometer, Schrittmotor-Grundlagen, einem 360-Grad-Servo aus einem Schrittmotor, einem per Bluetooth gesteuerten Auto mit L298N und einem Roboter, der Hindernissen ausweicht, jeweils Schritt für Schritt mit Schaltplan und Code.