360-Grad-Servo (FS90R): Geschwindigkeit und Richtung steuern

Ein 360-Grad-Servo heißt zwar Servo, ist aber in Wirklichkeit ein kleiner Getriebemotor, der sich dauerhaft dreht, statt einen Winkel anzufahren und dort stehen zu bleiben. Der bekannteste ist der FEETECH FS90R: Er hat dieselbe Größe und dieselben drei Kabel wie ein SG90, doch das Signal, das du sendest, legt nicht einen Winkel fest, sondern Drehgeschwindigkeit und Drehrichtung. Weil er ohne Motortreiber direkt an einen Arduino-Pin passt, ist er für kleine Roboterräder, Drehteller und Futterautomaten sehr praktisch.

In dieser Anleitung lernst du, was im FS90R anders ist als in einem normalen Servo, warum der Befehl write(90) den Motor anhält, wie du Geschwindigkeit und Richtung über die Pulsbreite einstellst und wie du mit dem Stopp-Trimmer einen Servo korrigierst, der von selbst weiterkriecht. Danach steuerst du mit zwei FS90R einen kleinen Roboter, regelst die Geschwindigkeit mit einem Potentiometer und probierst dasselbe mit ESP32 und Raspberry Pi Pico. Zum Schluss siehst du, warum dieser Servo keine Positionsregelung kann und was du stattdessen nimmst.

Was ist ein 360-Grad-Servo und was unterscheidet ihn vom normalen Servo?

Ein normaler Servo enthält einen kleinen Gleichstrommotor, ein Getriebe, eine Steuerschaltung und ein Potentiometer, das mit der Abtriebswelle verbunden ist. Die Steuerung vergleicht den vom Puls verlangten Winkel mit dem tatsächlichen Winkel des Potentiometers und dreht den Motor, bis die Differenz null ist; erreicht die Welle das Ziel, bleibt sie stehen. Beim Endlosservo ist diese Rückmeldung getrennt: Das Potentiometer ist von der Welle gelöst und in Mittelstellung fixiert, und der mechanische Anschlag im Getriebe fehlt. Die Schaltung berechnet weiterhin die „Differenz zwischen Soll- und Istposition“, doch weil sich die Istposition nie ändert, schließt sich die Differenz nie. Ergebnis: Je größer die Differenz, desto schneller dreht der Motor, und ihr Vorzeichen bestimmt die Richtung.

Technische Daten des FS90R

FS90R anschließen: Arduino Uno, ESP32 und Pico

Für einen einzelnen FS90R ohne Last genügt der 5V-Pin des Uno. Sobald das Rad den Boden berührt oder zwei Servos gleichzeitig anlaufen, steigt der Strom auf einige Hundert Milliampere; die USB-Spannung bricht ein, der Arduino startet womöglich neu oder die Servos zittern. Versorge die Servos im Roboter deshalb aus einer eigenen 5-V-Quelle (4 NiMH-Akkus, ein 5-V-Regler oder ein passendes Netzteil), verbinde die GND der Servoversorgung unbedingt mit der GND des Arduino und setz einen 470-µF-Kondensator nahe an die Servokabel. Das 3,3-V-Signal von ESP32 und Pico reicht für den FS90R; der Servo selbst braucht aber trotzdem 5 V, nicht den 3,3-V-Pin.

write(90) = Stopp: Wie wird aus der Pulsbreite Geschwindigkeit?

Das Servo-Steuersignal ist ein Puls, der 50-mal pro Sekunde (alle 20 ms) gesendet wird; entscheidend ist seine Länge. Beim FS90R bedeutet 1500 µs „Stopp“. Wird der Puls länger als 1500 µs, beschleunigt der Servo in die eine Richtung, wird er kürzer, in die andere; etwa bei 1000 µs und 2000 µs erreicht er volle Geschwindigkeit, darüber hinaus steigt sie kaum noch. Deshalb bedeutet write(90) in der Servo-Bibliothek des Arduino Stopp, write(0) und write(180) volle Geschwindigkeit in beide Richtungen. Hier lauert eine kleine Falle: Standardmäßig rechnet die Bibliothek 0–180 auf 544–2400 µs um, write(90) erzeugt also in Wahrheit 1472 µs. Diese Abweichung kann genügen, damit der Servo selbst bei write(90) langsam weiterkriecht. Abhilfe schafft attach(9, 1000, 2000), das den Bereich einengt, oder direkt writeMicroseconds(1500).

Erster Sketch: vorwärts, Stopp, rückwärts

