Servo a 360 gradi (FS90R): controllo di velocità e direzione

Un servo a 360 gradi si chiama servo, ma in realtà è un piccolo motoriduttore che continua a girare invece di portarsi a un angolo e fermarsi lì. Il più noto è il FEETECH FS90R: ha le stesse dimensioni e gli stessi tre fili di un SG90, ma il segnale che gli invii non stabilisce un angolo, bensì la velocità e il verso di rotazione. Dato che si collega direttamente a un pin di Arduino senza driver per motori, è comodissimo per le ruote di piccoli robot, le piattaforme girevoli e i distributori di cibo.

In questa guida scoprirai cosa cambia dentro l'FS90R rispetto a un servo normale, perché il comando write(90) ferma il motore, come regolare velocità e verso con la larghezza dell'impulso e come usare il trimmer di arresto per correggere un servo che continua a girare da solo. Poi guiderai un piccolo robot con due FS90R, regolerai la velocità con un potenziometro e proverai la stessa cosa con un ESP32 e un Raspberry Pi Pico. Infine vedrai perché questo servo non può fare controllo di posizione e cosa scegliere al suo posto.

Cos'è un servo a 360 gradi e in cosa differisce da un servo normale?

Un servo normale contiene un piccolo motore in corrente continua, un riduttore, un circuito di controllo e un potenziometro collegato all'albero di uscita. Il circuito confronta l'angolo richiesto dall'impulso con l'angolo reale letto dal potenziometro e fa girare il motore finché la differenza è zero; quando l'albero raggiunge l'obiettivo, si ferma. Nel servo a rotazione continua questo anello di retroazione è interrotto: il potenziometro è scollegato dall'albero e bloccato in posizione centrale, e il fermo meccanico negli ingranaggi è stato tolto. Il circuito continua a calcolare la "differenza tra posizione voluta e posizione reale", ma poiché quella reale non cambia mai, la differenza non si annulla mai. Risultato: più grande è la differenza, più veloce gira il motore, e il suo segno decide il verso.

Caratteristiche tecniche dell'FS90R

Collegamento dell'FS90R: Arduino Uno, ESP32 e Pico

Per far girare un solo FS90R a vuoto basta il pin 5V dell'Uno. Quando la ruota tocca terra o due servo partono insieme, la corrente sale a qualche centinaio di milliampere; la tensione USB cala, Arduino può riavviarsi o i servo tremano. Perciò in un robot alimenta i servo da una sorgente a 5 V separata (4 pile NiMH, un regolatore a 5 V o un alimentatore adatto), collega sempre il GND di questa alimentazione a quello di Arduino e aggiungi un condensatore da 470 µF vicino ai fili dei servo. Il segnale a 3,3 V di ESP32 e Pico basta per l'FS90R; il servo però va comunque alimentato a 5 V, non dal pin a 3,3 V.

write(90) = stop: come la larghezza dell'impulso diventa velocità?

Il segnale di controllo di un servo è un impulso inviato 50 volte al secondo (ogni 20 ms), e ciò che conta è la sua durata. Per l'FS90R, 1500 µs significa "fermo". Se l'impulso supera i 1500 µs, il servo accelera in un verso; se si accorcia, nell'altro; raggiunge la massima velocità intorno a 1000 µs e 2000 µs, oltre i quali la velocità quasi non aumenta. Per questo nella libreria Servo di Arduino write(90) significa fermo, mentre write(0) e write(180) significano massima velocità nei due versi. Qui c'è una piccola trappola: per impostazione predefinita la libreria converte 0–180 nell'intervallo 544–2400 µs, quindi write(90) produce in realtà 1472 µs. Questa differenza può bastare a far girare lentamente il servo anche con write(90). La soluzione è restringere l'intervallo con attach(9, 1000, 2000) o usare direttamente writeMicroseconds(1500).

Primo sketch: avanti, stop, indietro

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}

Lo sketch collega il servo a D9 e, con attach(9, 1000, 2000), adatta la scala di write() all'intervallo che l'FS90R usa davvero; così write(90) vale esattamente 1500 µs. La velocità non segue l'impulso in modo lineare: proprio intorno a 1500 µs c'è una banda morta di qualche decina di microsecondi in cui il servo non si muove, nell'intervallo 1500 ± 300 µs la velocità sale rapidamente e verso le estremità resta quasi costante. Se vuoi movimenti lenti e precisi, resta vicino a 1500 µs. L'idea generale della larghezza d'impulso è in Cos'è il PWM, il controllo dell'angolo dei servo normali in Cos'è un servomotore.

Regolare il trimmer di arresto (punto centrale)

1. Carica lo sketch di calibrazione qui sotto; il servo riceve un segnale da 1500 µs e normalmente dovrebbe restare fermo.
2. Se il servo gira piano, cerca il piccolo foro sul lato del corpo, vicino all'uscita del cavo; dentro c'è il trimmer che stabilisce il punto di arresto.
3. Gira il trimmer pochissimo con un piccolo cacciavite piatto o a croce; se il servo rallenta, stai andando nella direzione giusta.
4. Continua a piccoli passi finché il servo si ferma del tutto e sparisce anche il leggero ronzio. Il trimmer è molto sensibile: anche un quarto di giro è troppo.
5. Se preferisci non toccare il trimmer, invia + e - dal Monitor seriale per trovare il valore di impulso a cui il servo si ferma e usa quel valore nel codice al posto di 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}

