Servo zittert: Arduino, ESP32 und Pico – Ursachen und Lösungen
Servo zittert, dreht von allein oder der Arduino resettet? So behebst du es mit externem Netzteil, gemeinsamer Masse, Kondensator und ESP32/Pico-PWM.
Ein zitternder Servo gehört zu den häufigsten und nervigsten Fehlern in Arduino-Projekten: Der Servo brummt und zuckt, wo er stillstehen sollte, dreht sich ohne jeden Befehl von allein oder der Arduino startet neu, sobald er sich bewegt, und der Code beginnt von vorn. Die gute Nachricht: Die meisten dieser Symptome kommen nicht von einem defekten Servo, sondern von fünf typischen Ursachen: zu wenig Strom, fehlende gemeinsame Masse (GND), ein fehlender Kondensator, Signalrauschen oder Bibliothekskonflikte.
In dieser Anleitung erfährst du Schritt für Schritt, warum jede Ursache entsteht, wie du sie mit dem Multimeter findest und wie du sie dauerhaft behebst. Du bekommst die Stromberechnung für gängige Servos wie SG90, MG90S und MG996R, den richtigen Schaltplan, Arduino-Code, der das Zittern per Software unterdrückt, die PWM-Einstellungen mit LEDC auf dem ESP32 und die MicroPython-Lösung für den Raspberry Pi Pico. Wenn du die Grundlagen noch nicht kennst, lies zuerst Was ist ein Servomotor?.

