MG996R Servo am Arduino: Drehmoment, Strom, Netzteil und Code

Der MG996R Servo ist dank Metallgetriebe und bis zu 11 kg·cm Drehmoment bei 6 V der Standard-Servo für schwere Aufgaben in Arduino-Projekten. Mit seinen 55 Gramm hebt er die Schulter eines Roboterarms, öffnet einen schweren Deckel oder schwenkt eine Pan-Tilt-Kamerahalterung. Diese Kraft hat aber ihren Preis: Unter Last zieht der MG996R bis zu 2,5 A. Deshalb kannst du ihn nicht wie einen SG90 einfach an den 5V-Pin des Arduino hängen; er braucht eine externe 5–6-V-Versorgung, eine gemeinsame Masse (GND) und einen Kondensator nah am Servo. Hältst du dich nicht daran, zittert der Servo, der Arduino startet ständig neu und der Computer schaltet womöglich sogar den USB-Port ab.

In dieser Anleitung lernst du, die Drehmoment- und Stromwerte des MG996R mit echten Zahlen einzuordnen, das richtige Netzteil zu wählen, mit der Servo-Bibliothek den Bereich von 500–2500 µs zu nutzen und die Grenzen deines eigenen Servos zu finden sowie Zittern und Resets zu verhindern. Danach geht es um Code für ESP32 und Raspberry Pi Pico, das PCA9685-Modul, das 16 Servos über zwei Leitungen steuert, die Servoauswahl für einen Roboterarm und den Vergleich mit SG90 und MG90S.

Was ist der MG996R Servo und wie funktioniert er?

Der MG996R ist eine verbesserte Version des älteren MG995 von TowerPro: Dank überarbeiteter Steuerplatine und Zahnräder zentriert er zuverlässiger und hat weniger Spiel. Im Gehäuse sitzen ein kleiner DC-Motor, ein Metallgetriebe, das den Motor untersetzt und das Drehmoment erhöht, ein Potentiometer, das den Winkel der Abtriebswelle misst, und eine Steuerplatine, die alles regelt. Die Platine liest alle 20 ms (50 Hz) die Breite des Impulses auf der Signalleitung, vergleicht den gewünschten Winkel mit dem Winkel des Potis und dreht den Motor, bis die Abweichung verschwunden ist. Ein Impuls von etwa 1500 µs bedeutet Mittelstellung; kürzere Impulse drehen die Welle in die eine, längere in die andere Richtung. Die Totzone von 5 µs im Datenblatt bedeutet, dass der Servo auf kleinere Änderungen nicht reagiert. Wie Servomotoren grundsätzlich funktionieren, erklären wir in Was ist ein Servomotor?.

Was bedeutet Drehmoment? Den kg·cm-Wert richtig lesen

Das Drehmoment ist die Fähigkeit des Servos, eine Last in einem bestimmten Abstand von der Welle zu drehen, und wird als Kraft × Abstand angegeben. 11 kg·cm bedeutet, dass er 11 kg in 1 cm Abstand von der Welle halten kann oder 1,1 kg in 10 cm; verdoppelt sich der Abstand, halbiert sich die tragbare Last. Zur Umrechnung in Newtonmeter multiplizierst du mit 0,098: 11 kg·cm ≈ 1,08 N·m. Entscheidend ist: Der Wert im Datenblatt ist das Blockiermoment, also die Grenze, an der die Welle stehen bleibt, der Strom am höchsten ist und der Servo heiß wird. Im Dauerbetrieb solltest du höchstens die Hälfte davon nutzen; das hält den Servo kühl, verringert das Zittern und schont das Getriebe.

Die Tabelle berücksichtigt nur die Last an der Spitze. In einer echten Mechanik kommen das Eigengewicht des Arms, die darauf montierten Servos und der Greifer hinzu; du musst die Masse jedes Teils mit seinem Abstand zur Welle multiplizieren und alles addieren. Trägt ein 15 cm langer Arm zum Beispiel einen 150-g-Greifer und einen 100-g-Gegenstand an der Spitze, ergeben allein diese beiden 0,25 × 15 = 3,75 kg·cm; mit dem Eigengewicht des Arms kommen schnell 5 kg·cm zusammen. Das liegt knapp unter der Hälfte des Blockiermoments des MG996R bei 6 V, die Wahl passt also. Eine Drehmomentberechnung Teil für Teil mit Beispiel findest du in der Anleitung Arduino Roboterarm.

Strom: Warum darf der MG996R nicht am 5V-Pin des Arduino hängen?

