Servo am Arduino

Ein Modellbauservo ist ein kleiner Getriebemotor mit eingebauter Regelung: Du gibst ihm einen Winkel vor, und er fährt dorthin und hält die Position gegen Last. Damit bewegst du Klappen, Zeiger, Greifer, Weichen auf der Modellbahn oder Kameraschwenks. Angeschlossen wird er über drei Leitungen, und der Mikrocontroller muss nur ein Pulssignal liefern. Die meisten Probleme entstehen nicht beim Signal, sondern bei der Versorgung.

Hier schließt du einen SG90 so an einen Arduino Uno an, dass er ruhig steht und den Arduino nicht in den Neustart treibt. Die Hinweise gelten genauso für den ESP32 und für größere Servos wie den MG996R.

Schaltplan

• M1, Servo SG90: Mikroservo für 4,8 bis 6 V. Die Anschlussleitung ist braun (GND), rot (V+) und orange (Signal); bei anderen Herstellern schwarz, rot und weiß oder gelb.
• R1, 220 Ω: schützt Pin und Servo, falls der Servo stromlos ist, während der Arduino läuft. Ohne ihn würde der Pin die Elektronik des Servos über dessen Eingang mitversorgen.
• C1, 470 µF: ein Elko direkt an den Servoanschlüssen. Er liefert die Stromspitzen beim Anlaufen.
• Netzteil 5 V, 2 A: versorgt nur die Servos. Bei bis zu vier Mikroservos tut es auch ein USB-Netzteil.
• Gemeinsame Masse: GND von Netzteil, Servo und Arduino sind verbunden. Das Signal braucht diesen Bezug.

So funktioniert die Schaltung

Der Servo erwartet alle 20 ms einen Puls, also mit 50 Hz. Nicht die Frequenz trägt die Information, sondern die Länge des Pulses: Nach der Norm aus dem Modellbau bedeuten 1,5 ms die Mittelstellung, 1,0 und 2,0 ms die beiden Endlagen. Im Servo vergleicht eine kleine Schaltung diese Pulslänge mit der Stellung eines Potentiometers auf der Abtriebswelle. Weicht beides voneinander ab, treibt sie den Gleichstrommotor über das Getriebe so lange, bis es passt.

Viele billige Servos fahren mit 1,0 bis 2,0 ms nur rund 90°. Für den vollen Weg von etwa 180° brauchen sie 0,5 bis 2,5 ms. Die Arduino-Bibliothek Servo rechnet deshalb write(0) in 544 µs und write(180) in 2400 µs um. Fährt dein Servo damit gegen den mechanischen Anschlag und brummt, engst du den Bereich ein.

Das Signal ist ein Logiksignal mit wenigen Mikroampere. Der Strom für den Motor fließt dagegen über die rote Leitung, und er ist stark schwankend: Im Stillstand zieht ein SG90 etwa 10 mA, beim Fahren 100 bis 250 mA, und blockiert oder beim Anlaufen bis zu 0,7 A. Diese Spitzen brechen eine schwache Versorgung ein. Hängt der Arduino an derselben Leitung, setzt ihn der Spannungseinbruch zurück, oder der Servo zittert, weil seine eigene Regelung aus dem Takt kommt.

Dimensionierung

1. Netzteil. Rechne mit dem Blockierstrom aller Servos, die gleichzeitig fahren können. Für zwei SG90:

Ein 5-V-Netzteil mit 2 A reicht. Ein MG996R zieht blockiert bis 2,5 A; zwei davon brauchen 6 A. Am 5-V-Pin des Uno stehen über USB höchstens 500 mA für alles zur Verfügung – zu wenig schon für einen Servo unter Last.

2. Pufferelko. Die Leitung zum Netzteil und sein Regler reagieren nicht sofort. Für die ersten 200 µs eines Anlaufstroms von 0,7 A sinkt die Spannung am Elko um

Das verträgt der Servo. Mit 100 µF wären es 1,4 V. Die Spannungsfestigkeit wählst du mit Reserve: 10 V für 5 V. Der Elko sitzt am Servostecker, nicht am Netzteil – dort, wo die Spitze entsteht (Kondensator an Gleichspannung).

3. Signalwiderstand. Ist der Servo stromlos, liegt sein Eingang über interne Schutzdioden praktisch an Masse. R1 begrenzt den Pinstrom dann auf (5 V − 0,7 V) / 220 Ω ≈ 20 mA, gerade noch im Rahmen. Im Betrieb fließt kaum Strom; der Spannungsabfall an R1 ist vernachlässigbar.

4. Auflösung. Die Bibliothek verteilt 180° auf 2400 µs − 544 µs = 1856 µs, das sind gut 10 µs pro Grad. Mit writeMicroseconds() stellst du feiner ein; der Timer des Uno löst 0,5 µs auf. Mehr Genauigkeit gibt die Mechanik eines Mikroservos aber nicht her.

Code

#include <Servo.h>

Servo klappe;

void setup() {
  klappe.attach(9, 1000, 2000);   // D9, Pulsbereich auf 1,0–2,0 ms begrenzen
  klappe.write(90);               // Mittelstellung
  delay(1000);
}

void loop() {
  for (int w = 0; w <= 180; w += 2) {   // langsam auffahren
    klappe.write(w);
    delay(20);
  }
  delay(1000);
  klappe.write(0);                      // zurück, so schnell der Servo kann
  delay(1500);
}

Am ESP32 nimmst du die Bibliothek ESP32Servo mit derselben Schnittstelle. Sie erzeugt die Pulse mit dem LED-PWM-Baustein des Chips. Die 3,3 V am Pin genügen fast allen Servos als High-Pegel, ein Pegelwandler ist nur selten nötig. Die Versorgung bleibt bei 5 bis 6 V.

Bauteilliste

Erweiterungen

Viele Servos. Die Arduino-Bibliothek steuert am Uno bis zu 12 Servos, belegt dafür aber Timer 1. Für 16 Kanäle ohne Last für den Prozessor gibt es Treiberplatinen mit dem PCA9685, die per I²C angesprochen werden; den Bus dazu beschreibt I²C-Bus richtig beschalten.

Akkubetrieb. Vier NiMH-Zellen liefern 4,8 V, direkt passend für die meisten Servos. Hängt der Arduino am selben Akku, trennst du seine Versorgung über einen eigenen Regler ab, etwa einen Festspannungsregler oder LDO.

Dauerlaufservo. Bei 360°-Servos fehlt die Positionsrückmeldung. 1,5 ms bedeutet dort Stillstand, kürzere und längere Pulse Drehung in die eine oder andere Richtung mit steigender Geschwindigkeit.

Eigener Motor. Wenn du Drehzahl und Richtung eines Gleichstrommotors direkt steuern willst, brauchst du eine H-Brücke.

Typische Fehler

• Arduino startet neu, sobald der Servo fährt: Servo hängt am 5-V-Pin des Arduino. Eigene Versorgung und Pufferelko.
• Servo zittert im Stillstand: Versorgung zu schwach, Masse nicht verbunden oder das Signal kommt unregelmäßig, weil das Programm Interrupts lange sperrt. Mit dem Oszilloskop prüfst du am Signal Periode und Pulslänge.
• Servo brummt in der Endlage: Er fährt gegen den mechanischen Anschlag und zieht dauerhaft Blockierstrom. Pulsbereich in attach() einengen.
• PWM an D10 geht nicht mehr: Die Servo-Bibliothek belegt am Uno Timer 1; analogWrite an D9 und D10 funktioniert dann nicht.
• Servo reagiert gar nicht: Masse zwischen Netzteil und Arduino fehlt.

Selbsttest