Servo de 360 graus (FS90R): velocidade e direção com Arduino

Um servo de 360 graus pode ter o nome de servo, mas na verdade é um pequeno motor com redução que gira continuamente, em vez de ir até um ângulo e parar ali. O mais conhecido é o FEETECH FS90R: ele tem o mesmo tamanho e os mesmos três fios de um SG90, mas o sinal enviado define sua velocidade e direção de rotação em vez de um ângulo. Como se conecta diretamente a um pino do Arduino sem driver de motor, é muito prático para rodas de pequenos robôs, plataformas giratórias e projetos como alimentadores para animais de estimação.

Neste guia, você vai aprender o que muda dentro do FS90R em comparação com um servo normal, por que o comando write(90) para o motor, como definir a velocidade e a direção pela largura do pulso e como usar o trimpot de parada para ajustar um servo que continua girando lentamente. Depois, vai movimentar um pequeno robô com dois FS90R, controlar a velocidade com um potenciômetro e experimentar a mesma coisa no ESP32 e no Raspberry Pi Pico. Por fim, vai entender por que esse servo não consegue controlar a posição e o que escolher no lugar dele.

O que é um servo de 360 graus e como ele difere de um servo normal?

Um servo normal contém um pequeno motor CC, uma caixa de redução, um circuito de controle e um potenciômetro ligado ao eixo de saída. O circuito de controle compara o ângulo solicitado pelo pulso recebido com o ângulo real lido pelo potenciômetro e gira o motor até que a diferença seja zero; quando o eixo chega ao alvo, ele para. Em um servo de rotação contínua, essa ligação de realimentação é interrompida: o potenciômetro é desconectado do eixo e fixado na posição central, e o batente mecânico das engrenagens é removido. O circuito continua calculando a “diferença entre a posição desejada e a real”, mas, como a posição real nunca muda, a diferença nunca desaparece. Assim, quanto maior a diferença, mais rápido o motor gira, e o sinal da diferença define a direção.

Especificações do FS90R

Ligação do FS90R: Arduino Uno, ESP32 e Pico

O pino 5V do Uno é suficiente para acionar um único FS90R sem carga. Quando a roda do servo encosta no chão ou dois servos partem juntos, a corrente sobe para algumas centenas de miliampères; a tensão do USB cai, o Arduino pode reiniciar ou os servos podem tremer. Por isso, em um robô, alimente os servos com uma fonte separada de 5 V (4 pilhas NiMH, um regulador de 5 V ou uma fonte de alimentação adequada), sempre conecte o GND da alimentação dos servos ao GND do Arduino e adicione um capacitor de 470 µF perto dos fios dos servos. O sinal de 3,3 V do ESP32 e do Pico é suficiente para o FS90R; o servo em si ainda deve ser alimentado com 5 V, não pelo pino de 3,3 V.

write(90) = parar: como a largura do pulso se transforma em velocidade?

O sinal de controle do servo é um pulso enviado 50 vezes por segundo (a cada 20 ms), e o que importa é a duração do pulso. Para o FS90R, 1.500 µs significa “parar”. Conforme o pulso fica mais longo que 1.500 µs, o servo acelera em uma direção; conforme fica mais curto, acelera na outra; ele atinge a velocidade máxima por volta de 1.000 µs e 2.000 µs, e além disso a velocidade quase não aumenta. Por isso, write(90) na biblioteca Servo do Arduino significa parar, e write(0) e write(180) significam velocidade máxima em cada direção. Há uma pequena armadilha aqui: por padrão, a biblioteca mapeia 0–180 para a faixa de 544–2.400 µs, então write(90) na verdade gera 1.472 µs. Essa diferença pode ser suficiente para o servo girar lentamente mesmo com write(90). A solução é reduzir a faixa com attach(9, 1000, 2000) ou usar writeMicroseconds(1500) diretamente.

Primeiro sketch: avançar, parar, recuar

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}

O sketch associa o servo ao D9 e, com attach(9, 1000, 2000), mapeia a escala de write() para a faixa que o FS90R realmente usa, de modo que write(90) seja exatamente 1.500 µs. A velocidade não acompanha o pulso de forma linear: bem perto de 1.500 µs há uma zona morta de algumas dezenas de microssegundos em que o servo não se move; na faixa de 1.500 ± 300 µs, a velocidade sobe rapidamente e, perto das extremidades, fica quase constante. Se você quer um movimento lento e preciso, mantenha os valores próximos de 1.500 µs. A ideia geral da largura de pulso está em O que é PWM, e o controle de ângulo com servos normais em O que é um servo motor.

Ajuste do trimpot de parada (centro)

1. Carregue o sketch de calibração abaixo; o servo recebe um sinal de 1.500 µs e normalmente deve parar.
2. Se o servo girar lentamente, encontre o pequeno orifício na lateral da carcaça, perto da saída do cabo; dentro dele fica o trimpot que ajusta o ponto de parada.
3. Gire o trimpot bem pouco com uma pequena chave de fenda ou Phillips; se o servo desacelerar, você está girando na direção certa.
4. Continue em pequenos passos até o servo parar completamente e até o zumbido fraco desaparecer. O trimpot é muito sensível; mesmo um quarto de volta já é demais.
5. Se preferir não mexer no trimpot, envie + e - pelo Monitor Serial para encontrar o valor de pulso em que o servo para e use esse valor no lugar de 1500 no código.

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}

