Servo de 360 grados (FS90R): control de velocidad y dirección

Un servo de 360 grados se llama servo, pero en realidad es un pequeño motorreductor que gira sin parar, en lugar de ir a un ángulo y quedarse allí. El más conocido es el FEETECH FS90R: tiene el mismo tamaño y los mismos tres cables que un SG90, pero la señal que le envías no fija un ángulo, sino su velocidad y sentido de giro. Como se conecta directamente a un pin de Arduino sin driver de motor, resulta muy práctico para ruedas de robots pequeños, plataformas giratorias y comederos automáticos.

En esta guía aprenderás qué cambia dentro del FS90R respecto a un servo normal, por qué el comando write(90) detiene el motor, cómo ajustar velocidad y sentido con el ancho de pulso y cómo usar el trimmer de parada para corregir un servo que sigue girando solo. Después moverás un pequeño robot con dos FS90R, controlarás la velocidad con un potenciómetro y probarás lo mismo con un ESP32 y una Raspberry Pi Pico. Por último verás por qué este servo no puede hacer control de posición y qué elegir en su lugar.

¿Qué es un servo de 360 grados y en qué se diferencia de un servo normal?

Un servo normal contiene un pequeño motor de corriente continua, una reductora, un circuito de control y un potenciómetro unido al eje de salida. El circuito compara el ángulo que pide el pulso con el ángulo real que marca el potenciómetro y gira el motor hasta que la diferencia es cero; cuando el eje llega al objetivo, se detiene. En un servo de rotación continua ese lazo de realimentación está cortado: el potenciómetro está separado del eje y fijado en su posición central, y el tope mecánico de los engranajes ha desaparecido. El circuito sigue calculando la "diferencia entre la posición deseada y la real", pero como la posición real nunca cambia, la diferencia nunca se cierra. El resultado es que cuanto mayor es la diferencia, más rápido gira el motor, y su signo marca el sentido.

Características técnicas del FS90R

Conexión del FS90R: Arduino Uno, ESP32 y Pico

Para mover un solo FS90R sin carga basta con el pin 5V del Uno. Cuando la rueda del servo toca el suelo o dos servos arrancan a la vez, la corriente sube a unos cientos de miliamperios; la tensión del USB cae, el Arduino puede reiniciarse o los servos tiemblan. Por eso, en un robot, alimenta los servos desde una fuente de 5 V aparte (4 pilas NiMH, un regulador de 5 V o una fuente adecuada), une siempre el GND de esa alimentación con el GND del Arduino y añade un condensador de 470 µF cerca de los cables del servo. La señal de 3,3 V del ESP32 y de la Pico es suficiente para el FS90R; el servo en sí debe alimentarse igualmente con 5 V, no desde el pin de 3,3 V.

write(90) = parar: ¿cómo se convierte el ancho de pulso en velocidad?

La señal de control de un servo es un pulso que se envía 50 veces por segundo (cada 20 ms), y lo que importa es su duración. Para el FS90R, 1500 µs significa "parar". Si el pulso dura más de 1500 µs, el servo acelera en un sentido; si dura menos, en el otro; alcanza la velocidad máxima alrededor de 1000 µs y 2000 µs, y más allá apenas acelera. Por eso, en la biblioteca Servo de Arduino, write(90) significa parar, y write(0) y write(180), velocidad máxima en cada sentido. Aquí hay una pequeña trampa: por defecto la biblioteca convierte 0–180 al rango 544–2400 µs, así que write(90) produce en realidad 1472 µs. Esa diferencia puede bastar para que el servo siga girando despacio incluso con write(90). La solución es estrechar el rango con attach(9, 1000, 2000) o usar directamente writeMicroseconds(1500).

Primer programa: adelante, parar, atrás

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}

El programa conecta el servo a D9 y, con attach(9, 1000, 2000), ajusta la escala de write() al rango que el FS90R usa de verdad; así write(90) da exactamente 1500 µs. La velocidad no sigue al pulso de forma lineal: justo alrededor de 1500 µs hay una banda muerta de unas decenas de microsegundos en la que el servo no se mueve, entre 1500 ± 300 µs la velocidad sube rápido y hacia los extremos se mantiene casi constante. Si quieres movimientos lentos y precisos, mantén los valores cerca de 1500 µs. La idea general del ancho de pulso está en Qué es PWM, y el control de ángulo de los servos normales en Qué es un servomotor.

Ajuste del trimmer de parada (punto central)

1. Carga el programa de calibración de abajo; el servo recibe una señal de 1500 µs y debería quedarse quieto.
2. Si el servo gira despacio, busca el pequeño orificio en el lateral de la carcasa, cerca de la salida del cable; dentro está el trimmer que fija el punto de parada.
3. Gira el trimmer muy poco con un destornillador pequeño plano o de estrella; si el servo se frena, vas en la dirección correcta.
4. Sigue con pasos pequeños hasta que el servo se pare del todo y desaparezca incluso el leve zumbido. El trimmer es muy sensible; incluso un cuarto de vuelta es demasiado.
5. Si prefieres no tocar el trimmer, envía + y - desde el Monitor Serie para encontrar el valor de pulso en el que el servo se para y usa ese valor en tu código en lugar de 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}