Ohne Last im Stillstand zieht der MG996R nur etwa 10 mA (hält er eine Last, steigt der Wert mit der Last), in Bewegung steigt der Strom aber auf 0,5–0,9 A, und unter Last sowie in den ersten Millisekunden jedes Anlaufs nähert er sich 2,5 A. Läuft ein Arduino Uno über USB, ist der Gesamtstrom am 5V-Pin durch die 500-mA-Sicherung des Boards begrenzt, und einen Teil davon braucht das Board selbst. Sobald der Servo anläuft, bricht die 5-V-Schiene für einige Millisekunden deutlich ein, der Prozessor wird instabil und das Board startet neu. Der Computer kann einen USB-Port, an dem er zu viel Strom feststellt, außerdem zeitweise abschalten.

Auch die Leitungen sind Teil des Problems. Dünne Jumperkabel und die Kontakte eines Steckbretts kommen leicht auf zusammen 0,2 Ω. Rechne es mit dem ohmschen Gesetz nach: Bei 2,5 A Spitzenstrom gehen allein in den Leitungen 2,5 × 0,2 = 0,5 V verloren, aus 5 V werden am Servo 4,5 V, er wird schwächer und zittert. Steckbrettkontakte sind zudem nur für etwa 1 A ausgelegt. Schließe die Versorgungsleitungen des MG996R deshalb nicht über das Steckbrett, sondern direkt an eine Schraubklemme oder eine gelötete Verteilerschiene an und nimm Kabel mit 20–22 AWG.

Richtig versorgen: externe 5–6 V, gemeinsame Masse und Kondensator

1. Netzteil wählen: Nimm ein 5-V- oder 6-V-Schaltnetzteil, das für deine Servoanzahl den Strom aus der Tabelle oben liefert. Für mobile Projekte eignen sich 4 AA-NiMH-Akkus (4,8 V) oder ein 2S-LiPo mit einem auf 6 V eingestellten Spannungsregler (UBEC).
2. Plus nur an den Servo: Verbinde den Pluspol des Netzteils mit dem roten Kabel des MG996R, nicht mit dem 5V-Pin des Arduino.
3. Masse verbinden: Verbinde den Minuspol des Netzteils sowohl mit dem braunen Kabel des Servos als auch mit dem GND-Pin des Arduino. Das Signal ist eine Spannung gegenüber GND; ohne gemeinsame Masse versteht der Servo die Impulse nicht.
4. Signal anschließen: Verbinde das orange Kabel mit Pin D9 des Arduino Uno (beim ESP32 GPIO 18, beim Pico GP15).
5. Kondensator einsetzen: Setze einen Elko mit 470–1000 µF / 16 V so nah wie möglich am Servo zwischen dessen Versorgungsleitungen; das Bein mit dem Streifen kommt an Minus. Bei mehreren Servos rechnest du mit etwa 100 µF pro Servo.
6. Arduino getrennt versorgen: Betreibe das Board über USB oder die Hohlbuchse. So erreichen die Spannungseinbrüche des Servos den Prozessor nicht.

Die Servo-Bibliothek und der Bereich 500–2500 µs

Die Servo-Bibliothek des Arduino ist in der IDE enthalten. Schreibst du servo.attach(9), nutzt die Bibliothek standardmäßig den Bereich 544–2400 µs und legt write(0) und write(180) auf diese beiden Enden; viele MG996R erreichen damit nicht ganz 180 Grad. Um den Bereich zu erweitern, schreibst du servo.attach(9, 500, 2500). Das ist wichtig, denn auch writeMicroseconds() kann die bei attach angegebenen Grenzen nicht überschreiten: Schreibst du ohne Grenzen writeMicroseconds(2500), begrenzt die Bibliothek den Wert stillschweigend auf 2400. Außerdem behandelt write() Zahlen unter 544 als Winkel und größere als Mikrosekunden.

Auf dem Arduino Uno unterstützt die Servo-Bibliothek bis zu 12 Servos, und weil sie Timer1 belegt, funktioniert analogWrite an den Pins 9 und 10 nicht, solange ein Servo angeschlossen ist. Auch die mechanische Grenze ist bei jedem MG996R etwas anders: Das Datenblatt des Herstellers nennt mit Standardimpulsen von 1000–2000 µs etwa 120 Grad, mit dem breiteren Bereich kommen die meisten Servos nahe an 180 Grad. Ein Servo, der über seine Grenze getrieben wird, läuft gegen den internen Anschlag, zieht Blockierstrom, brummt und wird heiß. Deshalb ermittelst du zuerst mit dem folgenden Sketch den sicheren Impulsbereich deines Servos.