Controle de velocidade e direção com 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}

Com o potenciômetro conectado entre 5V, A0 e GND, a posição central significa parar, girar para a direita significa avançar e girar para a esquerda significa recuar. O código define uma zona morta de ±40 passos no centro, para que o servo pare de forma confiável mesmo que o potenciômetro não esteja exatamente centralizado ou que as leituras oscilem um pouco. Fora da zona morta, o valor é mapeado para 1.540–2.000 µs ou 1.460–1.000 µs, de modo que girar um pouco o botão faça o servo girar devagar, e girá-lo até o fim dê velocidade máxima. Você pode aplicar a mesma ideia com um joystick; a ligação do potenciômetro está em O que é um potenciômetro.

O FS90R como roda de um pequeno robô

O FS90R é tão popular em robôs por ser simples: com a caixa de redução e o circuito de acionamento integrados, você não precisa de driver de motor, ponte H ou encoder separados; um pino de sinal por roda é suficiente. Os dois servos são montados em lados opostos do chassi, espelhados, então, para avançar, um deve girar no sentido horário e o outro no anti-horário. O código abaixo trata disso dentro da função surus(); você só informa uma velocidade entre -100 e +100. Uma roda de 60 mm girando a 130 rpm com 6 V percorre cerca de 0,4 metro por segundo; a 4,8 V, isso cai para cerca de 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}

Dois servos nunca giram exatamente na mesma velocidade; se o robô desviar para um lado em vez de seguir reto, calibre o valor de parada de cada servo (DUR_SOL, DUR_SAG) separadamente e reduza um pouco o fator do mais rápido. O torque de 1,5 kg·cm do FS90R é adequado para pequenos robôs que pesem no máximo algumas centenas de gramas; para um chassi mais pesado ou rodas grandes, um motor CC com L298N ou motores com redução são a melhor escolha. Com pilhas, 4 células NiMH (4,8 V) fornecem a tensão ideal; 4 pilhas alcalinas novas podem chegar a 6,4 V e ultrapassar o limite do servo. Para uma montagem completa com chassi e sensores, veja Como fazer um carrinho robô com Arduino.

FS90R com ESP32

A biblioteca Servo do Arduino não funciona no ESP32; instale a biblioteca ESP32Servo pelo Gerenciador de Bibliotecas. O uso é quase igual, exceto por definir explicitamente 50 Hz com setPeriodHertz(50). Quase qualquer GPIO capaz de gerar PWM serve para o sinal; apenas GPIO 34–39, que são somente entradas, não podem ser usados para isso. Conecte o fio vermelho do servo ao pino VIN (5 V do USB) do ESP32 ou a uma fonte externa de 5 V, não ao pino 3V3. O código abaixo acelera o servo suavemente da parada até a velocidade máxima, depois desacelera e inverte a direção; o Monitor Serial mostra a duração do pulso a cada passo.

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 com Raspberry Pi Pico e MicroPython

No Pico, você não precisa de biblioteca extra: configure o objeto machine.PWM para 50 Hz e informe a duração do pulso em nanossegundos com duty_ns(). A função hiz() no código converte um valor entre -100 e +100 em 1.000–2.000 µs; basta colocar o valor de parada encontrado na sua calibração na linha DUR_US. Quando o programa é interrompido com Ctrl+C, o servo também para; caso contrário, o PWM continua funcionando com o último valor e a roda continua girando. Alimente o servo pelo pino VBUS do Pico (os 5 V do USB). Se você está começando com MicroPython, leia primeiro Fundamentos 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()

Ideias de projetos com servo de 360 graus

• Mini robô seguidor de linha: Um chassi leve com dois FS90R e dois sensores infravermelhos; a lógica está em robô seguidor de linha.
• Robô que desvia de obstáculos: Adicione um HC-SR04 na frente para que ele gire no lugar e mude de direção ao detectar um obstáculo.
• Carrinho controlado pelo celular: Envie comandos pelo celular com um módulo Bluetooth HC-05.
• Alimentador para animais de estimação: Faça o FS90R girar uma rosca sem-fim para que a ração caia em horários definidos por um temporizador.
• Plataforma giratória de exposição: Uma plataforma que gira bem devagar para fotos de produtos ou tomadas em time-lapse; ajuste a velocidade com valores próximos de 1.500 µs.
• Pequeno guincho ou acionador de cortina: Enrole um cordão leve, com duas chaves de fim de curso nas extremidades para parar o motor no lugar certo.

Problemas comuns e soluções

O FS90R é a maneira mais fácil de controlar um mecanismo que gira continuamente com um único pino e sem driver de motor: ele para em 1.500 µs, gira nos dois sentidos na velocidade que você quiser e já vem pronto para acionar rodas de pequenos robôs. Ajuste o ponto de parada uma vez, lembre-se de usar um servo normal ou um motor de passo para tarefas que exigem controle de posição, e ele funcionará sem problemas por muito tempo. No app BlueGrays, você encontra fundamentos de servos, controle de servo com potenciômetro e joystick, construção de um servo de 360 graus a partir de um motor de passo e projetos de carrinhos robôs, com diagramas de fiação passo a passo e código pronto para usar.