Ratgeber · 10 Min. Lesezeit

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

SG90-Mikroservo mit dreifarbigem Kabel
SG90-Mikroservo: 9 Gramm, etwa 1,8 kg·cm Drehmoment; braun GND, rot Plus, orange Signal.

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.

ModellDrehmomentGetriebeBlockierstromEmpfohlene VersorgungTypisches Projekt
SG901,8 kg·cm (4,8 V)Kunststoff650-750 mA5 VRadar, Pan-Tilt, kleine Klappe
MG90S1,8-2,2 kg·cmMetall0,7-1 A5-6 VTürschloss, Greifer, Spinnenroboter
MG996R9,4-11 kg·cmMetall, doppelt kugelgelagert2,5 A (6 V)6 V, 3 A pro ServoSchulter eines Roboterarms, Vorhang, schwerer Deckel
FS90R (360°)1,5 kg·cmKunststoffbis 800 mA5 VRäder, Drehteller
MG996R-Servomotor mit Metallgetriebe und Servohörnern
MG996R: Metallgetriebe und bis zu 11 kg·cm Drehmoment; ideal für Roboterarme und schwere Mechaniken, braucht aber immer eine externe Versorgung.

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.

AufbauStrom in Bewegung (ca.)Empfohlenes Netzteil
1 × SG90, leichte Last100-250 mA5V-Pin des Arduino reicht
2 × SG90 oder MG90S0,3-0,6 AExtern 5 V, 2 A
4 × MG90S (kleiner Roboterarm)0,6-1,2 AExtern 5 V, 3 A
1 × MG996R0,5-0,9 A (blockiert 2,5 A)6 V, 3 A
6 × MG996R (großer Roboterarm)3-5,4 ASchaltnetzteil 6 V, 10 A
12 × MG90S (Spinnenroboter)1,8-3,6 A5-6 V, 5 A oder 2S-LiPo mit 5-A-BEC
Versorge niemals mehrere Servos oder auch nur ein MG996R über den 5V-Pin des Arduino und versuch nicht, sie mit einem 9-V-Block zu betreiben: Diese kleinen Batterien liefern den Servostrom nicht, das Board startet ständig neu. Bei einem externen Netzteil darfst du nicht vergessen, die Massen zu verbinden; ohne gemeinsames GND fehlt dem Signal der Bezug und das Servo bewegt sich zufällig.

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.

PlattformBibliothekServos direktAchtung
Arduino Uno / NanoServo (integriert)Bis 12Nutzt Timer1: analogWrite geht an D9 und D10 nicht
Arduino MegaServo (integriert)Bis 48Viele Servos brauchen trotzdem externe Versorgung
ESP32ESP32ServoBis 16GPIO 18, 19, 21, 22, 23, 25, 26, 27 sind sicher; 34-39 nur Eingang
Raspberry Pi Picomachine.PWM (MicroPython)Bis 16Zwei Pins desselben PWM-Slice teilen die Frequenz; bei 50 Hz egal
PCA9685 (mit jedem Board)Adafruit PWM Servo Driver16 pro Board, bis zu 62 Boards verkettetServostrom kommt über die V+-Klemme des Boards

15 Servo-Projekte: Servo, Anzahl und Ansteuerung

#ProjektServoAnzahlAnsteuerungNiveau
1Winkelsteuerung mit PotentiometerSG901DirektEinsteiger
2Ultraschall-RadarSG901DirektEinsteiger
3Automatischer MülleimerdeckelMG90S1DirektEinsteiger
4Futterautomat für HaustiereMG90S oder MG996R1DirektFortgeschritten
5Türschloss mit RFID oder CodeMG90S1DirektFortgeschritten
6Zeigerthermometer mit ServoSG901DirektEinsteiger
7Drehbarer Kopf für den Hindernis-RoboterSG901DirektFortgeschritten
8Pan-Tilt-Kamerahalter mit JoystickSG902DirektEinsteiger
9SolartrackerMG90S2DirektFortgeschritten
10Bahnschranke (Modell)SG902DirektEinsteiger
11Vorhang- oder Klappenöffner per WLANMG996R1Direkt (ESP32)Fortgeschritten
12Selbstnivellierende Plattform mit MPU6050MG90S2DirektProfi
134-achsiger Tisch-RoboterarmMG90S oder SG904Direkt oder PCA9685Fortgeschritten
146-achsiger RoboterarmMG996R und MG90S6PCA9685Profi
15Vierbeiniger SpinnenroboterMG90S12PCA9685Profi

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.
Fahrende Roboter nutzen statt eines normalen Servos ein 360-Grad-Servo mit Dauerrotation: Gesteuert werden Geschwindigkeit und Richtung statt des Winkels. Details stehen im Artikel 360-Grad-Servo FS90R. Für Showprojekte lassen sich mit zwei PCA9685 sogar 32 Servos synchron bewegen; das BlueGrays-Projekt Servo-Kreis-Choreografie macht genau das.

Gemeinsame Verdrahtung: Arduino Uno, ESP32 und Pico

ServokabelArduino UnoESP32Raspberry Pi PicoExternes 5-6-V-Netzteil
Braun / schwarz (GND)GNDGNDGNDMinus (-)
Rot (V+)5V (nur ein SG90)Nicht verbundenNicht verbundenPlus (+)
Orange / gelb (Signal)D9GPIO 18GP15Nicht verbunden
GND des NetzteilsGND (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.

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

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

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

MicroPython
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.
Bevor du das Projekt in ein Gehäuse baust, lass den Code ohne aufgestecktes Servohorn laufen und steck das Horn bei aktivem 90-Grad-Befehl so auf, dass es mittig steht. So hat die Mechanik in beide Richtungen gleich viel Weg und das Servo knallt beim ersten Test nicht gegen den Anschlag.

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.

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
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
Roboter zur Hindernisvermeidung
AR-81Fortgeschritten
Premium

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.

5.0(38)
49