1// FS90R ilk test: ileri, dur, geri / FS90R first test: forward, stop, backward
2#include <Servo.h>
3
4Servo teker;                         // sürekli dönüş servosu / continuous rotation servo
5
6void setup() {
7  teker.attach(9, 1000, 2000);       // write(0..180) artık 1000..2000 µs üretir / write(0..180) now outputs 1000..2000 µs
8}
9
10void loop() {
11  teker.write(180);                  // tam hız bir yöne / full speed one way
12  delay(2000);
13  teker.write(90);                   // 1500 µs: dur / 1500 µs: stop
14  delay(1000);
15  teker.write(0);                    // tam hız ters yöne / full speed the other way
16  delay(2000);
17  teker.write(110);                  // yavaş / slow
18  delay(2000);
19  teker.writeMicroseconds(1500);     // durmanın en kesin yolu / the most precise way to stop
20  delay(1000);
21}

Der Sketch hängt den Servo an D9 und bildet mit attach(9, 1000, 2000) die write()-Skala auf den Bereich ab, den der FS90R tatsächlich nutzt; so ergibt write(90) genau 1500 µs. Die Geschwindigkeit folgt dem Puls nicht linear: Direkt um 1500 µs liegt ein Totbereich von einigen zehn Mikrosekunden, in dem sich der Servo nicht bewegt, im Bereich 1500 ± 300 µs steigt die Geschwindigkeit schnell, zu den Enden hin bleibt sie fast konstant. Für langsame, feine Bewegungen bleibst du nahe an 1500 µs. Das Prinzip der Pulsbreite erklärt Was ist PWM, die Winkelsteuerung normaler Servos Was ist ein Servomotor.

Den Stopp-Trimmer (Mittelpunkt) einstellen

1. Lade den Kalibrier-Sketch unten hoch; der Servo bekommt ein 1500-µs-Signal und sollte eigentlich stehen.
2. Kriecht der Servo, suche das kleine Loch an der Gehäuseseite nahe dem Kabelausgang; darin sitzt der Trimmer, der den Stopppunkt festlegt.
3. Dreh den Trimmer mit einem kleinen Schlitz- oder Kreuzschraubendreher nur ein winziges Stück; wird der Servo langsamer, stimmt die Richtung.
4. Mach in kleinen Schritten weiter, bis der Servo ganz steht und selbst das leise Summen verschwindet. Der Trimmer ist sehr empfindlich, schon eine Vierteldrehung ist zu viel.
5. Willst du den Trimmer nicht anfassen, sende + und - aus dem seriellen Monitor, finde den Pulswert, bei dem der Servo steht, und nutze ihn im Code statt 1500.

1// Durma noktası ayarı: Serial Monitor'den µs değeri gönder
2// Stop point calibration: send a µs value from the Serial Monitor
3#include <Servo.h>
4
5Servo teker;
6int darbe = 1500;                    // başlangıç: teorik durma noktası / start: theoretical stop point
7
8void setup() {
9  Serial.begin(9600);
10  teker.attach(9);
11  teker.writeMicroseconds(darbe);
12  Serial.println(F("Sayi yaz (900-2100) ya da + / - gonder"));
13  Serial.println(F("Type a number (900-2100) or send + / -"));
14}
15
16void loop() {
17  if (Serial.available()) {
18    char c = Serial.peek();
19    if (c == '+') { Serial.read(); darbe += 5; }          // 5 µs artır / add 5 µs
20    else if (c == '-') { Serial.read(); darbe -= 5; }     // 5 µs azalt / subtract 5 µs
21    else if (isDigit(c)) darbe = Serial.parseInt();       // doğrudan değer / direct value
22    else { Serial.read(); return; }                       // satır sonu vb. atla / skip line endings etc.
23
24    darbe = constrain(darbe, 900, 2100);
25    teker.writeMicroseconds(darbe);
26    Serial.print(F("Darbe / pulse: "));
27    Serial.print(darbe);
28    Serial.println(F(" us"));
29  }
30}

Geschwindigkeit und Richtung mit einem Potentiometer

1// Potansiyometreyle hız ve yön: ortada dur, sağa ileri, sola geri
2// Speed and direction with a pot: centre = stop, right = forward, left = backward
3#include <Servo.h>
4
5const int POT_PIN = A0;
6const int OLU_BOLGE = 40;            // ortadaki ±40 adım: kesin dur / ±40 steps in the middle: solid stop
7Servo teker;
8
9void setup() {
10  teker.attach(9);
11}
12
13void loop() {
14  int okuma = analogRead(POT_PIN) - 512;                   // -512 ... +511
15  int darbe = 1500;                                        // varsayılan: dur / default: stop
16  if (okuma > OLU_BOLGE) {
17    darbe = map(okuma, OLU_BOLGE, 511, 1540, 2000);        // ileri, yavaştan hızlıya / forward, slow to fast
18  } else if (okuma < -OLU_BOLGE) {
19    darbe = map(okuma, -OLU_BOLGE, -512, 1460, 1000);      // geri / backward
20  }
21  teker.writeMicroseconds(darbe);
22  delay(20);                                               // servo periyodu kadar / one servo period
23}