Control de velocidad y sentido con un potenciómetro

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}

Con el potenciómetro conectado entre 5V, A0 y GND, la posición central significa parar, girar a la derecha significa avanzar y girar a la izquierda, retroceder. El código define una zona muerta de ±40 pasos en el centro, para que el servo se detenga con seguridad aunque el potenciómetro no esté justo en medio o las lecturas bailen un poco. Fuera de la zona muerta el valor se convierte a 1540–2000 µs o a 1460–1000 µs, de modo que al girar un poco el mando el servo va despacio y al girarlo del todo, a máxima velocidad. Puedes aplicar la misma idea con un joystick; la conexión del potenciómetro está en Qué es un potenciómetro.

El FS90R como rueda de un robot pequeño

El FS90R gusta tanto en robótica por su sencillez: como lleva la reductora y el circuito de control dentro, no necesitas driver de motor, puente H ni encoder; basta un pin de señal por rueda. Los dos servos se montan a ambos lados del chasis como imágenes en espejo, así que para avanzar uno debe girar en sentido horario y el otro en sentido contrario. El código de abajo resuelve esa inversión dentro de la función surus(); tú solo indicas una velocidad entre -100 y +100. Una rueda de 60 mm de diámetro que gira a 130 rpm con 6 V recorre unos 0,4 metros por segundo; con 4,8 V baja a unos 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}

Dos servos nunca giran exactamente a la misma velocidad; si tu robot se desvía a un lado en lugar de ir recto, calibra por separado el valor de parada de cada servo (DUR_SOL, DUR_SAG) y reduce un poco el factor del más rápido. El par de 1,5 kg·cm del FS90R es adecuado para robots pequeños de unos pocos cientos de gramos como mucho; para un chasis más pesado o ruedas grandes es mejor un motor de corriente continua con L298N o motorreductores. Con pilas, 4 NiMH (4,8 V) dan la tensión ideal; 4 alcalinas nuevas pueden llegar a 6,4 V y superar el límite del servo. Para montar el chasis completo con sensores, consulta Cómo hacer un coche robot con Arduino.

FS90R con el ESP32

La biblioteca Servo de Arduino no funciona en el ESP32; en su lugar instala la biblioteca ESP32Servo desde el Gestor de bibliotecas. Se usa casi igual, salvo que indicas los 50 Hz de forma explícita con setPeriodHertz(50). Para la señal sirve casi cualquier GPIO capaz de dar PWM; solo los GPIO 34–39, que son únicamente de entrada, no valen. Conecta el cable rojo del servo al pin VIN (5 V del USB) del ESP32 o a una fuente externa de 5 V, no al pin 3V3. El código siguiente lleva el servo con suavidad desde parado hasta la velocidad máxima, luego lo frena y lo hace girar al revés; en el Monitor Serie ves la duración del pulso en cada paso.

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 con la Raspberry Pi Pico y MicroPython

En la Pico no hace falta ninguna biblioteca extra: ajustas el objeto machine.PWM a 50 Hz y das la duración del pulso en nanosegundos con duty_ns(). La función hiz() del código convierte un valor entre -100 y +100 en 1000–2000 µs; basta con escribir en la línea DUR_US el valor de parada que encontraste en tu calibración. Cuando el programa se detiene con Ctrl+C, el servo también se para; si no, el PWM sigue con el último valor y la rueda continúa girando. Alimenta el servo desde el pin VBUS de la Pico (los 5 V del USB). Si eres nuevo en MicroPython, lee antes Conceptos básicos de MicroPython.

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()

Ideas de proyectos con el servo de 360 grados

• Mini seguidor de líneas: Un chasis ligero con dos FS90R y dos sensores infrarrojos; la lógica está en Robot seguidor de líneas.
• Robot que esquiva obstáculos: Añade un HC-SR04 delante para que gire sobre sí mismo y cambie de dirección al ver un obstáculo.
• Coche controlado desde el móvil: Envía las órdenes desde el teléfono con un módulo Bluetooth HC-05.
• Comedero automático: Que el FS90R haga girar un tornillo sinfín para que caiga comida a horas fijas con un temporizador.
• Plataforma giratoria de exposición: Una base que gira muy despacio para fotos de producto o timelapses; ajusta la velocidad con valores cercanos a 1500 µs.
• Pequeño cabrestante o recogedor de cortinas: Enrolla un cordel ligero y pon dos finales de carrera en los extremos para parar el motor en el sitio correcto.

Errores frecuentes y soluciones

El FS90R es la forma más sencilla de controlar un mecanismo de giro continuo con un solo pin y sin driver de motor: se para en 1500 µs, gira en ambos sentidos a la velocidad que quieras y es un motor de rueda listo para robots pequeños. Ajusta una vez el punto de parada, recuerda pasar a un servo normal o a un motor paso a paso cuando necesites control de posición y funcionará sin problemas mucho tiempo. En la app BlueGrays encontrarás el uso básico del servo, el control de servos con potenciómetro y joystick, cómo hacer un servo de 360 grados con un motor paso a paso y proyectos de coche robot, con esquemas de conexión y código listo paso a paso.