Un servocomando hobby non vuole una tensione, una corrente o un pin di direzione. Vuole un impulso, ripetuto all'infinito, e la durata di quell'impulso è l'angolo che stai chiedendo. Tutto il resto — coppia, velocità, forza di tenuta — se lo gestisce il servo.
Il filo di comando porta una semplice onda quadra digitale. Ogni 20 ms la linea va alta per un tempo compreso tra 1,0 ms e 2,0 ms, poi torna bassa per tutto il resto della trama. Il servo ignora quasi del tutto il tempo basso: misura soltanto quanto la linea è rimasta alta.
1,5 ms è il centro. Impulsi più corti portano la squadretta da una parte, impulsi più lunghi dall'altra. Se smetti di inviare impulsi la maggior parte dei servi si "ammorbidisce" nel giro di poche trame; se continui a inviare sempre lo stesso impulso, il servo contrasta attivamente qualsiasi cosa provi a spostarlo.
Un servo è un piccolo motore in continua, un rotismo di riduzione, un potenziometro solidale all'albero di uscita e un controllore che confronta le due cose. L'impulso fissa il riferimento, il potenziometro dice dove si trova davvero la squadretta e il driver fa girare il motore finché la differenza non è zero. Tutto qui — ed è per questo che la squadretta reagisce se provi a ruotarla a mano, e per questo che un servo in stallo si scalda.
L'intervallo 1,0–2,0 ms è una convenzione, non una legge. Molti servi lavorano bene da circa 0,5 ms a 2,5 ms e quasi nessuno è centrato esattamente a 1,5 ms appena tolto dalla scatola. Prendi la tabella come punto di partenza, poi taratura degli estremi sul servo che hai davvero sul banco.
| Durata impulso | Angolo tipico | Servo standard | Rotazione continua |
|---|---|---|---|
| 0,50 ms | −45° | Fuori specifica — può ronzare o stallare | Massima velocità, un verso |
| 1,00 ms | 0° | Un estremo della corsa | Massima velocità, un verso |
| 1,25 ms | 45° | Un quarto della corsa | Metà velocità |
| 1,50 ms | 90° | Neutro / centro | Fermo |
| 1,75 ms | 135° | Tre quarti della corsa | Metà velocità, verso opposto |
| 2,00 ms | 180° | Altro estremo della corsa | Massima velocità, verso opposto |
| 2,50 ms | 225° | Fuori specifica — può battere sul fine corsa | Massima velocità, verso opposto |
Nel segnale non c'è scritto da nessuna parte "180°". L'impulso è una frazione di un intervallo, ed è il servo — con il suo riduttore e il suo potenziometro — a decidere quanta corsa copre quell'intervallo. Un servo multigiro accetta esattamente le stesse trame a 50 Hz e le distribuisce su più giri completi.
L'esempio più chiaro è il goBILDA 2000 Series 5-Turn Dual Mode Servo: l'intervallo 500–2500 µs corrisponde a cinque giri — 1800° di corsa, sempre con tre fili e sempre con la trama da 20 ms. Il cablaggio non cambia e lo sketch quasi per niente: cambiano i conti.
La risoluzione. L'impulso si muove sempre a passi di microsecondo, quindi distribuire 2000 µs su 1800° lascia circa 1,1 µs per grado, contro gli 11 µs per grado circa di un servo da 180°. I servi multigiro servono per la corsa, non per la precisione: usali dove il meccanismo trasforma i giri in qualcos'altro — una vite senza fine, un verricello, un rinvio a cavo, una slitta lineare — e tieni un servo da 180° per un giunto che deve ripetere sempre lo stesso angolo.
write(90) non significa 90° su un servo multigiro. La libreria mappa 0–180 sull'intervallo che hai passato ad attach(), quindi su un servo da 5 giri write(90) finisce a metà corsa: 2,5 giri, 900°. Comandalo in microsecondi, oppure convertili tu a partire dai giri.
// goBILDA 2000 Series 5-Turn: 500...2500 us = 5 giri = 1800 gradi.
const int MIN_US = 500;
const int MAX_US = 2500;
const float TURNS = 5.0;
void setup() {
arm.attach(9, MIN_US, MAX_US); // passagli tutta la corsa
arm.writeMicroseconds(1500); // meta corsa = 2,5 giri
}
// Comanda l'albero in giri invece che in gradi.
int usForTurns(float turns) {
if (turns < 0) turns = 0;
if (turns > TURNS) turns = TURNS; // mai oltre il fine corsa
return MIN_US + (int)(turns / TURNS * (MAX_US - MIN_US));
}
arm.writeMicroseconds(usForTurns(0.0)); // 500 us — un estremo
arm.writeMicroseconds(usForTurns(1.0)); // 900 us — un giro completo
arm.writeMicroseconds(usForTurns(5.0)); // 2500 us — cinque giri
Appena tolto dalla scatola il servo da 5 giri lavora in modalità di posizione, con il potenziometro da 5 kΩ a chiudere l'anello, esattamente come nello schema a blocchi qui sopra. Il 3102 Series Dual Mode Servo Programmer lo commuta in rotazione continua: lì l'impulso comanda una velocità proporzionale invece di una posizione — 900–2100 µs, con 1500 µs che significa fermo. Un solo codice prodotto copre sia una vite a cinque giri sia una ruota motrice.
| goBILDA 2000 Series 5-Turn Dual Mode Servo (25-2, Torque) | |
|---|---|
| Rotazione totale | 5 giri (1800°) |
| Larghezza impulso — modalità posizione | 500 – 2500 µs |
| Larghezza impulso — rotazione continua | 900 – 2100 µs |
| Frequenza PWM | 50 Hz (20 ms) |
| Coppia di stallo | 17,2 kg·cm a 4,8 V · 21,6 a 6,0 V · 25,2 a 7,4 V |
| Velocità a vuoto | 0,25 s/60° a 4,8 V · 0,20 a 6,0 V · 0,17 a 7,4 V |
| Tensione di alimentazione | 4,8 – 7,4 V |
| Rapporto di riduzione | 300:1 |
| Retroazione | potenziometro da 5 kΩ |
| Scanalatura | 25 denti |
Segnale, V+ e massa. Il filo di segnale è quello chiaro — arancione, giallo o bianco — e sta sempre su un bordo del connettore; V+ è rosso, al centro; la massa è marrone o nera. Il segnale assorbe praticamente nulla, quindi qualsiasi pin di Arduino può pilotarlo direttamente.
La trappola è V+. Un micro servo a riposo assorbe qualche decina di milliampere, ma appena deve muovere qualcosa arriva a un ampere e oltre: il regolatore a bordo di Arduino non ce la fa. Alimentare un servo sotto carico dal pin 5 V della scheda fa cadere la tensione al microcontrollore a metà movimento: la scheda si resetta, lo sketch riparte, il servo scatta — e sembra tutto un bug del firmware. Dai al servo il suo alimentatore e collega insieme le masse.
La libreria Servo inclusa nell'IDE genera le trame da 20 ms in background usando un timer hardware, così il tuo loop non deve occuparsene. Su UNO gestisce fino a dodici servi e, mentre è attiva, disabilita analogWrite() sui pin 9 e 10.
// Servo hobby su D9, alimentato da un alimentatore esterno a 5 V
// con la massa collegata al GND di Arduino.
#include <Servo.h>
Servo braccio;
const int SERVO_PIN = 9;
void setup() {
braccio.attach(SERVO_PIN, 1000, 2000); // pin, min us, max us
braccio.write(90); // parte al centro
delay(500);
}
void loop() {
// Corsa di andata: un grado ogni 15 ms, lento quanto basta.
for (int angolo = 0; angolo <= 180; angolo++) {
braccio.write(angolo);
delay(15);
}
delay(300);
// ...e ritorno.
for (int angolo = 180; angolo >= 0; angolo--) {
braccio.write(angolo);
delay(15);
}
delay(300);
}
write(90) è una comodità: internamente converte l'angolo nell'intervallo in microsecondi passato ad attach(). Quando conta l'impulso vero — taratura degli estremi, oppure un servo a rotazione continua dove i gradi non significano nulla — conviene ragionare in microsecondi.
// Lo stesso servo, comandato per durata dell'impulso e non per angolo.
braccio.writeMicroseconds(1000); // un estremo della corsa
braccio.writeMicroseconds(1500); // neutro — un servo CR qui sta fermo
braccio.writeMicroseconds(2000); // altro estremo della corsa
// Per trovare i limiti reali: allarga di 25 us alla volta e fermati
// appena senti il servo ronzare contro il fine corsa meccanico.
int impulsoPer(int angolo) {
return map(angolo, 0, 180, MIN_US, MAX_US); // valori misurati
}
Infine la versione senza libreria. Non è così che si pilota un servo in uno sketch vero — delay() blocca tutto il resto — ma rende concreto il diagramma dei tempi ed è la strada da percorrere quando non hai un timer libero.
// Costruiamo a mano la trama a 50 Hz: alta per la durata
// dell'impulso, bassa per il resto dei 20 000 us di periodo.
const int SERVO_PIN = 9;
const unsigned long TRAMA_US = 20000;
void setup() {
pinMode(SERVO_PIN, OUTPUT);
}
void inviaTrama(int impulsoUs) {
digitalWrite(SERVO_PIN, HIGH);
delayMicroseconds(impulsoUs); // 1000...2000 us — il comando
digitalWrite(SERVO_PIN, LOW);
delayMicroseconds(TRAMA_US - impulsoUs);
}
void loop() {
// Ogni posizione tenuta circa un secondo = 50 trame identiche.
for (int i = 0; i < 50; i++) inviaTrama(1000);
for (int i = 0; i < 50; i++) inviaTrama(1500);
for (int i = 0; i < 50; i++) inviaTrama(2000);
}
| Sintomo | Causa tipica | Rimedio |
|---|---|---|
| La scheda si resetta quando il servo si muove | Servo alimentato dal pin 5 V di Arduino | Alimentatore separato, masse collegate insieme |
| Non succede assolutamente nulla | Manca la massa comune, o segnale sul filo sbagliato | Collega le masse; il segnale è il filo chiaro esterno |
| Ronzio continuo da fermo | Comando oltre il fine corsa, o segnale disturbato | Restringi gli estremi; accorcia il cavo di segnale |
| Copre solo una parte della corsa | Valori di default della libreria più stretti della corsa reale | attach(pin, min, max) con i valori misurati |
| Gira all'infinito invece di tenere l'angolo | È un servo a rotazione continua | 1,5 ms significa "fermo", non "centro" |
| Gira molto più dell'angolo richiesto | È un servo multigiro: l'intervallo copre più giri completi | Comandalo in microsecondi, o converti dai giri |
| Si scalda e perde coppia | In stallo su un carico che non riesce a muovere | Più coppia, oppure demoltiplica il carico |
Un servocomando hobby vuole un segnale PWM a 50 Hz: una trama da 20 ms in cui la linea resta alta da 1,0 a 2,0 ms. La durata dell'impulso e il comando di posizione - 1,0 ms a un estremo della corsa, 1,5 ms al centro, 2,0 ms all'altro estremo. Il livello logico puo essere 3,3 V o 5 V.
Non sotto carico. Un micro servo assorbe un ampere o piu appena si muove e il regolatore a bordo di Arduino non ce la fa: la scheda si resetta a meta movimento. Usa un alimentatore da 5-6 V dedicato e collega la sua massa al GND di Arduino, altrimenti l'impulso non ha riferimento.
In un servo standard il potenziometro sull'albero di uscita chiude l'anello di posizione, quindi l'impulso indica un angolo. In un servo a rotazione continua quel collegamento non c'e e lo stesso impulso indica una velocita: 1,5 ms significa fermo, valori piu corti o piu lunghi fanno girare l'albero nei due versi.
Un servo multigiro come il goBILDA 2000 Series 5-Turn distribuisce l'intervallo 500-2500 us su cinque giri, cioe 1800 gradi. Comandarlo in gradi con write() non ha piu senso: usa writeMicroseconds() e converti dai giri, ricordando che restano circa 1,1 us per grado contro gli 11 us per grado di un servo da 180 gradi.
Di solito perche gli stai chiedendo una posizione oltre il fine corsa meccanico, oppure perche il segnale e disturbato. Stringi i valori minimo e massimo passati ad attach(), accorcia il filo di segnale e verifica che l'alimentatore condivida la massa con Arduino.
La libreria Servo gestisce fino a dodici servi su una UNO (fino a 48 su una Mega) e mentre e attiva disabilita analogWrite() sui pin 9 e 10. Il limite pratico e pero l'alimentazione: conta almeno 1 A per servo sotto carico e usa un alimentatore esterno.
Il segnale è la parte facile. La parte difficile è scegliere un servo con coppia, velocità e attacchi adatti al meccanismo — e poi fissarlo a qualcosa che non gli strappi via l'albero di uscita. In questa categoria abbiamo 57 prodotti, costruiti attorno al sistema metrico goBILDA: squadrette, mozzi, staffe e alberi sono allineati con il resto della struttura.
Commutabili tra angolo e rotazione continua: lo stesso pezzo per un giunto o per una ruota motrice
SfogliaSquadrette metalliche e mozzi a serraggio che si fissano al passo forato standard, non solo alla cava in plastica
SfogliaSupporti su cuscinetti che scaricano lo sforzo radiale dall'albero di uscita — la causa più comune di servi bruciati
SfogliaProgrammatori per modalità ed estremi corsa, più prolunghe e alberini
SfogliaCoppia, assorbimento e dimensioni sono indicati su ogni scheda prodotto. Non sai quale servo serve al tuo meccanismo? Chiedicelo: rispondiamo con codici prodotto, non con dépliant.