1#include <Servo.h>
2
3const byte SERVO_PIN = 9;          // turuncu sinyal kablosu / orange signal wire
4Servo servo;
5int pulseUs = 1500;                // orta konum / center position
6
7void setup() {
8  Serial.begin(115200);
9  servo.writeMicroseconds(pulseUs);      // önce darbe, sonra attach / pulse first, then attach
10  servo.attach(SERVO_PIN, 500, 2500);    // aralığı genişlet / widen the range
11  Serial.println(F("500-2500 arasi bir deger yaz / type a value between 500 and 2500"));
12}
13
14void loop() {
15  if (Serial.available()) {
16    long value = Serial.parseInt();             // yazılan sayıyı oku / read the typed number
17    while (Serial.available()) Serial.read();   // satır sonunu temizle / clear the line ending
18    if (value >= 500 && value <= 2500) {
19      int step = (value > pulseUs) ? 10 : -10;  // 10 µs adımlarla yavaşça git / move slowly in 10 µs steps
20      while (abs(value - pulseUs) >= 10) {
21        pulseUs += step;
22        servo.writeMicroseconds(pulseUs);
23        delay(5);
24      }
25      pulseUs = value;
26      servo.writeMicroseconds(pulseUs);
27      Serial.print(F("Darbe / pulse: "));
28      Serial.print(pulseUs);
29      Serial.println(F(" us"));
30    }
31  }
32}

1. Lade den Sketch hoch, öffne den Seriellen Monitor mit 115200 Baud und stelle das Zeilenende auf Neue Zeile.
2. Gib 1500 ein; der Servo fährt in die Mitte. Setze jetzt das Servohorn so auf, dass es auf die Mittelstellung deiner Mechanik zeigt.
3. Taste dich mit Werten wie 1000, 800 und 700 in 50-µs-Schritten zur unteren Grenze vor. Bewegt sich der Servo nicht mehr oder beginnt er zu brummen, geh 30–50 µs vom letzten Wert zurück und notiere diese Zahl als MIN_US.
4. Mach dasselbe für die obere Grenze mit Werten wie 2000, 2200 und 2300 und ermittle MAX_US. Diese beiden Zahlen brauchst du in den nächsten Sketches.

Sanfte Bewegung: Code gegen Stromspitzen und Ruckeln

Ein einzelner Befehl wie servo.write(160) schleudert den Servo mit voller Geschwindigkeit ans Ziel, bei 6 V in 0,14 Sekunden pro 60 Grad. Dabei zieht der Motor fast seinen Blockierstrom, die Mechanik ruckt und ein gehaltener Gegenstand kann herunterfallen. Teilst du die Bewegung in kleine Schritte, sinken sowohl die Stromspitzen als auch die mechanischen Stöße. Der folgende Sketch bewegt den Servo alle 15 ms um 1 Grad (etwa 67°/s), und weil er millis() nutzt, kannst du nebenbei andere Dinge erledigen.

1#include <Servo.h>
2
3const byte SERVO_PIN = 9;
4const int MIN_US = 550;            // kalibrasyonda bulduğun alt sınır / lower limit from calibration
5const int MAX_US = 2450;           // kalibrasyonda bulduğun üst sınır / upper limit from calibration
6const byte STEP_MS = 15;           // derece başına süre: 15 ms ≈ 67°/sn / time per degree: 15 ms ≈ 67°/s
7
8const int POSES[] = {20, 160, 90, 45, 135};    // sırayla gidilecek açılar / angles to visit in order
9const byte POSE_COUNT = sizeof(POSES) / sizeof(POSES[0]);
10
11Servo servo;
12int current = 90;                  // şu anki açı / current angle
13int target = 90;                   // hedef açı / target angle
14byte poseIndex = 0;
15unsigned long lastStep = 0;
16unsigned long arrivedAt = 0;
17
18int angleToUs(int angle) {
19  return map(angle, 0, 180, MIN_US, MAX_US);   // açıyı darbeye çevir / angle to pulse width
20}
21
22void setup() {
23  servo.writeMicroseconds(angleToUs(current)); // önce konum, sonra attach / position first, then attach
24  servo.attach(SERVO_PIN, MIN_US, MAX_US);
25  arrivedAt = millis();
26}
27
28void loop() {
29  unsigned long now = millis();
30
31  // Hedefe 1 derecelik adımlarla yaklaş / approach the target in 1-degree steps
32  if (current != target && now - lastStep >= STEP_MS) {
33    lastStep = now;
34    current += (target > current) ? 1 : -1;
35    servo.writeMicroseconds(angleToUs(current));
36    if (current == target) arrivedAt = now;
37  }
38
39  // Hedefte 1 sn bekle, sonra sıradaki poza geç / wait 1 s at the target, then take the next pose
40  if (current == target && now - arrivedAt >= 1000) {
41    target = POSES[poseIndex];
42    poseIndex = (poseIndex + 1) % POSE_COUNT;
43  }
44
45  // Burada başka işler de yapılabilir / other tasks can run here too
46}

