Ratgeber · 11 Min. Lesezeit

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?.

SG90 Servo zittert
SG90-Mikroservo: braun = GND, rot = Versorgung, orange = Signal. Die meisten Zitterprobleme hängen damit zusammen, wie diese drei Kabel versorgt werden.

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.

EigenschaftSG90MG90SMG996R
Betriebsspannung4,8–6 V4,8–6 V4,8–7,2 V
GetriebeKunststoffMetallMetall
Drehmoment (4,8 V)ca. 1,8 kg·cmca. 1,8 kg·cmca. 9,4 kg·cm
Strom bei Bewegung100–250 mA150–300 mA500–900 mA
Blockierstrom (Stall)ca. 650–750 mAca. 0,7–1 Aca. 2,5 A
Empfohlene Quelle (ein Servo)5 V 1 A5 V 1 A6 V 3 A

Symptome und mögliche Ursachen

SymptomMögliche UrsacheErster Schritt
Servo brummt im Stand ständig und zittert leichtVerrauschtes Signal, unruhige Potentiometer-Werte, Anschlag am mechanischen LimitFilter und Totzone im Code ergänzen, Winkelbereich auf 5–175 Grad verkleinern
Arduino resettet, wenn sich der Servo bewegtVersorgungsspannung bricht ein (Brownout)Servo aus einer externen 5–6-V-Quelle versorgen
Servo dreht zufällig von alleinKeine gemeinsame Masse oder Signalkabel offenGND der externen Quelle mit dem Arduino-GND verbinden
Servo springt beim Start plötzlich90-Grad-Befehl direkt bei attach(), Boot-Pins beim ESP32Startwinkel festlegen, beim ESP32 einen sicheren Pin wie GPIO 18 wählen
Servo zittert nur, wenn ein anderes Modul läuftBibliothek sperrt Interrupts oder Timer-KonfliktKonfliktierende Bibliothek finden, notfalls PCA9685-Treiber nutzen
Servo hat am Anschlag Mühe und wird heißImpulsbereich überschreitet die mechanische GrenzeImpulsbereich mit attach(pin, min, max) kalibrieren
360-Grad-Servo dreht im Stand langsamMittelpunkt (ca. 1500 µs) ist verschobenTrimmpoti 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.

Versorge den Servo nicht mit einer 9-V-Blockbatterie oder über den VIN-Pin des Arduino. Eine 9-V-Batterie kann den kurzzeitigen Stromstoß nicht liefern, und ihre Spannung liegt über dem 6-V-Limit des SG90 und kann die Servoelektronik beschädigen. Um einen einzelnen kleinen SG90 ohne Last zu testen, reicht der 5V-Pin meist, aber bei zwei oder mehr Servos oder jeder Anwendung mit Last brauchst du eine externe Quelle.

Richtiger Anschluss: externe Versorgung und gemeinsame Masse

ServokabelArduino UnoESP32Raspberry Pi PicoExterne 5–6-V-Quelle
Braun / schwarz (GND)GNDGNDGNDMinus (-)
Rot (V+)Nicht verbindenNicht verbindenNicht verbindenPlus (+)
Orange / gelb (Signal)D9GPIO 18GP15Nicht verbinden
GND der externen QuelleGND (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.

Verbinde den Pluspol der externen Quelle niemals mit dem 5V-Pin des Arduino; zwei verschiedene Quellen arbeiten sonst gegeneinander und können Strom zurück in den USB-Port speisen. Die einzige Leitung, die du zusammenführst, ist GND. Beim Verdrahten empfiehlt sich diese Reihenfolge: zuerst GND, dann die Versorgung, zuletzt das Signalkabel.

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.

Beim Elko ist das lange Bein plus (+), das Bein auf der Seite mit dem Streifen am Gehäuse ist minus (-). Ein falsch herum angeschlossener Kondensator wird heiß und kann platzen. Um Codes wie „104“ auf Keramikkondensatoren zu entschlüsseln, nutzt du den Kondensatorcode-Rechner; 104 bedeutet 100 nF.

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.

C++ (Arduino IDE)
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 / BefehlWofü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.1Exponentieller 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 = 2Sendet 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:

C++ (Arduino IDE)
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.

MicroPython
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

  1. 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.
  2. Verbinde den GND der externen Quelle mit dem GND von Arduino, ESP32 oder Pico; dieses eine Kabel beendet die meisten „dreht von allein“-Probleme.
  3. Miss die Versorgungsspannung bei Servobewegung mit dem Multimeter; fällt sie unter 4,6 V, nimm eine stärkere Quelle oder dickere Kabel.
  4. Ergänze neben dem Servostecker einen 470–1000-µF-Elko und einen 100-nF-Keramikkondensator und prüfe die Polung.
  5. Kürze das Signalkabel, ergänze bei Bedarf einen 220–470-Ω-Serienwiderstand und sichere die Breadboard-Kontakte.
  6. 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.
  7. Zittert der Servo, wenn ein anderes Modul läuft, finde den Konflikt, indem du die Bibliotheken einzeln deaktivierst; wechsle bei Bedarf zum PCA9685.
  8. 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.

Alle Projekte ansehen
Verwendung von Servomotoren
AR-35Anfänger
Premium

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.

4.7(48)
67
Servomotorbetrieb mit Potentiometer
AR-36Anfänger
Premium

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.

4.6(37)
53
Servo-Steuerung mit Joystick
AR-60Mittel
Premium

Servo-Steuerung mit Joystick

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

4.7(42)
58
ESP32-Servomotor (Steuerung über Potentiometer)
ES-16Mittel
Premium

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.

4.3(29)
42
ESP32-RFID-Türschloss (RC522 + Servo + OLED + Summer + LED)
ES-35Fortgeschritten
Premium

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.

4.8(9)
16
360-Grad-Servo aus einem Schrittmotor bauen
AR-68Mittel
Premium

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.

4.5(22)
33
Servo-Kreis-Choreografie - Animierte Muster mit 32 Servos
AR-97Fortgeschritten
Premium

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.

4.5(40)
62