Warum zittert ein Servo? So funktioniert er
In einem Hobbyservo stecken ein kleiner Gleichstrommotor, ein Getriebe, ein Potentiometer an der Abtriebswelle und eine Regelschaltung. Der Arduino sendet alle 20 Millisekunden (50 Hz) einen Impuls; seine Breite bestimmt den Winkel: etwa 0,5–1 ms entsprechen 0 Grad, 1,5 ms 90 Grad und 2–2,4 ms 180 Grad. Die Regelschaltung vergleicht den Impuls mit der vom Potentiometer gelesenen Istposition und treibt den Motor bei einer Abweichung in Korrekturrichtung. Wegen dieses geschlossenen Regelkreises behandelt der Servo jede kleine Schwankung der Impulsbreite wie einen neuen Befehl. Verschiebt sich der Impuls um ein paar Mikrosekunden, bricht die Versorgungsspannung ein oder kommen Störungen dazu, korrigiert der Servo ständig – das Brummen und Zittern, das du hörst und siehst. Servos wie der SG90 haben eine Totzone (Deadband) von etwa 10 µs; erst wenn das Signal stärker schwankt, setzt sich der Motor in Bewegung.
| Eigenschaft | SG90 | MG90S | MG996R |
|---|---|---|---|
| Betriebsspannung | 4,8–6 V | 4,8–6 V | 4,8–7,2 V |
| Getriebe | Kunststoff | Metall | Metall |
| Drehmoment (4,8 V) | ca. 1,8 kg·cm | ca. 1,8 kg·cm | ca. 9,4 kg·cm |
| Strom bei Bewegung | 100–250 mA | 150–300 mA | 500–900 mA |
| Blockierstrom (Stall) | ca. 650–750 mA | ca. 0,7–1 A | ca. 2,5 A |
| Empfohlene Quelle (ein Servo) | 5 V 1 A | 5 V 1 A | 6 V 3 A |
Symptome und mögliche Ursachen
| Symptom | Mögliche Ursache | Erster Schritt |
|---|---|---|
| Servo brummt im Stand ständig und zittert leicht | Verrauschtes Signal, unruhige Potentiometer-Werte, Anschlag am mechanischen Limit | Filter und Totzone im Code ergänzen, Winkelbereich auf 5–175 Grad verkleinern |
| Arduino resettet, wenn sich der Servo bewegt | Versorgungsspannung bricht ein (Brownout) | Servo aus einer externen 5–6-V-Quelle versorgen |
| Servo dreht zufällig von allein | Keine gemeinsame Masse oder Signalkabel offen | GND der externen Quelle mit dem Arduino-GND verbinden |
| Servo springt beim Start plötzlich | 90-Grad-Befehl direkt bei attach(), Boot-Pins beim ESP32 | Startwinkel festlegen, beim ESP32 einen sicheren Pin wie GPIO 18 wählen |
| Servo zittert nur, wenn ein anderes Modul läuft | Bibliothek sperrt Interrupts oder Timer-Konflikt | Konfliktierende Bibliothek finden, notfalls PCA9685-Treiber nutzen |
| Servo hat am Anschlag Mühe und wird heiß | Impulsbereich überschreitet die mechanische Grenze | Impulsbereich mit attach(pin, min, max) kalibrieren |
| 360-Grad-Servo dreht im Stand langsam | Mittelpunkt (ca. 1500 µs) ist verschoben | Trimmpoti am Servo drehen oder den Stoppwert feinjustieren |
Ursache 1: Zu wenig Strom und Arduino-Reset
Die häufigste Ursache für Zittern und Resets ist, den Servo über den 5V-Pin des Arduino zu versorgen. Ein SG90 zieht im Leerlauf nur wenige Milliampere, kann aber in den ersten Millisekunden der Bewegung – besonders unter Last oder an einem Hindernis – über 650 mA ziehen. Wird der Arduino Uno über USB versorgt, ist die 5V-Leitung durch den USB-Port des Computers und die 500-mA-Sicherung auf dem Board begrenzt. Bei einem plötzlichen Stromstoß kann die Spannung unter 4 V fallen. Der Brownout-Schutz des ATmega328P greift zwar erst bei etwa 2,7 V, doch da sind Servoelektronik, Sensoren und serielle Kommunikation längst gestört. Bricht die Spannung weit genug ein, startet der Mikrocontroller neu, der Code läuft wieder ab setup(), der Servo fährt wieder in die Startposition, zieht wieder Strom – und du steckst in einer Schleife. Das ist das klassische Beispiel für Arduino resettet sich von selbst.
Das Problem lässt sich leicht bestätigen: Schließe das Multimeter zwischen 5V und GND an und bewege den Servo. Fällt die Spannung unter 4,6 V oder springt der Wert bei jeder Bewegung, liegt es an der Versorgung. Als Lösung versorgst du die Servos separat und rechnest mit dem Blockierstrom: Für einen Roboterarm mit vier SG90 sind das 4 × 0,7 A = 2,8 A, also sind mindestens ein 5-V-3-A-Netzteil oder ein LM2596-Abwärtswandler sinnvoll. Bei kräftigen Servos wie dem MG996R rechnest du 2,5 A pro Servo. Für Batteriebetrieb eignen sich 4 AA-Zellen (ca. 6 V mit Alkaline, 4,8 V mit NiMH) oder 6 V aus einem heruntergeregelten 2S-Li-Ion-Pack; mit dem Batterielaufzeit-Rechner siehst du vorab, wie lange dein Projekt durchhält.
Richtiger Anschluss: externe Versorgung und gemeinsame Masse
| Servokabel | Arduino Uno | ESP32 | Raspberry Pi Pico | Externe 5–6-V-Quelle |
|---|---|---|---|---|
| Braun / schwarz (GND) | GND | GND | GND | Minus (-) |
| Rot (V+) | Nicht verbinden | Nicht verbinden | Nicht verbinden | Plus (+) |
| Orange / gelb (Signal) | D9 | GPIO 18 | GP15 | Nicht verbinden |
| GND der externen Quelle | GND (gemeinsam) | GND (gemeinsam) | GND (gemeinsam) | Minus (-) |
Die wichtigste Zeile in dieser Tabelle ist die letzte. Der Servo misst den Impuls auf dem Signalkabel relativ zu seiner eigenen Masse. Ist der Minuspol der externen Quelle nicht mit dem Arduino-GND verbunden, hat das Signal keinen Bezugspunkt; der Servo liest Streuspannungen auf den Kabeln und Netzstörungen als zufällige Impulse und fängt an, sich von allein zu drehen. Warum die gemeinsame Masse Pflicht ist, erklären wir ausführlich im Beitrag GND und gemeinsame Masse. Arbeitest du auf dem Breadboard, ist das MB102-Netzteilmodul praktisch für die Servoschiene; sein Regler ist in der Praxis aber auf etwa 700–800 mA begrenzt und reicht daher höchstens für ein bis zwei kleine Servos.
Kondensator ergänzen: welcher Wert, wohin?
Auch mit externer Quelle entstehen bei jedem Anlaufen des Servos Stromspitzen von wenigen Millisekunden. Sind die Kabel dünn und lang, erzeugen sie kurze Spannungseinbrüche; die Servoelektronik wird dabei instabil und beginnt zu zittern. Die Lösung ist ein lokaler Energiespeicher in der Servoversorgung: Schließe so nah wie möglich am Servostecker zwischen Plus und Minus einen 470–1000 µF großen Elko (Kondensator) und parallel dazu einen 100-nF-Keramikkondensator an. Der Elko deckt den großen, kurzzeitigen Strombedarf, der Keramikkondensator filtert die hochfrequenten Störungen der Motorbürsten. Die Spannungsfestigkeit sollte mindestens das 1,5- bis 2-Fache der Versorgungsspannung betragen; für eine 5–6-V-Servoleitung passen 10 V oder 16 V. Bei mehreren Servos funktioniert ein eigener 470-µF-Kondensator neben jedem Servo besser als ein einzelner großer.
Signalrauschen und Kabelführung
- Kabel kurz halten: Das Servosignalkabel sollte nicht länger als 50 cm sein. Musst du verlängern, führe Signal- und GND-Kabel miteinander verdrillt (Twisted Pair).
- Serienwiderstand ergänzen: Ein Widerstand von 220–470 Ω zwischen Board-Pin und Servosignal verringert Reflexionen und Klingeln auf langen Leitungen und schützt den Pin vor Kurzschluss.
- Leistung und Signal trennen: Verlege Kabel mit Motor- oder Relaisstrom nicht parallel zur Servosignalleitung; müssen sie sich kreuzen, dann im rechten Winkel.
- Breadboard-Kontakte prüfen: Lose Jumperkabel und ausgeleierte Breadboard-Federn führen zu kurzen Aussetzern; ändert sich das Zittern, wenn du das Kabel berührst, ist der Kontakt die Ursache.
- Potentiometer-Rauschen: Steuerst du den Servo mit einem Potentiometer, schwankt der analogRead-Wert um ein paar Einheiten, und das überträgt sich direkt auf den Winkel. Ein 100-nF-Kondensator zwischen Schleifer und GND sowie ein Filter im Code lösen das.
- 3,3-V-Signal: ESP32 und Pico erzeugen 3,3-V-Impulse. Die meisten Servos wie SG90 und MG996R erkennen sie problemlos; bei einem selten instabilen Servo kann ein Pegelwandler helfen.
Zittern im Code verhindern: Filter und Totzone
Auch bei sauberer Hardware kann die Software den Servo zittern lassen. Die häufigsten Fehler: in loop() bei jedem Durchlauf attach() aufrufen, den rohen Potentiometerwert direkt an write() übergeben und den Servo bis an seine physischen Grenzen (0 oder 180 Grad) treiben. Bei billigen Servos liegt der mechanische Anschlag oft etwas innerhalb von 0 und 180 Grad; der Servo erreicht sein Ziel nicht, drückt ständig weiter, brummt und wird heiß. Der folgende Code trifft drei Maßnahmen gleichzeitig: Er glättet die Messung mit einem exponentiellen Mittelwert, hält den Winkel zwischen 5 und 175 Grad und sendet nur dann einen neuen Befehl, wenn sich der Winkel um mindestens 2 Grad ändert. Mehr zu Filtermethoden findest du im Beitrag Sensordaten filtern.
1#include <Servo.h>
2
3const int SERVO_PIN = 9; // servo sinyal pini / servo signal pin
4const int POT_PIN = A0; // potansiyometre orta ucu / potentiometer wiper
5const int DEADBAND = 2; // derece cinsinden ölü bölge / dead band in degrees
6
7Servo servo;
8float filtered = 0; // filtrelenmiş okuma / filtered reading
9int lastAngle = -1; // son gönderilen açı / last angle sent
10
11void setup() {
12 servo.write(90); // attach öncesi başlangıç açısı (AVR) / start angle before attach (AVR)
13 servo.attach(SERVO_PIN); // yalnızca bir kez / only once
14 filtered = analogRead(POT_PIN);
15}
16
17void loop() {
18 int raw = analogRead(POT_PIN);
19 filtered = filtered * 0.9 + raw * 0.1; // üstel ortalama / exponential moving average
20 int angle = map((int)filtered, 0, 1023, 5, 175); // sınırlara dayanma / stay away from end stops
21
22 if (lastAngle < 0 || abs(angle - lastAngle) >= DEADBAND) {
23 servo.write(angle); // yalnızca belirgin değişimde / only on a real change
24 lastAngle = angle;
25 }
26 delay(15);
27}| Zeile / Befehl | Wofür? |
|---|---|
| servo.write(90) (vor attach) | Sorgt bei der Standard-AVR-Servo-Bibliothek dafür, dass der erste Impuls mit 90 Grad beginnt; das verringert den Sprung beim Start. |
| filtered = filtered * 0.9 + raw * 0.1 | Exponentieller gleitender Mittelwert: unterdrückt plötzliche Schwankungen und lässt langsame Änderungen durch. Je kleiner der Faktor 0.1, desto stärker der Filter, aber desto träger die Reaktion. |
| map(..., 5, 175) | Lässt den Servo laufen, ohne ihn gegen die mechanischen Anschläge zu drücken. |
| DEADBAND = 2 | Sendet keinen neuen Befehl, wenn sich der Winkel um weniger als 2 Grad geändert hat; die Totzone schneidet kleines Zittern ab. |
| delay(15) | Gibt dem Servo Zeit, die neue Position zu erreichen, und begrenzt die Abtastrate. |
| attach(pin, 500, 2400) | Kalibriert den Impulsbereich auf die tatsächlichen Grenzen des Servos; die Standardwerte sind 544 und 2400 µs. |
| servo.detach() | Beendet die Impulse, sobald der Servo sein Ziel erreicht hat; das Brummen verschwindet, aber der Servo verliert sein Haltemoment. |
Bibliotheks- und Timer-Konflikte
Die Standard-Servo-Bibliothek auf dem Arduino Uno erzeugt die Impulse mit dem Hardware-Timer Timer1 und Interrupts. Dieses Design erlaubt es, mit einem einzigen Timer bis zu 12 Servos anzusteuern, hat aber zwei Nebenwirkungen: Sie kann nicht gleichzeitig mit einer anderen Bibliothek laufen, die Timer1 nutzt, und die Genauigkeit der Impulse hängt davon ab, dass Interrupts rechtzeitig ausgeführt werden. Jeder Code, der Interrupts für einige hundert Mikrosekunden sperrt, verlängert den gerade erzeugten Impuls, und der Servo zuckt. Beginnt das Zittern nur, wenn ein bestimmtes Modul aktiv wird, hast du es fast sicher mit genau diesem Fall zu tun.
- analogWrite an Pin 9 und 10: Mit der Servo-Bibliothek funktioniert PWM an diesen beiden Pins des Uno nicht; verlege LED oder Motortreiber an diesen Pins auf Pin 3, 5, 6 oder 11.
- 433-MHz-Funkbibliotheken: VirtualWire und der RH_ASK-Treiber von RadioHead nutzen standardmäßig ebenfalls Timer1; du siehst Kompilierfehler oder unregelmäßige Servobewegungen. Details findest du im Beitrag 433-MHz-Funkmodul.
- NeoPixel-Streifen: Adafruit NeoPixel und FastLED sperren beim Senden der Daten die Interrupts; bei einem langen Streifen dauert das Millisekunden, und der Servo zuckt bei jedem Update. Läuft ein WS2812B zusammen mit einem Servo, aktualisiere den Streifen seltener.
- SoftwareSerial und DHT: Beide sperren beim Empfang von Bytes bzw. beim Auslesen des Sensors kurz die Interrupts; das ist eine häufige Ursache für Zittern bei Servoarmen, die per Bluetooth-Modul gesteuert werden.
- Dauerhafte Lösung: Ein PCA9685-Servotreiber, der die Impulse in eigener Hardware erzeugt; so erreicht bis zu 16 Servos ein zitterfreies Signal, egal was der Arduino gerade tut.
Servo-PWM-Einstellungen auf dem ESP32
Auf dem ESP32 funktioniert die Standard-Servo-Bibliothek von Arduino nicht; stattdessen nutzt du die Bibliothek ESP32Servo oder direkt die eingebaute LEDC-PWM-Einheit. Da LEDC in Hardware arbeitet, bleibt sie von Interrupts unbeeinflusst und erzeugt sehr stabile Impulse; du musst nur die Frequenz auf 50 Hz und die Auflösung auf einen ausreichenden Wert setzen. Bei 14 Bit Auflösung wird die 20-ms-Periode in 16384 Schritte geteilt; jeder Schritt entspricht etwa 1,22 µs – für einen Servo mehr als genau genug. Wir haben 14 Bit gewählt, weil auch neuere Chips wie ESP32-S3 und ESP32-C3 diesen Wert unterstützen. Da sich die LEDC-Funktionen im ESP32-Arduino-Core 3.x geändert haben, ist der folgende Code so geschrieben, dass er mit beiden Versionen kompiliert:
1// ESP32 Arduino core 2.x ve 3.x uyumlu / compatible with ESP32 Arduino core 2.x and 3.x
2const int SERVO_PIN = 18; // güvenli bir GPIO / a safe GPIO
3const int PWM_FREQ = 50; // 50 Hz = 20 ms periyot / 20 ms period
4const int PWM_BITS = 14; // ESP32, S3 ve C3 destekler / supported by ESP32, S3 and C3
5const int MIN_US = 500; // 0 derece darbesi / 0 degree pulse
6const int MAX_US = 2400; // 180 derece darbesi / 180 degree pulse
7
8#if ESP_ARDUINO_VERSION_MAJOR < 3
9const int PWM_CHANNEL = 0; // 2.x için LEDC kanalı / LEDC channel for 2.x
10#endif
11
12uint32_t usToDuty(uint32_t us) {
13 return us * ((1UL << PWM_BITS) - 1) / 20000UL; // mikrosaniyeyi duty değerine çevir / convert microseconds to duty
14}
15
16void servoWriteUs(uint32_t us) {
17#if ESP_ARDUINO_VERSION_MAJOR >= 3
18 ledcWrite(SERVO_PIN, usToDuty(us)); // 3.x: pin numarası / pin number
19#else
20 ledcWrite(PWM_CHANNEL, usToDuty(us)); // 2.x: kanal numarası / channel number
21#endif
22}
23
24void servoWriteAngle(int angle) {
25 angle = constrain(angle, 0, 180);
26 servoWriteUs(map(angle, 0, 180, MIN_US, MAX_US));
27}
28
29void setup() {
30#if ESP_ARDUINO_VERSION_MAJOR >= 3
31 ledcAttach(SERVO_PIN, PWM_FREQ, PWM_BITS);
32#else
33 ledcSetup(PWM_CHANNEL, PWM_FREQ, PWM_BITS);
34 ledcAttachPin(SERVO_PIN, PWM_CHANNEL);
35#endif
36 servoWriteAngle(90); // başlangıç konumu / start position
37}
38
39void loop() {
40 for (int a = 30; a <= 150; a++) { // yumuşak tarama / smooth sweep
41 servoWriteAngle(a);
42 delay(15);
43 }
44 for (int a = 150; a >= 30; a--) {
45 servoWriteAngle(a);
46 delay(15);
47 }
48}Auf dem ESP32 gibt es noch zwei weitere Fallen. Die erste sind die Boot-Pins: Pins wie GPIO 0, 2, 12, 14 und 15 sowie die seriellen Pins 1 und 3 können beim Start kurze Impulse erzeugen; hängt der Servo daran, springt er bei jedem Reset. Für Servos sind GPIO 13, 18, 19, 23, 25, 26, 27, 32 und 33 sichere Wahlen; die Pins 34–39 sind reine Eingänge und können keinen Servo ansteuern. Die zweite ist die Empfindlichkeit der Versorgung: Der ESP32 zieht bei aktivem WLAN ohnehin Stromspitzen über 300 mA, und wird der Servo aus derselben Leitung versorgt, siehst du im seriellen Monitor die Meldung „Brownout detector was triggered“. Die Lösung dafür beschreiben wir im Beitrag ESP32 Brownout und Guru Meditation; kurz gesagt: Servo separat versorgen und die Massen verbinden.
Servo am Raspberry Pi Pico (MicroPython)
Jeder GPIO-Pin des Raspberry Pi Pico kann Hardware-PWM erzeugen; der Chip hat 8 PWM-Slices und insgesamt 16 Kanäle. In MicroPython kannst du nach dem Setzen der Frequenz des PWM-Objekts auf 50 Hz die Impulsbreite mit duty_ns() direkt in Nanosekunden angeben; das ist deutlich sicherer als Prozent- oder 16-Bit-Duty-Berechnungen. Der folgende Code steuert den Servo an GP15 mit dem Potentiometer an GP26 und setzt die Filter- und Totzonenlogik des Arduino-Beispiels unverändert um. Der 3V3-Ausgang des Pico ist weder bei Spannung noch bei Strom für die Servoversorgung geeignet; versorge den Servo aus einer externen 5-V-Quelle und lege die Massen zusammen.
1from machine import Pin, PWM, ADC
2import time
3
4servo = PWM(Pin(15)) # servo sinyali GP15 / servo signal on GP15
5servo.freq(50) # 50 Hz = 20 ms
6pot = ADC(26) # potansiyometre GP26 (ADC0) / potentiometer on GP26 (ADC0)
7
8MIN_US = 500 # 0 derece / 0 degrees
9MAX_US = 2400 # 180 derece / 180 degrees
10DEADBAND = 2 # ölü bölge (derece) / dead band (degrees)
11
12def write_angle(angle):
13 angle = max(5, min(175, angle)) # sınırlara dayanma / stay away from end stops
14 us = MIN_US + (MAX_US - MIN_US) * angle // 180
15 servo.duty_ns(us * 1000) # mikrosaniye -> nanosaniye / microseconds -> nanoseconds
16
17filtered = pot.read_u16()
18last = -100
19write_angle(90) # başlangıç konumu / start position
20
21while True:
22 filtered = filtered * 0.9 + pot.read_u16() * 0.1 # üstel ortalama / exponential moving average
23 angle = int(filtered * 180 / 65535)
24 if abs(angle - last) >= DEADBAND:
25 write_angle(angle)
26 last = angle
27 time.sleep_ms(20)Checkliste Schritt für Schritt
- Trenne den Servo vom Board und versorge ihn nur aus einer externen 5–6-V-Quelle; stelle sicher, dass der Strom der Quelle für die Anzahl der Servos × Blockierstrom reicht.
- Verbinde den GND der externen Quelle mit dem GND von Arduino, ESP32 oder Pico; dieses eine Kabel beendet die meisten „dreht von allein“-Probleme.
- Miss die Versorgungsspannung bei Servobewegung mit dem Multimeter; fällt sie unter 4,6 V, nimm eine stärkere Quelle oder dickere Kabel.
- Ergänze neben dem Servostecker einen 470–1000-µF-Elko und einen 100-nF-Keramikkondensator und prüfe die Polung.
- Kürze das Signalkabel, ergänze bei Bedarf einen 220–470-Ω-Serienwiderstand und sichere die Breadboard-Kontakte.
- Prüfe im Code, dass attach() nur in setup() aufgerufen wird, der Winkel im Bereich 5–175 Grad bleibt und Filter sowie Totzone verwendet werden.
- Zittert der Servo, wenn ein anderes Modul läuft, finde den Konflikt, indem du die Bibliotheken einzeln deaktivierst; wechsle bei Bedarf zum PCA9685.
- Zittert er immer noch, tausche den Servo gegen einen anderen aus; Servos mit verschlissenem Potentiometer oder gebrochenem Zahnrad zittern unter allen Bedingungen.
Worauf du bei Projekten mit Servos achten solltest
- Roboterarm: Bewege bei einem Roboterarm mit vier oder sechs Servos nicht alle gleichzeitig; staffele die Befehle im Abstand von 100–200 ms, damit sich die Stromspitzen nicht addieren.
- Radarprojekt: Bei Dauerscan-Projekten wie dem Arduino-Radar drehst du den Servo Grad für Grad und wartest bei jedem Schritt 15–30 ms; plötzliche große Sprünge bedeuten sowohl Zittern als auch Stromspitzen.
- Schwere Lasten: Bei Türschlössern oder Kameraträgern nimmst du statt des SG90 den MG996R mit Metallgetriebe und wählst eine Quelle mit mindestens 3 A.
- Servos mit Dauerrotation: Wenn 360-Grad-Servos wie der FS90R im Stillstand kriechen, ist das kein Zittern, sondern ein Kalibrierproblem; justiere den Stopp bei etwa 1500 µs fein.
- Batteriebetriebene Projekte: Den Servo nach der Bewegung mit detach() freizugeben beendet das Brummen und verlängert die Batterielaufzeit; das ist sehr wirksam, wenn die Mechanik nicht durch ihr Eigengewicht verrutscht.
Ein zitternder Servo wirkt auf den ersten Blick kompliziert, lässt sich aber fast immer in derselben Reihenfolge lösen: zuerst Strom, dann gemeinsame Masse, dann Kondensator, Verkabelung und zuletzt die Software. Wenn du dieser Reihenfolge folgst, musst du den Servo selbst nur selten tauschen. Details zur Strombilanz findest du in der Anleitung Arduino-Stromversorgung. In der BlueGrays-App findest du Schaltpläne und Code für Projekte wie Servo mit Potentiometer, Servo mit Joystick, ESP32-Servo und RFID-Türschloss und kannst das Gelernte sofort umsetzen.
Häufige Fragen
Warum zittert ein Servomotor?
Die häufigste Ursache für das Zittern eines Servos ist eine zu schwache oder schwankende Versorgungsspannung; wird der Servo über den 5V-Pin des Arduino versorgt, bricht die Spannung bei Stromspitzen ein und die Regelung wird instabil. Außerdem können eine fehlende gemeinsame Masse, ein verrauschtes Signal, unruhige Potentiometer-Werte und das Anfahren des mechanischen Anschlags Zittern verursachen. Eine externe 5–6-V-Quelle, gemeinsame Masse und ein 470–1000-µF-Kondensator lösen die meisten Probleme.
Warum dreht sich mein Servo von allein?
Dreht der Servo ohne Befehl, fehlt meist der Bezug der Signalleitung: Der GND der externen Quelle ist nicht mit dem Arduino-GND verbunden oder das Signalkabel sitzt locker. Der Servo liest dann Störungen auf den Kabeln als Impulse. Bei 360-Grad-Servos kommt langsames Drehen von einer verschobenen Mittelpunkt-Kalibrierung (etwa 1500 µs), die du mit dem Trimmpoti am Servo korrigierst.
Warum resettet der Arduino, wenn der Servo läuft?
Beim Anlaufen zieht ein Servo mehrere hundert Milliampere, bei großen Servos über 2 A. Wird dieser Strom über USB oder den Regler des Arduino gezogen, bricht die 5-V-Spannung ein und der Mikrocontroller startet neu. Versorgst du den Servo aus einer separaten Quelle und verbindest nur die Massen, hört das Resetten auf.
Wie viel µF Kondensator brauche ich für einen Servo?
Für einen einzelnen SG90 oder MG90S sind 470 µF nahe am Servostecker ein guter Start, für große Servos wie den MG996R 1000 µF (Elko). Ein 100-nF-Keramikkondensator daneben filtert zusätzlich hochfrequentes Rauschen. Die Spannungsfestigkeit sollte für eine 5–6-V-Leitung mindestens 10 V betragen, und die Polung muss stimmen.
Kann ich einen Servo über den 5V-Pin des Arduino versorgen?
Um einen einzelnen SG90 ohne Last zu testen, reicht der 5V-Pin meist, zuverlässig ist das aber nicht. Die USB-Leitung ist auf etwa 500 mA begrenzt, und ein blockierender Servo überschreitet diesen Wert. Bei zwei oder mehr Servos, einem Servo mit Last oder einem MG996R nimm unbedingt eine externe Quelle.
Warum zittert mein Servo am ESP32 oder funktioniert nicht?
Auf dem ESP32 funktioniert die Standard-Servo-Bibliothek von Arduino nicht; du brauchst die ESP32Servo-Bibliothek oder LEDC-PWM mit 50 Hz. Hängt der Servo an Boot-Pins wie GPIO 0, 2, 12 oder 15, springt er beim Reset, und eine Versorgung über die ESP32-Leitung führt zu Brownout-Fehlern. Ein sicherer Pin wie GPIO 18 und eine separate 5-V-Quelle lösen das Problem.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Verwendung von Servomotoren
Der Arm eines kleinen Servomotors dreht sich nacheinander in drei Stellungen: ganz an den Anfang, genau in die Mitte und ganz ans Ende, mit jeweils zwei Sekunden Pause.