Die Funktion angleToUs() bildet den Winkel auf den Bereich zwischen den bei der Kalibrierung ermittelten Werten MIN_US und MAX_US ab; so werden 0 und 180 Grad zu den echten, sicheren Endpunkten des Servos. Ein Servo merkt sich seine Position im ausgeschalteten Zustand nicht und fährt beim ersten Impuls mit voller Geschwindigkeit dorthin. Wird writeMicroseconds() vor attach() aufgerufen, überspringt die Bibliothek ihren Standardimpuls von 1500 µs und sendet sofort deinen Startwinkel; bringst du die Mechanik vor dem Ausschalten in dieselbe Startpose, verschwindet der Sprung beim Einschalten fast ganz. Die Geschwindigkeit stellst du mit STEP_MS ein: 30 ms ergeben eine langsame, weiche Bewegung, 5 ms eine schnelle, aber ruckige. Willst du den Servo mit einem Potentiometer steuern, rechnest du den Messwert in einen Winkel um und schreibst ihn in die Variable target.

Zittern und Arduino-Resets: Ursachen und Lösungen

MG996R mit dem ESP32 ansteuern

Auf dem ESP32 funktioniert die Standard-Servo-Bibliothek des Arduino nicht; installiere über den Bibliotheksverwalter die Bibliothek ESP32Servo. Sie wird fast genauso verwendet: Du legst die Periode mit setPeriodHertz(50) fest, und die Bibliothek akzeptiert keine Grenzen außerhalb von 500–2500 µs. Der Signalausgang des ESP32 liefert 3,3 V, was die allermeisten MG996R problemlos erkennen; reagiert dein Servo nicht oder verhält er sich unruhig, setze einen Pegelwandler in die Signalleitung. Im folgenden Beispiel dreht ein Potentiometer an GPIO 34 den Servo. Weil der ADC des ESP32 12 Bit hat, liegen die Werte zwischen 0 und 4095 und rauschen etwas; deshalb glättet der Code und nutzt eine Totzone.

1#include <ESP32Servo.h>
2
3const int SERVO_PIN = 18;          // servo sinyali / servo signal
4const int POT_PIN = 34;            // pot orta bacağı (ADC1) / pot wiper (ADC1)
5const int MIN_US = 500;            // ESP32Servo bu aralığın dışına çıkmaz / ESP32Servo stays within 500–2500
6const int MAX_US = 2500;
7
8Servo servo;
9float smooth = 0;                  // süzülmüş pot değeri / filtered pot value
10int lastAngle = -1;
11
12void setup() {
13  Serial.begin(115200);
14  ESP32PWM::allocateTimer(0);              // servo için zamanlayıcı ayır / reserve a timer for the servo
15  servo.setPeriodHertz(50);                // 50 Hz = 20 ms periyot / 20 ms period
16  servo.attach(SERVO_PIN, MIN_US, MAX_US);
17  smooth = analogRead(POT_PIN);
18}
19
20void loop() {
21  smooth += (analogRead(POT_PIN) - smooth) * 0.1;   // ADC gürültüsünü süz / filter ADC noise
22  int angle = map((int)smooth, 0, 4095, 0, 180);    // 12 bit ADC: 0–4095
23  if (abs(angle - lastAngle) >= 2) {                // ölü bant: titremeyi keser / deadband stops jitter
24    servo.write(angle);
25    lastAngle = angle;
26    Serial.println(angle);
27  }
28  delay(20);
29}

MG996R mit dem Raspberry Pi Pico (MicroPython)

