Servo-Projekte mit Arduino: 15 Ideen mit SG90 und MG996R
15 Servo-Projekte mit Arduino: Radar, Roboterarm, Türschloss, Solartracker, Futterautomat; SG90, MG90S oder MG996R wählen, richtig versorgen, PCA9685 nutzen.
Servo-Projekte mit Arduino sind der einfachste Weg, etwas wirklich in Bewegung zu bringen: Über eine einzige Leitung gibst du einen Winkel vor, das Servo fährt dorthin und hält die Position. In dieser Anleitung haben wir 15 Servo-Projekte gesammelt, vom Ultraschall-Radar über Roboterarm, RFID-Türschloss und Solartracker bis zum automatischen Futterspender. Für jedes Projekt findest du in einer Tabelle, welches Servo passt, wie viele du brauchst, ob du sie direkt vom Arduino oder über einen PCA9685-Treiber ansteuerst und wie du sie mit Strom versorgst.
Vor den Projekten klären wir die Unterschiede zwischen SG90, MG90S und MG996R, wie du das Netzteil passend zur Servoanzahl wählst und wie viele Servos Arduino Uno, ESP32 und Raspberry Pi Pico gleichzeitig ansteuern können. Danach folgen kompilierte, sofort nutzbare Codevorlagen für Radar, Roboterarm und Solartracker. Wenn Servos neu für dich sind, lies am besten zuerst Was ist ein Servomotor?.

Welches Servo: SG90, MG90S oder MG996R?
Der erste Wert bei der Servoauswahl ist das Drehmoment: Es wird in kg·cm angegeben und sagt, wie viele Kilogramm das Servo 1 cm von der Achse entfernt halten kann. Je länger der Hebel, desto weniger kann es heben, und zwar im gleichen Verhältnis; ein SG90 mit 1,8 kg·cm hält am Ende eines 6-cm-Arms gerade noch 300 Gramm, und das nicht dauerhaft. Der zweite Punkt ist das Getriebematerial: Kunststoffzahnräder überspringen bei Überlast, Metallgetriebe stecken Stöße weg. Der dritte ist der Strom: Ein großes Servo braucht ein großes Netzteil. In der Praxis passt der SG90 für leichte Klappen und drehende Sensoren, der MG90S für kleine Mechaniken mit häufigem Einsatz oder Last und der MG996R für die Schulter eines Roboterarms und schwere Deckel.
| Modell | Drehmoment | Getriebe | Blockierstrom | Empfohlene Versorgung | Typisches Projekt |
|---|---|---|---|---|---|
| SG90 | 1,8 kg·cm (4,8 V) | Kunststoff | 650-750 mA | 5 V | Radar, Pan-Tilt, kleine Klappe |
| MG90S | 1,8-2,2 kg·cm | Metall | 0,7-1 A | 5-6 V | Türschloss, Greifer, Spinnenroboter |
| MG996R | 9,4-11 kg·cm | Metall, doppelt kugelgelagert | 2,5 A (6 V) | 6 V, 3 A pro Servo | Schulter eines Roboterarms, Vorhang, schwerer Deckel |
| FS90R (360°) | 1,5 kg·cm | Kunststoff | bis 800 mA | 5 V | Räder, Drehteller |