Velocità e verso con un potenziometro

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 il potenziometro collegato tra 5V, A0 e GND, la posizione centrale significa fermo, girare a destra significa avanti e girare a sinistra indietro. Il codice definisce una zona morta di ±40 passi al centro, così il servo si ferma con sicurezza anche se il potenziometro non è perfettamente centrato o le letture oscillano un po'. Fuori dalla zona morta il valore viene convertito in 1540–2000 µs o in 1460–1000 µs: girando poco la manopola il servo va piano, girandola fino in fondo va alla massima velocità. Puoi applicare la stessa idea con un joystick; il collegamento del potenziometro è in Cos'è un potenziometro.

L'FS90R come ruota di un piccolo robot

L'FS90R piace tanto nei robot per la sua semplicità: con riduttore e circuito di controllo integrati non servono driver per motori, ponte H né encoder; basta un pin di segnale per ruota. I due servo si montano ai lati del telaio a specchio, quindi per andare avanti uno deve girare in senso orario e l'altro in senso antiorario. Il codice qui sotto gestisce questa inversione dentro la funzione surus(); tu indichi solo una velocità tra -100 e +100. Una ruota da 60 mm di diametro che gira a 130 giri/min a 6 V percorre circa 0,4 metri al secondo; a 4,8 V si scende a circa 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}

Due servo non girano mai esattamente alla stessa velocità; se il robot devia da un lato invece di andare dritto, calibra separatamente il valore di arresto di ciascun servo (DUR_SOL, DUR_SAG) e riduci un po' il coefficiente di quello più veloce. La coppia di 1,5 kg·cm dell'FS90R va bene per piccoli robot che pesano al massimo qualche centinaio di grammi; per un telaio più pesante o ruote grandi è meglio un motore DC con L298N o dei motoriduttori. A batteria, 4 pile NiMH (4,8 V) danno la tensione ideale; 4 alcaline nuove possono arrivare a 6,4 V e superare il limite del servo. Per montare un telaio completo con sensori, vedi Costruire una macchinina robot con Arduino.

FS90R con l'ESP32

La libreria Servo di Arduino non funziona sull'ESP32; installa invece la libreria ESP32Servo dal Gestore librerie. Si usa quasi allo stesso modo, solo che indichi esplicitamente i 50 Hz con setPeriodHertz(50). Per il segnale va bene quasi qualsiasi GPIO in grado di generare PWM; solo i GPIO 34–39, che sono di solo ingresso, non si possono usare. Collega il filo rosso del servo al pin VIN (5 V dell'USB) dell'ESP32 o a un'alimentazione esterna a 5 V, non al pin 3V3. Il codice seguente porta dolcemente il servo da fermo alla massima velocità, poi lo rallenta e ne inverte il verso; nel Monitor seriale vedi la durata dell'impulso a ogni 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 con il Raspberry Pi Pico e MicroPython

Sul Pico non serve alcuna libreria aggiuntiva: imposti l'oggetto machine.PWM a 50 Hz e dai la durata dell'impulso in nanosecondi con duty_ns(). La funzione hiz() del codice converte un valore tra -100 e +100 in 1000–2000 µs; basta scrivere nella riga DUR_US il valore di arresto trovato con la tua calibrazione. Quando il programma viene interrotto con Ctrl+C, anche il servo si ferma; altrimenti il PWM continua con l'ultimo valore e la ruota continua a girare. Alimenta il servo dal pin VBUS del Pico (i 5 V dell'USB). Se sei alle prime armi con MicroPython, leggi prima Basi di 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()

Idee di progetto con il servo a 360 gradi

• Mini inseguitore di linea: Un telaio leggero con due FS90R e due sensori a infrarossi; la logica è in Robot inseguitore di linea.
• Robot che evita gli ostacoli: Aggiungi davanti un HC-SR04 perché giri su sé stesso e cambi direzione quando vede un ostacolo.
• Auto comandata dal telefono: Invia i comandi dal telefono con un modulo Bluetooth HC-05.
• Distributore di cibo: L'FS90R fa girare una coclea e un timer fa cadere il cibo a orari fissi.
• Piattaforma girevole espositiva: Una base che ruota molto lentamente per foto di prodotto o timelapse; regola la velocità con valori vicini a 1500 µs.
• Piccolo argano o tira-tende: Avvolgi un filo leggero e metti due finecorsa alle estremità per fermare il motore nel punto giusto.

Errori comuni e soluzioni

L'FS90R è il modo più semplice per comandare un meccanismo a rotazione continua con un solo pin e senza driver: si ferma a 1500 µs, gira nei due versi alla velocità che vuoi ed è un motore per ruote già pronto per piccoli robot. Regola una volta il punto di arresto, ricordati di passare a un servo normale o a un motore passo-passo quando serve il controllo di posizione, e funzionerà a lungo senza problemi. Nell'app BlueGrays trovi l'uso di base del servo, il controllo del servo con potenziometro e joystick, la costruzione di un servo a 360 gradi da un motore passo-passo e progetti di macchinine robot, con schemi di collegamento e codice pronto passo passo.