Auf dem Raspberry Pi Pico brauchst du keine zusätzliche Bibliothek: Du stellst PWM auf 50 Hz und gibst die Impulsbreite mit duty_ns() in Nanosekunden an; 500 µs sind 500000 ns. Auch das Signal des Pico hat 3,3 V. Versorge den Servo nicht über den Pin VBUS oder VSYS des Pico; der Strom an diesen Pins kommt vom USB-Port des Computers, und der Spitzenstrom des MG996R lässt den Pico neu starten. Versorge den Servo extern und verbinde die Massen. Der folgende Code fährt den Servo Grad für Grad sanft zwischen drei Positionen hin und her.

1from machine import Pin, PWM
2import time
3
4MIN_NS = 500000                   # 500 µs = 0 derece / 0 degrees
5MAX_NS = 2500000                  # 2500 µs = 180 derece / 180 degrees
6
7servo = PWM(Pin(15))              # turuncu kablo GP15'e / orange wire to GP15
8servo.freq(50)                    # 50 Hz servo sinyali / 50 Hz servo signal
9
10def write_angle(angle):
11    angle = max(0, min(180, angle))                           # 0–180 ile sınırla / clamp to 0–180
12    servo.duty_ns(MIN_NS + (MAX_NS - MIN_NS) * angle // 180)  # açıyı darbeye çevir / angle to pulse
13
14def move_slow(start, end, ms_per_degree=15):
15    step = 1 if end > start else -1
16    for a in range(start, end + step, step):  # 1 derecelik adımlar / 1-degree steps
17        write_angle(a)
18        time.sleep_ms(ms_per_degree)
19
20write_angle(90)                   # ortadan başla / start at the center
21time.sleep(1)
22
23while True:
24    move_slow(90, 170)
25    time.sleep(1)
26    move_slow(170, 10)
27    time.sleep(1)
28    move_slow(10, 90)
29    time.sleep(1)

16 Servos mit dem PCA9685: viele MG996R über zwei Leitungen

Wenn die Zahl der Servos wächst oder du mit Bibliotheken arbeitest, die Interrupts sperren, erleichtert dir das Modul PCA9685 die Arbeit. Die Platine ist ein 16-Kanal-PWM-Generator mit 12 Bit Auflösung, der mit dem Arduino nur über SDA und SCL per I2C spricht. Weil er die Impulse mit seinem eigenen Takt erzeugt, bleibt das Signal stabil, auch wenn der Prozessor gerade beschäftigt ist. Die Standardadresse ist 0x40; über die Lötbrücken A0–A5 lässt sich die Adresse ändern, sodass 62 Platinen am selben Bus hängen können, theoretisch also 992 Servos. Bei 50 Hz wird die Periode von 20 ms in 4096 Schritte geteilt, ein Schritt sind etwa 4,9 µs: 500 µs entsprechen rund 102, 2500 µs rund 512 Schritten.

1#include <Wire.h>
2#include <Adafruit_PWMServoDriver.h>
3
4Adafruit_PWMServoDriver pca = Adafruit_PWMServoDriver(0x40);   // varsayılan adres / default address
5
6const byte SERVO_COUNT = 16;
7const uint16_t MIN_US = 500;       // kalibrasyonla daralt / narrow it after calibration
8const uint16_t MAX_US = 2500;
9
10uint16_t angleToUs(float angle) {
11  return MIN_US + (uint16_t)(angle * (MAX_US - MIN_US) / 180.0);
12}
13
14void setup() {
15  pca.begin();
16  pca.setOscillatorFrequency(27000000);   // kartın gerçek saatine yakın / close to the real board clock
17  pca.setPWMFreq(50);                     // servolar için 50 Hz / 50 Hz for servos
18  delay(10);
19  for (byte ch = 0; ch < SERVO_COUNT; ch++) {
20    pca.writeMicroseconds(ch, angleToUs(90));   // hepsini ortala / center them all
21    delay(200);                                 // sırayla başlat: akım darbesini dağıt / one by one: spread the current surge
22  }
23}
24
25void loop() {
26  // Dalga: her servo komşusundan biraz geride / wave: each servo slightly behind its neighbour
27  float t = millis() / 1000.0;
28  for (byte ch = 0; ch < SERVO_COUNT; ch++) {
29    float angle = 90 + 40 * sin(t * 2.0 - ch * 0.4);   // 50–130° arası / between 50° and 130°
30    pca.writeMicroseconds(ch, angleToUs(angle));
31  }
32  delay(20);
33}

Für den Sketch installierst du über den Bibliotheksverwalter die Bibliothek Adafruit PWM Servo Driver. Die Zeile setOscillatorFrequency(27000000) ist wichtig: Auf dem Papier taktet der interne Oszillator des PCA9685 mit 25 MHz, in Wirklichkeit schwankt er zwischen etwa 23 und 27 MHz, und die Adafruit-Beispiele verwenden 27 MHz. Ohne diese Einstellung können die mit writeMicroseconds() gesetzten Impulse um einige Prozent abweichen. Dass die Servos im setup nacheinander im Abstand von 200 ms starten, verhindert, dass alle 16 gleichzeitig Anlaufstrom ziehen. Haben die Servos unterschiedliche Grenzen, machst du aus MIN_US und MAX_US Arrays mit 16 Elementen und kalibrierst jeden Kanal einzeln. Der Sketch läuft unverändert auch auf dem ESP32, weil die Wire-Bibliothek dort standardmäßig GPIO 21 und 22 nutzt.

MG996R, SG90 und MG90S im Vergleich

Die Wahl hängt von Last und Hebelarm ab. Drehst du ein Teil von wenigen Gramm oder experimentierst nur, reicht der SG90. Willst du dieselbe Größe mit stoßfestem Metallgetriebe, nimm den MG90S. Brauchst du mehr als 1 kg·cm, etwa für 100 g am Ende eines 10-cm-Arms, steig auf den MG996R um. Der MG996R hat etwa das Fünffache des Drehmoments eines SG90, ist aber langsamer, sechsmal so schwer und zieht drei- bis viermal so viel Strom; plane Netzteil und mechanische Befestigung entsprechend. Reichen auch 11 kg·cm nicht, schau dir größere Servos der 20-kg·cm-Klasse wie den DS3218 an.

Servoauswahl für einen Roboterarm

• Basis: MG996R. Lass nicht das ganze Gewicht des Arms auf der Servowelle lasten; ein Lager in der Basis sorgt dafür, dass der Servo nur noch dreht.
• Schulter: Das am stärksten belastete Gelenk. Nimm einen MG996R; ist der Arm länger als 20 cm, ergänze einen Servo der 20-kg·cm-Klasse oder ein Gegengewicht.
• Ellbogen: MG996R. Setzt du den schweren Servo auf Schulterhöhe und bewegst den Ellbogen über eine Schubstange, entlastest du die Schulter.
• Handgelenk und Handgelenkdrehung: Ein MG90S genügt; ein MG996R würde hier nur unnötig Gewicht auf die Schulter bringen.
• Greifer: SG90 oder MG90S. Stell den Schließwinkel auf den Punkt ein, an dem die Finger den Gegenstand gerade berühren; ein Servo, der ständig weiter zudrücken will, zieht Blockierstrom.
• Befestigung: Setze ein Metallhorn auf die 25-Zahn-Welle des MG996R und sichere es mit der Mittelschraube; Kunststoffhörner leiern bei diesem Drehmoment schnell aus.

Projektideen mit dem MG996R

• Roboterarm: Ein Arm mit 6 Servos, MG996R an Basis, Schulter und Ellbogen, MG90S an Handgelenk und Greifer; den Aufbau zeigt die Roboterarm-Anleitung.
• Pan-Tilt-Kamera: Schwenke und neige ein ESP32-CAM-Modul mit zwei MG996R.
• Sonnenverfolgung: Bestimme mit vier LDRs die Lichtrichtung und richte ein kleines Panel mit einem MG996R zur Sonne aus; Details im Artikel Sonnenverfolgung.
• Smarter Mülleimer: Ein smarter Mülleimer, der einen schweren Deckel öffnet, sobald sich eine Hand nähert.
• Kartenschloss: Ziehe mit einem MG996R einen Riegel zurück, sobald am RFID RC522 die richtige Karte erkannt wird.
• Joystick-Kran: Ein kleiner Kran oder Bagger, der sich mit einem Joystick auf zwei Achsen bewegt.
• Dauerantrieb: Ein langsames, aber kräftiges Rad mit der 360-Grad-Version des MG996R; den Unterschied erklärt der Artikel 360-Grad-Servo.

Richtig versorgt ist der MG996R ein robuster, günstiger Motor, der Aufgaben übernimmt, an denen kleine Servos scheitern. Merk dir die Regeln: externe 5–6 V, gemeinsame Masse, ein Kondensator nah am Servo, ein kalibrierter Impulsbereich und sanfte Bewegungen, bei vielen Servos dazu ein PCA9685. In der BlueGrays-App findest du Projekte wie Servosteuerung mit Potentiometer und Joystick, ein ESP32-RFID-Türschloss mit Servo und eine Choreografie mit 32 Servos, jeweils mit Schritt-für-Schritt-Schaltplan und fertigem Code.