Servomotorbetrieb mit Potentiometer
Während du am Knopf des Potentiometers drehst, dreht sich der Arm des Servomotors einfach mit: Das eine Ende des Knopfes bedeutet null Grad, das andere eine halbe Umdrehung.

Servo-Steuerung mit Joystick
Steuere zwei Motoren mit einem Joystick, genau wie beim Schwenken einer Überwachungskamera.

ESP32-Servomotor (Steuerung über Potentiometer)
In diesem Projekt steuern wir einen SG90-Servomotor mit einem Potentiometer. Wir stellen den Servowinkel ein, indem wir den vom Potentiometer gelesenen Analogwert auf den Bereich von 0 bis 180 Grad abbilden. Die ESP32Servo-Bibliothek erzeugt Servosignale an geeigneten GPIO-Pins des ESP32, die als Ausgang verwendet werden können; in diesem Projekt wird GPIO 18 verwendet. Dies ist eine grundlegende Steuerungsmethode für Roboterarme, Kamera-Gimbals und automatische Türmechanismen.

ESP32-RFID-Türschloss (RC522 + Servo + OLED + Summer + LED)
Wir bauen ein smartes Türschloss mit ESP32, RFID-Modul RC522, Servo SG90, SSD1306-OLED, aktivem Summer und 2 LEDs. Die UID einer gescannten Karte wird mit den im Code hinterlegten Karten verglichen; passt sie, öffnet der Servo das Schloss (grüne LED + 2 kurze Pieptöne) und verriegelt nach 5 Sekunden wieder. Bei einer fremden Karte leuchtet die rote LED, es piept 3-mal schnell und das OLED zeigt die UID.

360-Grad-Servo aus einem Schrittmotor bauen
Bring einem gewöhnlichen Schrittmotor bei, jeden gewünschten Winkel anzufahren, und zwar rund um den ganzen Kreis.

Servo-Kreis-Choreografie - Animierte Muster mit 32 Servos
Ein visuelles Animationsprojekt mit 32 kreisförmig angeordneten Servomotoren an einem Arduino Mega. Die Servos werden in einem einzigen Array verwaltet, hängen an den Pins 22–53 des Mega und zeigen vier Bewegungsabläufe: ein chaotisches Zittern in zufälligen Winkeln, einen synchronen Schwenk, eine um den Kreis laufende Welle und eine hin und her pendelnde Kompassnadel.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