Ist das Potentiometer zwischen 5V, A0 und GND angeschlossen, bedeutet die Mittelstellung Stopp, nach rechts drehen vorwärts und nach links rückwärts. Der Code legt in der Mitte eine Totzone von ±40 Schritten fest, damit der Servo sicher steht, auch wenn das Potentiometer nicht exakt mittig ist oder die Messwerte etwas schwanken. Außerhalb der Totzone wird der Wert auf 1540–2000 µs bzw. 1460–1000 µs abgebildet: Ein wenig gedreht läuft der Servo langsam, ganz aufgedreht mit voller Geschwindigkeit. Dieselbe Idee funktioniert mit einem Joystick; den Anschluss des Potentiometers zeigt Was ist ein Potentiometer.

Der FS90R als kleines Roboterrad

Der FS90R ist bei Robotern so beliebt, weil er einfach ist: Getriebe und Treiberschaltung sind eingebaut, du brauchst also keinen separaten Motortreiber, keine H-Brücke und keinen Encoder; ein Signalpin pro Rad genügt. Die beiden Servos sitzen spiegelbildlich an den Seiten des Chassis, daher muss sich für die Vorwärtsfahrt einer im und einer gegen den Uhrzeigersinn drehen. Der folgende Code erledigt das in der Funktion surus(); du gibst nur eine Geschwindigkeit zwischen -100 und +100 vor. Ein Rad mit 60 mm Durchmesser legt bei 130 U/min an 6 V etwa 0,4 Meter pro Sekunde zurück, bei 4,8 V sind es rund 0,3 m/s.

1// İki FS90R ile küçük robot: tekerlekler ayna gibi takılır
2// A small robot with two FS90Rs: the wheels are mounted as mirror images
3#include <Servo.h>
4
5Servo sol, sag;
6const int DUR_SOL = 1500;            // kalibrasyonla bulduğun değerler / values you found during calibration
7const int DUR_SAG = 1500;
8
9// hiz: -100 (tam geri) ... +100 (tam ileri) / speed: -100 (full back) ... +100 (full forward)
10void surus(int hizSol, int hizSag) {
11  sol.writeMicroseconds(DUR_SOL + hizSol * 5);             // sol teker normal yönde / left wheel normal direction
12  sag.writeMicroseconds(DUR_SAG - hizSag * 5);             // sağ teker ters takılı / right wheel is mounted reversed
13}
14
15void setup() {
16  sol.attach(9);
17  sag.attach(10);
18  surus(0, 0);
19  delay(1000);
20}
21
22void loop() {
23  surus(80, 80);    delay(1500);     // ileri / forward
24  surus(0, 0);      delay(500);      // dur / stop
25  surus(-60, 60);   delay(600);      // yerinde sola dön / spin left in place
26  surus(60, 60);    delay(1000);
27  surus(30, 80);    delay(1500);     // sola doğru yay çiz / curve to the left
28  surus(-80, -80);  delay(1000);     // geri / backward
29  surus(0, 0);      delay(2000);
30}

Zwei Servos drehen nie exakt gleich schnell; zieht dein Roboter zur Seite, statt geradeaus zu fahren, kalibriere den Stoppwert jedes Servos (DUR_SOL, DUR_SAG) einzeln und senke den Faktor des schnelleren etwas. Das Drehmoment von 1,5 kg·cm passt zu kleinen Robotern mit höchstens einigen Hundert Gramm Gesamtgewicht; für ein schwereres Chassis oder große Räder sind ein Gleichstrommotor mit L298N oder Getriebemotoren die bessere Wahl. Im Akkubetrieb liefern 4 NiMH-Zellen (4,8 V) die ideale Spannung; 4 frische Alkalibatterien kommen auf bis zu 6,4 V und können die Grenze des Servos überschreiten. Chassis und Sensoren komplett aufzubauen zeigt Arduino-Roboterauto bauen.

FS90R am ESP32

Die Servo-Bibliothek des Arduino läuft nicht auf dem ESP32; installiere stattdessen in der Bibliotheksverwaltung die Bibliothek ESP32Servo. Sie wird fast genauso benutzt, nur stellst du 50 Hz mit setPeriodHertz(50) ausdrücklich ein. Als Signalpin eignet sich nahezu jeder PWM-fähige GPIO; nur GPIO 34–39, die reine Eingänge sind, kommen nicht infrage. Schließ das rote Servokabel an den VIN-Pin (USB-5 V) des ESP32 oder an eine externe 5-V-Quelle an, nicht an 3V3. Der folgende Code beschleunigt den Servo sanft aus dem Stand auf volle Geschwindigkeit, bremst ihn dann ab und kehrt die Richtung um; im seriellen Monitor siehst du die Pulsdauer jedes Schritts.