Servo-Stromtabelle: wie viele Servos, wie viel Strom?
Die meisten Probleme bei Servo-Projekten kommen nicht vom Code, sondern von der Stromversorgung. Sobald ein Servo anläuft, zieht es einen kurzen Stromstoß; schafft der vom USB gespeiste 5V-Pin des Arduino das nicht, bricht die Spannung ein, das Board startet neu und das Servo zittert. Die Regel ist einfach: Ein einzelnes, leicht belastetes SG90 darf am 5V-Pin des Arduino laufen, für alles Weitere versorgst du die Servos aus einem externen 5-6-V-Netzteil, verbindest dessen Minus mit dem GND des Arduino und setzt einen Elko mit 470-1000 µF an die Servo-Versorgung. Für die Netzteilgröße addierst du die Betriebsströme der Servos und planst mindestens 50 % Reserve ein.
| Aufbau | Strom in Bewegung (ca.) | Empfohlenes Netzteil |
|---|---|---|
| 1 × SG90, leichte Last | 100-250 mA | 5V-Pin des Arduino reicht |
| 2 × SG90 oder MG90S | 0,3-0,6 A | Extern 5 V, 2 A |
| 4 × MG90S (kleiner Roboterarm) | 0,6-1,2 A | Extern 5 V, 3 A |
| 1 × MG996R | 0,5-0,9 A (blockiert 2,5 A) | 6 V, 3 A |
| 6 × MG996R (großer Roboterarm) | 3-5,4 A | Schaltnetzteil 6 V, 10 A |
| 12 × MG90S (Spinnenroboter) | 1,8-3,6 A | 5-6 V, 5 A oder 2S-LiPo mit 5-A-BEC |
Servos direkt oder mit PCA9685 ansteuern?
Ein paar Servos direkt an den Pins des Mikrocontrollers zu betreiben ist am einfachsten. Die Servo-Bibliothek des Arduino Uno erzeugt mit Timer1 Impulse für bis zu 12 Servos, allerdings funktioniert analogWrite dann an den Pins 9 und 10 nicht mehr. Der ESP32 gibt jedem Servo einen eigenen Hardware-PWM-Kanal, der Pico hat 16 PWM-Kanäle. Sobald es mehr als 5 oder 6 Servos werden, die Impulse zu zittern beginnen oder du die Pins für andere Aufgaben brauchst, kommt das Treiberboard PCA9685 ins Spiel: Es steuert 16 Servos über nur zwei I2C-Pins und erzeugt die Impulse mit seinem eigenen Takt, was den Mikrocontroller entlastet. Die Einrichtung erklären wir ausführlich im Artikel PCA9685-Servotreiber.
| Plattform | Bibliothek | Servos direkt | Achtung |
|---|---|---|---|
| Arduino Uno / Nano | Servo (integriert) | Bis 12 | Nutzt Timer1: analogWrite geht an D9 und D10 nicht |
| Arduino Mega | Servo (integriert) | Bis 48 | Viele Servos brauchen trotzdem externe Versorgung |
| ESP32 | ESP32Servo | Bis 16 | GPIO 18, 19, 21, 22, 23, 25, 26, 27 sind sicher; 34-39 nur Eingang |
| Raspberry Pi Pico | machine.PWM (MicroPython) | Bis 16 | Zwei Pins desselben PWM-Slice teilen die Frequenz; bei 50 Hz egal |
| PCA9685 (mit jedem Board) | Adafruit PWM Servo Driver | 16 pro Board, bis zu 62 Boards verkettet | Servostrom kommt über die V+-Klemme des Boards |
15 Servo-Projekte: Servo, Anzahl und Ansteuerung
| # | Projekt | Servo | Anzahl | Ansteuerung | Niveau |
|---|---|---|---|---|---|
| 1 | Winkelsteuerung mit Potentiometer | SG90 | 1 | Direkt | Einsteiger |
| 2 | Ultraschall-Radar | SG90 | 1 | Direkt | Einsteiger |
| 3 | Automatischer Mülleimerdeckel | MG90S | 1 | Direkt | Einsteiger |
| 4 | Futterautomat für Haustiere | MG90S oder MG996R | 1 | Direkt | Fortgeschritten |
| 5 | Türschloss mit RFID oder Code | MG90S | 1 | Direkt | Fortgeschritten |
| 6 | Zeigerthermometer mit Servo | SG90 | 1 | Direkt | Einsteiger |
| 7 | Drehbarer Kopf für den Hindernis-Roboter | SG90 | 1 | Direkt | Fortgeschritten |
| 8 | Pan-Tilt-Kamerahalter mit Joystick | SG90 | 2 | Direkt | Einsteiger |
| 9 | Solartracker | MG90S | 2 | Direkt | Fortgeschritten |
| 10 | Bahnschranke (Modell) | SG90 | 2 | Direkt | Einsteiger |
| 11 | Vorhang- oder Klappenöffner per WLAN | MG996R | 1 | Direkt (ESP32) | Fortgeschritten |
| 12 | Selbstnivellierende Plattform mit MPU6050 | MG90S | 2 | Direkt | Profi |
| 13 | 4-achsiger Tisch-Roboterarm | MG90S oder SG90 | 4 | Direkt oder PCA9685 | Fortgeschritten |
| 14 | 6-achsiger Roboterarm | MG996R und MG90S | 6 | PCA9685 | Profi |
| 15 | Vierbeiniger Spinnenroboter | MG90S | 12 | PCA9685 | Profi |
Projekte mit einem Servo (1-7)
- 1. Winkelsteuerung mit Potentiometer: das "Hallo Welt" der Servos. Du rechnest den Potiwert 0-1023 mit map() in 0-180 Grad um und schreibst ihn ans Servo. Code und Schaltung stehen in Was ist ein Servomotor?; dieselbe Logik nutzt du in allen weiteren Projekten.
- 2. Ultraschall-Radar: Auf ein SG90 wird ein HC-SR04-Abstandssensor geklebt, das Servo schwenkt zwischen 15 und 165 Grad, und der Abstand jedes Winkels geht über die serielle Schnittstelle raus. Ein Processing-Sketch am PC macht daraus den klassischen grünen Radarschirm. Details im Arduino-Radar-Projekt, den Code findest du weiter unten.
- 3. Automatischer Mülleimerdeckel: Ein HC-SR04 vorne erkennt eine Hand näher als 20 cm, das Servo öffnet den Deckel und schließt ihn nach ein paar Sekunden. Ist der Deckel schwer, nimm statt SG90 ein MG90S mit Metallgetriebe; siehe smarter Mülleimer.
- 4. Futterautomat für Haustiere: Zu festen Uhrzeiten öffnet das Servo für ein paar Sekunden die Klappe unter dem Futterbehälter. Die Uhrzeit liefert ein RTC-Modul, die Portion ergibt sich aus der Öffnungsdauer. Schneckenförderer brauchen mehr Drehmoment, dafür eignet sich ein MG996R oder ein 360-Grad-Servo; siehe Futterautomat.
- 5. Türschloss mit RFID oder Code: Wird die richtige RFID-Karte vorgehalten oder auf dem Tastenfeld der richtige Code eingegeben, schiebt das Servo den Riegel. Weil der Riegel Reibung hat, hält ein MG90S mit Metallgetriebe deutlich länger.
- 6. Zeigerthermometer mit Servo: Du steckst einen Zeiger aufs Servohorn und stellst eine Karte mit einer Skala von 0 bis 40 °C dahinter; die vom DHT11 gemessene Temperatur wird mit map() in einen Winkel umgerechnet. Dieselbe Idee funktioniert als Anzeige für Luftfeuchte, Lautstärke oder Abonnentenzahl.
- 7. Drehbarer Kopf für den Hindernis-Roboter: Hält der Roboter an, schaut der HC-SR04 auf dem Servo nach links und rechts, und der Roboter dreht zur freieren Seite. Diese einfache Ergänzung macht ihn viel schlauer als einen Roboter mit festem Sensor; siehe Hindernis ausweichender Roboter.
Projekte mit zwei Servos (8-12)
- 8. Pan-Tilt-Kamerahalter mit Joystick: Zwei SG90 werden übereinander montiert: Das untere dreht horizontal (Pan), das obere vertikal (Tilt). Die X- und Y-Achse eines Joystick-Moduls werden den beiden Servos zugeordnet; oben drauf passt eine kleine Kamera, ein Laser oder ein Sensor.
- 9. Solartracker: Vier LDRs messen, von welcher Seite mehr Licht kommt, und zwei Servos richten das Panel horizontal und vertikal zur hellsten Richtung aus. Wind belastet den Panelarm, deshalb sind MG90S eine gute Wahl. Details im Artikel Solartracker, den ESP32-Code findest du unten.
- 10. Bahnschranke: Für die Modellbahn oder ein Schulprojekt senken und heben zwei SG90 die Schranken, rote LEDs blinken im Wechsel und ein Buzzer warnt. Den nahenden Zug erkennt ein Infrarotsensor oder ein Reedkontakt; eine langsamere Servobewegung wirkt sehr realistisch.
- 11. Vorhang- oder Klappenöffner per WLAN: Ein ESP32 betreibt einen kleinen Webserver, und ein Tipp auf die Schaltfläche im Handy lässt ein MG996R die Vorhangschnur oder eine Lüftungsklappe bewegen. Weil es ein MG996R ist, brauchst du unbedingt ein externes 6-V-Netzteil.
- 12. Selbstnivellierende Plattform mit MPU6050: Der Beschleunigungssensor MPU6050 misst die Neigung der Plattform, zwei Servos gleichen sie in Gegenrichtung aus und halten die Fläche waagerecht. So entsteht ein einfacher Gimbal, der ein Glas Wasser oder eine kleine Kamera ruhig hält; für schnelle Reaktion braucht es MG90S und einen guten Filter.
Projekte mit vielen Servos: Roboterarm und Spinnenroboter (13-15)
- 13. 4-achsiger Tisch-Roboterarm: Vier Servos bewegen Basis, Schulter, Ellbogen und Greifer. Bei kleinen Armen aus Acryl oder dem 3D-Drucker reichen MG90S, und alle vier lassen sich direkt vom Uno ansteuern; die Servos sollten aus einem externen 5-V-3-A-Netzteil laufen. Du kannst manuelle Steuerung per Potis, Joystick oder aufgezeichnete und wieder abgespielte Bewegungen ergänzen; siehe Arduino-Roboterarm.
- 14. 6-achsiger Roboterarm: Größere Metallarme nutzen MG996R für Basis, Schulter und Ellbogen und MG90S für Handgelenk und Greifer. Alle sechs über einen PCA9685 zu steuern vereinfacht die Verkabelung; ein 6-V-10-A-Netzteil und Code, der die Servos nacheinander statt gleichzeitig bewegt, senken die Stromspitzen. Für die Last an der Schulter wirf einen Blick in die MG996R-Drehmomenttabelle.
- 15. Vierbeiniger Spinnenroboter: Mit drei Gelenken pro Bein brauchst du 12 Servos, und bei dieser Anzahl ist ein PCA9685 praktisch Pflicht. Weil das Gewicht zählt, nimmt man MG90S, versorgt wird der Roboter mit einem 2S-LiPo und einem 5-A-BEC. Das Laufen entsteht aus einer Posentabelle, die die Winkel jedes Beins der Reihe nach ändert; die Roboterarm-Vorlage weiter unten ist dafür ein guter Startpunkt.
Gemeinsame Verdrahtung: Arduino Uno, ESP32 und Pico
| Servokabel | Arduino Uno | ESP32 | Raspberry Pi Pico | Externes 5-6-V-Netzteil |
|---|---|---|---|---|
| Braun / schwarz (GND) | GND | GND | GND | Minus (-) |
| Rot (V+) | 5V (nur ein SG90) | Nicht verbunden | Nicht verbunden | Plus (+) |
| Orange / gelb (Signal) | D9 | GPIO 18 | GP15 | Nicht verbunden |
| GND des Netzteils | GND (gemeinsam) | GND (gemeinsam) | GND (gemeinsam) | Minus (-) |
Code zu Projekt 2: Ultraschall-Radar mit Arduino
Das Servo kommt an D9, TRIG des HC-SR04 an D10 und ECHO an D11. Das Servo hält alle 2 Grad an, wartet 30 ms und misst den Abstand; das Ergebnis geht als "Winkel,Abstand" über die serielle Schnittstelle. Dieses Format liest der Radarschirm in Processing oder der serielle Plotter der Arduino IDE direkt. Die Zeitgrenze von 30 ms für pulseIn entspricht etwa 5 Metern; kommt kein Echo, wird -1 ausgegeben. Die Abstandsrechnung erklärt der Artikel zum HC-SR04.
1#include <Servo.h>
2
3const int SERVO_PIN = 9; // servo sinyali / servo signal
4const int TRIG_PIN = 10; // HC-SR04 TRIG
5const int ECHO_PIN = 11; // HC-SR04 ECHO
6
7Servo radar;
8
9int readDistanceCm() {
10 digitalWrite(TRIG_PIN, LOW);
11 delayMicroseconds(2);
12 digitalWrite(TRIG_PIN, HIGH); // 10 µs tetik darbesi / 10 µs trigger pulse
13 delayMicroseconds(10);
14 digitalWrite(TRIG_PIN, LOW);
15 unsigned long us = pulseIn(ECHO_PIN, HIGH, 30000UL); // en fazla 30 ms (~5 m) / max 30 ms (~5 m)
16 if (us == 0) return -1; // yankı yok / no echo
17 return us * 0.0343 / 2; // µs -> cm
18}
19
20void scanTo(int angle) {
21 radar.write(angle);
22 delay(30); // servo yerine otursun / let the servo settle
23 int d = readDistanceCm();
24 Serial.print(angle); // "açı,mesafe" satırı / "angle,distance" line
25 Serial.print(',');
26 Serial.println(d);
27}
28
29void setup() {
30 Serial.begin(9600);
31 pinMode(TRIG_PIN, OUTPUT);
32 pinMode(ECHO_PIN, INPUT);
33 radar.attach(SERVO_PIN);
34}
35
36void loop() {
37 for (int a = 15; a <= 165; a += 2) scanTo(a); // soldan sağa / left to right
38 for (int a = 165; a >= 15; a -= 2) scanTo(a); // sağdan sola / right to left
39}Code zu Projekt 13: Roboterarm mit mehreren Servos ohne delay
Bei einem Roboterarm müssen sich alle Gelenke gleichzeitig und weich bewegen. Schreibst du jedem Servo den Zielwinkel direkt mit write(), springen die Servos mit voller Geschwindigkeit, der Arm wackelt und die Stromspitzen wachsen. Die folgende Vorlage bewegt jedes Gelenk mit millis() Grad für Grad zum Ziel; das Array STEP_MS legt die Geschwindigkeit jedes Gelenks fest. Mit neuen Zeilen in der Tabelle POSES schreibst du deine eigene Bewegungsfolge, und dieselbe Struktur passt auch für Pan-Tilt, Schranke oder Spinnenroboter.
1#include <Servo.h>
2
3// 4 eksenli robot kol: taban, omuz, dirsek, kıskaç / 4-axis robot arm: base, shoulder, elbow, gripper
4const byte JOINTS = 4;
5const byte PINS[JOINTS] = {3, 5, 6, 9};
6const unsigned int STEP_MS[JOINTS] = {15, 20, 20, 8}; // 1 derece için bekleme (ms) / wait per degree (ms)
7
8// Hareket sırası: her satır bir poz / move sequence: each row is a pose
9const int POSES[][JOINTS] = {
10 {90, 90, 90, 30}, // başlangıç / home
11 {40, 120, 60, 30}, // nesneye uzan / reach the object
12 {40, 120, 60, 90}, // kıskacı kapat / close the gripper
13 {140, 80, 100, 90}, // taşı / carry
14 {140, 80, 100, 30} // bırak / release
15};
16const byte POSE_COUNT = sizeof(POSES) / sizeof(POSES[0]);
17
18Servo servos[JOINTS];
19int current[JOINTS], target[JOINTS];
20unsigned long lastStep[JOINTS];
21byte pose = 0;
22
23// Servoyu hedefe 1 derece yaklaştırır, delay kullanmaz / moves a servo 1 degree closer, no delay
24bool updateJoint(byte i) {
25 if (current[i] == target[i]) return true; // hedefte / at target
26 if (millis() - lastStep[i] < STEP_MS[i]) return false;
27 lastStep[i] = millis();
28 current[i] += (target[i] > current[i]) ? 1 : -1;
29 servos[i].write(current[i]);
30 return current[i] == target[i];
31}
32
33void setup() {
34 for (byte i = 0; i < JOINTS; i++) {
35 current[i] = target[i] = POSES[0][i];
36 servos[i].write(current[i]); // attach öncesi başlangıç açısı / start angle before attach
37 servos[i].attach(PINS[i]);
38 }
39 delay(1000);
40}
41
42void loop() {
43 bool allDone = true;
44 for (byte i = 0; i < JOINTS; i++) {
45 if (!updateJoint(i)) allDone = false; // hepsi aynı anda hareket eder / all move together
46 }
47 if (allDone) { // poz tamam, sıradakine geç / pose reached, next one
48 delay(500);
49 pose = (pose + 1) % POSE_COUNT;
50 for (byte i = 0; i < JOINTS; i++) target[i] = POSES[pose][i];
51 }
52}Dass write() vor attach() aufgerufen wird, verhindert, dass das Servo beim Einschalten erst auf 90 Grad springt und dann in die Startpose fährt. Die Servos hängen an D3, D5, D6 und D9; weil die Servo-Bibliothek jeden digitalen Pin nutzen kann, muss der Pin keine PWM-Markierung haben. Startet der Arduino neu, während sich der Arm bewegt, liegt es nicht am Code, sondern an der Versorgung; arbeite die Checkliste im Artikel Servo zittert ab.
Code zu Projekt 9: Solartracker mit ESP32
Auf dem ESP32 läuft die Servo-Bibliothek des Arduino nicht; installiere stattdessen die Bibliothek ESP32Servo, die mit demselben Code auf den Cores 2.x und 3.x funktioniert. Jeder der vier LDRs liegt zwischen 3V3 und einem Analogpin, von diesem Pin geht ein 10-kΩ-Widerstand nach GND; je heller es ist, desto höher der Messwert. Die LDRs hängen an ADC1-Pins (32-35), weil ADC2-Pins bei eingeschaltetem WLAN nicht gelesen werden können. Dreht das Panel in die falsche Richtung, ist dein Servo anders montiert; tausch einfach 1 und -1 im Code. Wie ein LDR Licht misst, erklärt der Artikel LDR-Lichtsensor.
1#include <ESP32Servo.h>
2
3const int PAN_PIN = 18; // yatay servo / horizontal servo
4const int TILT_PIN = 19; // dikey servo / vertical servo
5// LDR'ler ADC1 pinlerinde (Wi-Fi ile çakışmaz) / LDRs on ADC1 pins (no Wi-Fi conflict)
6const int LDR_TL = 32, LDR_TR = 33, LDR_BL = 34, LDR_BR = 35;
7const int TOLERANCE = 80; // bu farkın altında hareket etme / ignore smaller differences
8
9Servo pan, tilt;
10int panAngle = 90, tiltAngle = 45;
11
12void setup() {
13 analogReadResolution(12); // 0-4095
14 pan.setPeriodHertz(50); // standart servo 50 Hz / standard servo 50 Hz
15 tilt.setPeriodHertz(50);
16 pan.attach(PAN_PIN, 500, 2400); // darbe aralığı (µs) / pulse range (µs)
17 tilt.attach(TILT_PIN, 500, 2400);
18 pan.write(panAngle);
19 tilt.write(tiltAngle);
20}
21
22void loop() {
23 int tl = analogRead(LDR_TL), tr = analogRead(LDR_TR);
24 int bl = analogRead(LDR_BL), br = analogRead(LDR_BR);
25 int top = (tl + tr) / 2, bottom = (bl + br) / 2;
26 int left = (tl + bl) / 2, right = (tr + br) / 2;
27
28 // Daha aydınlık tarafa 1 derece dön / turn 1 degree toward the brighter side
29 if (abs(left - right) > TOLERANCE) panAngle += (left > right) ? 1 : -1;
30 if (abs(top - bottom) > TOLERANCE) tiltAngle += (top > bottom) ? 1 : -1;
31 panAngle = constrain(panAngle, 5, 175);
32 tiltAngle = constrain(tiltAngle, 10, 90);
33
34 pan.write(panAngle);
35 tilt.write(tiltAngle);
36 delay(25);
37}Servo mit dem Raspberry Pi Pico (MicroPython)
Der Pico braucht keine zusätzliche Bibliothek: Mit machine.PWM erzeugst du ein 50-Hz-Signal und gibst die Impulsbreite in Nanosekunden vor. Die Funktion set_angle() unten rechnet 0-180 Grad in den Bereich 500-2400 µs um; brummt dein Servo an den Enden, verkleinere diese Grenzen. Die Pins des Pico liefern 3,3 V, und SG90, MG90S und MG996R kommen mit diesem Signalpegel problemlos zurecht, die Versorgung des Servos muss aber trotzdem von VBUS (USB-5 V) oder einem externen Netzteil kommen. Wendest du dieselbe Funktion auf eine Liste von PWM-Objekten an, kannst du alle Projekte oben auf den Pico übertragen.
1from machine import Pin, PWM
2import time
3
4servo = PWM(Pin(15)) # GP15 sinyal / GP15 signal
5servo.freq(50) # 50 Hz = 20 ms periyot / 20 ms period
6
7def set_angle(angle, min_us=500, max_us=2400):
8 angle = max(0, min(180, angle)) # 0-180 arası sınırla / clamp to 0-180
9 us = min_us + (max_us - min_us) * angle / 180 # açı -> darbe (µs) / angle -> pulse (µs)
10 servo.duty_ns(int(us * 1000)) # µs -> ns
11
12while True:
13 for a in range(0, 181, 2): # 0 -> 180 derece / degrees
14 set_angle(a)
15 time.sleep_ms(15)
16 for a in range(180, -1, -2): # 180 -> 0 derece / degrees
17 set_angle(a)
18 time.sleep_ms(15)Häufige Fehler bei Servo-Projekten
- Der Arduino startet neu, wenn sich das Servo bewegt: Die Servos hängen am USB-gespeisten 5V-Pin. Nimm ein externes Netzteil, gemeinsames GND und einen Elko mit 470-1000 µF.
- Das Servo brummt und wird an den Enden warm: Bei 0 oder 180 Grad drückt es gegen den mechanischen Anschlag. Begrenze den Bereich auf 5-175 Grad oder kalibriere die Impulsgrenzen in attach().
- Das Servo zittert: schwache Versorgung, lange dünne Kabel oder ein verrauschtes Poti. Nimm dickere Kabel, filtere den Messwert und ergänze ein Totband, das kleine Änderungen ignoriert.
- analogWrite funktioniert an D9 und D10 nicht: Auf dem Uno nutzt die Servo-Bibliothek Timer1. Leg die PWM für LEDs oder Motoren auf D3, D5, D6 oder D11.
- Der Arm schafft die Last nicht: Das Drehmoment teilt sich durch die Armlänge. Kürze den Arm, verringere die Last oder nimm die nächstgrößere Servoklasse (SG90 zu MG90S, MG90S zu MG996R).
- Die Kunststoffzahnräder sind gebrochen: Die Mechanik blockiert das Servo oder der Arm wurde mit Gewalt von Hand gedreht. Wo Dauerlast herrscht, nimm Servos mit Metallgetriebe und dreh das Horn nicht von Hand.
Hast du das Prinzip einmal verstanden, öffnen Servomotoren die Tür zu unzähligen Projekten; dieselben paar Codezeilen bewegen ein Radar genauso wie einen Roboterarm. Wenn du mehrere dieser Projekte Schritt für Schritt bauen willst, findest du in der BlueGrays-App Servosteuerung mit Potentiometer, Servo mit Joystick, Servo am ESP32, ein RFID-Türschloss mit Servo, einen Hindernis-Roboter und eine Kreis-Choreografie mit 32 Servos, jeweils mit Schaltplan und Code.
Häufige Fragen
Was kann man mit einem Servomotor bauen?
Alles, was einen Winkel anfahren und halten muss: Radar, Roboterarm, Türschloss, Solartracker, Futterautomat, Pan-Tilt-Kamerahalter und laufende Roboter sind die beliebtesten Beispiele. Mit 360-Grad-Servos lassen sich auch kleine fahrende Roboter bauen.
Wie viele Servos kann ein Arduino ansteuern?
Die Servo-Bibliothek steuert am Arduino Uno bis zu 12 und am Mega bis zu 48 Servos direkt an. Die echte Grenze setzt meist das Netzteil, nicht die Pinzahl. Ab 5 oder 6 Servos verringert ein PCA9685-Treiber Kabelsalat und Zittern; ein Board steuert 16, verkettete Boards Hunderte.
Soll ich ein SG90 oder ein MG996R kaufen?
Für leichte Klappen, drehende Sensoren und kleine Arme reicht ein SG90. Schwere Lasten, die Schulter eines Roboterarms oder Mechaniken unter Dauerlast brauchen das MG996R mit Metallgetriebe und bis zu 11 kg·cm, das aber ein externes Netzteil mit 3 A pro Servo verlangt.
Kann man ein Servo am 5V-Pin des Arduino betreiben?
Nur ein einzelnes SG90 mit leichter Last. Hängst du mehr Servos oder ein großes an, ziehen die Stromspitzen die Spannung herunter und der Arduino startet neu. Nutze ein externes 5-6-V-Netzteil und verbinde dessen GND mit dem GND des Arduino.
Warum zittert mein Servo?
Häufigste Ursache ist eine zu schwache Versorgung, gefolgt von fehlendem gemeinsamem GND, verrauschten Potiwerten und einem Servo, das gegen seinen Anschlag drückt. Externes Netzteil, Kondensator, gefilterte Messwerte und ein schmalerer Bereich wie 5-175 Grad lösen die meisten Fälle.
Wie steuert man ein Servo mit dem ESP32?
Auf dem ESP32 nimmt man statt der normalen Servo-Bibliothek ESP32Servo; attach(pin, 500, 2400) und write(winkel) funktionieren wie beim Arduino. Wähl ausgangsfähige Pins wie GPIO 18, 19 oder 25 und versorg das Servo aus einer 5-V-Quelle, nicht vom 3,3-V-Pin des ESP32.
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.

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.

Roboter zur Hindernisvermeidung
Wie wäre es, ein intelligentes Fahrzeug zu bauen, das seinen Weg selbst findet? Der Obstacle Avoiding Robot scannt dank des Ultraschallsensors vor ihm ständig seine Umgebung.
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