1// ESP32 + FS90R: ESP32Servo kütüphanesiyle hız rampası
2// ESP32 + FS90R: a speed ramp with the ESP32Servo library
3#include <ESP32Servo.h>
4
5const int SERVO_PIN = 18;            // PWM verebilen herhangi bir GPIO / any PWM-capable GPIO
6Servo teker;
7
8void setup() {
9  Serial.begin(115200);
10  teker.setPeriodHertz(50);          // standart servo frekansı / standard servo frequency
11  teker.attach(SERVO_PIN, 1000, 2000);
12  teker.writeMicroseconds(1500);     // dur / stop
13  delay(1000);
14}
15
16void loop() {
17  for (int us = 1500; us <= 2000; us += 25) {   // yavaşça hızlan / speed up gently
18    teker.writeMicroseconds(us);
19    Serial.println(us);
20    delay(200);
21  }
22  for (int us = 2000; us >= 1000; us -= 25) {   // yavaşla, dur, ters yöne hızlan / slow down, stop, reverse
23    teker.writeMicroseconds(us);
24    Serial.println(us);
25    delay(200);
26  }
27  teker.writeMicroseconds(1500);
28  delay(2000);
29}

FS90R mit Raspberry Pi Pico und MicroPython

Beim Pico brauchst du keine zusätzliche Bibliothek: Stell das Objekt machine.PWM auf 50 Hz und gib die Pulsdauer mit duty_ns() in Nanosekunden vor. Die Funktion hiz() im Code wandelt einen Wert zwischen -100 und +100 in 1000–2000 µs um; trag in die Zeile DUR_US nur den Stoppwert ein, den du bei deiner Kalibrierung ermittelt hast. Wird das Programm mit Strg+C beendet, hält auch der Servo an; sonst läuft die PWM mit dem letzten Wert weiter und das Rad dreht sich weiter. Versorge den Servo über den Pin VBUS des Pico (die 5 V vom USB). Bist du neu bei MicroPython, lies zuerst MicroPython-Grundlagen.

1# Raspberry Pi Pico (MicroPython) + FS90R: hız -100 ... +100
2# Raspberry Pi Pico (MicroPython) + FS90R: speed -100 ... +100
3from machine import Pin, PWM
4import time
5
6servo = PWM(Pin(15))
7servo.freq(50)                        # 20 ms periyot / 20 ms period
8DUR_US = 1500                         # kalibrasyonla bulduğun durma noktası / your calibrated stop point
9
10def hiz(yuzde):
11    yuzde = max(-100, min(100, yuzde))
12    us = DUR_US + yuzde * 5           # -100 -> 1000 µs, +100 -> 2000 µs
13    servo.duty_ns(us * 1000)
14
15try:
16    while True:
17        for h in (50, 100, 0, -50, -100, 0):
18            hiz(h)
19            print("Hiz / speed:", h)
20            time.sleep(2)
21except KeyboardInterrupt:
22    hiz(0)                            # durdurunca teker dönmeye devam etmesin / stop the wheel on exit
23    servo.deinit()

Projektideen mit dem 360-Grad-Servo

• Mini-Linienfolger: Ein leichtes Chassis mit zwei FS90R und zwei Infrarotsensoren; die Logik erklärt Linienfolger-Roboter.
• Hindernisvermeidender Roboter: Setz einen HC-SR04 vorn auf, damit er bei einem Hindernis auf der Stelle dreht und die Richtung wechselt.
• Per Handy gesteuertes Fahrzeug: Schick die Befehle über ein HC-05-Bluetooth-Modul vom Handy.
• Futterautomat: Der FS90R dreht eine Förderschnecke, und per Timer fällt zu festen Zeiten Futter heraus.
• Drehteller für Präsentationen: Eine sehr langsam drehende Plattform für Produktfotos oder Zeitraffer; die Geschwindigkeit stellst du mit Werten nahe 1500 µs ein.
• Kleine Seilwinde oder Vorhangzug: Eine leichte Schnur aufwickeln, zwei Endschalter an den Enden stoppen den Motor an der richtigen Stelle.

Häufige Fehler und Lösungen

Der FS90R ist der einfachste Weg, eine sich dauerhaft drehende Mechanik ohne Motortreiber mit einem einzigen Pin zu steuern: Bei 1500 µs steht er, er dreht in beide Richtungen mit beliebiger Geschwindigkeit und ist ein fertiger Radmotor für kleine Roboter. Stell den Stopppunkt einmal ein und nimm für Aufgaben mit Positionsregelung einen normalen Servo oder Schrittmotor, dann läuft er lange ohne Probleme. In der BlueGrays-App findest du Servo-Grundlagen, Servosteuerung mit Potentiometer und Joystick, einen 360-Grad-Servo aus einem Schrittmotor und Roboterauto-Projekte, jeweils mit Schaltplänen und fertigem Code Schritt für Schritt.