Servo MG90S Arduino: differenze con SG90, schema e calibrazione
Come usare il servo MG90S con Arduino: ingranaggi in metallo, differenze con SG90, colori dei fili, calibrazione 500–2400 µs e codice per Uno, ESP32 e Pico.
Il servo MG90S è un micro servo con le stesse dimensioni dell'SG90 ma con ingranaggi in metallo: con un corpo di 13,4 grammi offre una coppia di stallo di 1,8 kg·cm a 4,8 V e 2,2 kg·cm a 6 V, e sopporta urti, colpi del braccio e rotazioni accidentali a mano molto meglio dell'SG90 con ingranaggi in plastica. Usare il servo MG90S con Arduino è facile quanto con un SG90: stessi tre fili, stessa libreria Servo e stesso segnale a 50 Hz. Le differenze stanno nei dettagli: assorbe un po' più di corrente, l'intervallo degli impulsi cambia da esemplare a esemplare e, se vuoi angoli precisi, va calibrato.
In questa guida confronterai i dati tecnici dell'MG90S con quelli di SG90 e MG996R e vedrai i colori dei fili e i collegamenti con Arduino Uno, ESP32 e Raspberry Pi Pico. Poi imparerai come l'intervallo di impulsi 500–2400 µs si trasforma in un angolo, come trovare i limiti del tuo servo dal Monitor seriale e come correggere l'errore d'angolo con una calibrazione a tre punti. Le ultime sezioni riguardano il dimensionamento dell'alimentazione separata, il controllo dal telefono con un ESP32, il codice MicroPython per Pico e le articolazioni di un braccio robotico adatte all'MG90S.

Che cos'è il servo MG90S e come funziona?
Dentro l'MG90S ci sono un piccolo motore DC, un riduttore con ingranaggi in metallo che rallenta il motore e ne moltiplica la coppia, un potenziometro che misura l'angolo dell'albero d'uscita e una scheda di controllo che gestisce il tutto. Ogni 20 ms (50 Hz) la scheda misura la durata dell'impulso che arriva sul filo del segnale, la confronta con l'angolo indicato dal potenziometro e fa girare il motore finché la differenza non si annulla. Un impulso di circa 1500 µs corrisponde alla posizione centrale; con impulsi più brevi l'albero gira da un lato, con impulsi più lunghi dall'altro. La banda morta di 5 µs indicata nel datasheet è la metà dei 10 µs dell'SG90: l'MG90S reagisce quindi a variazioni d'impulso più piccole e mantiene la posizione con maggiore precisione. Abbiamo spiegato da zero il funzionamento dei servo in Che cos'è un servomotore?.
| Caratteristica | Valore |
|---|---|
| Tensione di lavoro | 4,8–6 V |
| Coppia di stallo | 1,8 kg·cm (4,8 V), 2,2 kg·cm (6 V) ≈ 0,18–0,22 N·m |
| Velocità (per 60°) | 0,10 s (4,8 V), 0,08 s (6 V) |
| Corrente a riposo | Circa 5–10 mA (albero fermo, senza carico) |
| Corrente in movimento | Circa 120–250 mA (senza carico) |
| Corrente di stallo | Circa 0,7–1 A |
| Banda morta | 5 µs |
| Escursione | Circa 180° con 500–2400 µs (varia da esemplare a esemplare) |
| Segnale | 50 Hz (periodo di 20 ms), posizione data dalla durata dell'impulso |
| Ingranaggi | In metallo, cuscinetto sull'albero d'uscita |
| Peso e dimensioni | 13,4 g, 22,8 × 12,2 × 28,5 mm |
| Cavo | Circa 25 cm; marrone GND, rosso positivo, arancione segnale |
| Temperatura di esercizio | 0–55 °C |
Differenze tra MG90S e SG90: ingranaggi, coppia e corrente
Dall'esterno i due servo sono quasi identici: fori di fissaggio, larghezza del corpo e squadrette sono compatibili, quindi puoi montare un MG90S direttamente in un supporto progettato per l'SG90. La vera differenza è all'interno. Gli ingranaggi in plastica dell'SG90 saltano un dente e si rompono quando il braccio urta qualcosa o l'albero viene forzato a mano; quelli in metallo dell'MG90S di solito superano lo stesso colpo senza danni. A 6 V la coppia sale da 1,8 a 2,2 kg·cm e la velocità scende a 0,08 secondi per 60 gradi. In cambio l'MG90S pesa circa 4,4 grammi in più, in stallo assorbe un po' più di corrente e di solito costa due o tre volte un SG90. Gli ingranaggi in metallo possono avere anche un piccolo gioco: su un braccio di precisione si nota come uno o due gradi di oscillazione quando il carico cambia direzione.
| Caratteristica | SG90 | MG90S | MG996R |
|---|---|---|---|
| Ingranaggi | Plastica | Metallo | Metallo, doppio cuscinetto |
| Coppia di stallo | 1,8 kg·cm (4,8 V) | 1,8 kg·cm (4,8 V), 2,2 kg·cm (6 V) | 9,4 kg·cm (4,8 V), 11 kg·cm (6 V) |
| Velocità (per 60°) | 0,10 s (4,8 V) | 0,10 s (4,8 V), 0,08 s (6 V) | 0,17 s (4,8 V), 0,14 s (6 V) |
| Banda morta | 10 µs | 5 µs | 5 µs |
| Peso | 9 g | 13,4 g | 55 g |
| Dimensioni | 22,2 × 11,8 × 31 mm | 22,8 × 12,2 × 28,5 mm | 40,7 × 19,7 × 42,9 mm |
| Tensione di lavoro | 4,8–6 V | 4,8–6 V | 4,8–7,2 V |
| Corrente di stallo | Circa 0,6–0,75 A | Circa 0,7–1 A | 2,5 A (6 V) |
| Resistenza agli urti | Bassa, gli ingranaggi si spanano facilmente | Buona | Ottima |
| Dal pin 5V di Arduino | Un servo, carico leggero | Un servo, carico leggero | No, sempre alimentazione esterna |
| Uso tipico | Primi esperimenti, coperchi leggeri | Polso, pinza, pan-tilt, piccoli robot | Spalla del braccio robotico, coperchi pesanti, sterzo |



Per scegliere, calcola prima la coppia che ti serve: la coppia è il peso del carico moltiplicato per la sua distanza dall'albero. Un carico di 100 g a 5 cm dall'albero richiede 0,1 × 5 = 0,5 kg·cm. A 5 V l'MG90S fornisce circa 2 kg·cm, ma questo è il limite di stallo, quello in cui l'albero si ferma; nell'uso continuo restare al massimo alla metà, cioè circa 1 kg·cm, mantiene il servo fresco e allunga la vita degli ingranaggi. Con questo calcolo l'MG90S porta tranquillamente fino a 200 g all'estremità di un braccio di 5 cm e fino a 100 g all'estremità di un braccio di 10 cm. Se ti serve più di 1 kg·cm passa al servo MG996R; se stai solo sperimentando o muovi un pezzo di pochi grammi, l'SG90 basta.
Colori dei fili dell'MG90S e collegamento
I tre fili dell'MG90S seguono lo schema di colori TowerPro. Alcuni produttori usano colori diversi, ma l'ordine è quasi sempre lo stesso, con il positivo al centro. Se inserisci il connettore al contrario, di solito il servo non si danneggia, semplicemente non funziona; correggi comunque subito il collegamento, perché in quel caso la corrente di massa del servo cerca di passare dal pin di segnale di Arduino.
| Filo (TowerPro) | Funzione | Altre marche | Dove si collega |
|---|---|---|---|
| Marrone | GND (negativo) | Nero | Negativo dell'alimentatore e GND di Arduino |
| Rosso | Positivo (4,8–6 V) | Rosso | 5 V o positivo esterno 5–6 V |
| Arancione | Segnale (PWM) | Giallo o bianco | Un pin digitale della scheda |
| Collegamento | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Arancione (segnale) | D9 | GPIO 18 | GP15 |
| Rosso (positivo): un servo, carico leggero | Pin 5V | Pin 5V (VIN), da USB | Pin VBUS (5 V da USB) |
| Rosso (positivo): con carico o più servo | Esterno 5–6 V | Esterno 5–6 V | Esterno 5–6 V |
| Marrone (GND) | GND e negativo dell'alimentatore | GND e negativo dell'alimentatore | GND e negativo dell'alimentatore |
| Potenziometro (esempio Uno) | Centrale su A0, laterali su 5V e GND | — | — |
| Secondo servo (esempio Pico) | — | — | GP14 |
Alimentazione separata: quanti servo, quanta corrente?
Un MG90S assorbe 120–250 mA quando si muove senza carico, ma nei primi millisecondi di ogni partenza e quando l'albero viene forzato la corrente sale a 0,7–1 A. Con più servo questi picchi si sommano. Considera anche i cavi: i contatti della breadboard e i sottili cavetti jumper arrivano facilmente a 0,2 Ω in totale. Facendo il conto con la legge di Ohm, con il picco di 3,2 A di quattro servo che partono insieme si perdono solo nei cavi 3,2 × 0,2 = 0,64 V: i 5 V dell'alimentatore arrivano ai servo come 4,4 V, e i servo perdono forza e tremano. Distribuire l'alimentazione dei servo con una morsettiera o una linea saldata invece che sulla breadboard riduce molto questa perdita.
| Numero di servo | In movimento | Caso peggiore (tutti in stallo) | Alimentazione consigliata |
|---|---|---|---|
| 1 | 0,12–0,25 A | Circa 1 A | 5V di Arduino per prove a vuoto, 5 V 1 A sotto carico |
| 2 (pan-tilt) | 0,25–0,5 A | 2 A | 5 V, 2 A |
| 4 (piccolo braccio robotico) | 0,5–1 A | 4 A | 5 V, 3–4 A |
| 6 | 0,75–1,5 A | 6 A | 5–6 V, 5 A e codice che muove i servo uno alla volta |
| 16 (PCA9685) | 2–4 A | 16 A | Alimentatore switching 5–6 V da 10 A o più |
- Scegli l'alimentazione: usa un alimentatore switching da 5 V o 4 pile stilo AA NiMH (4,8 V). Le pile alcaline nuove arrivano a 1,6 V l'una, quindi un portapile da 4 può dare 6,4 V, un po' sopra il limite dell'MG90S.
- Porta il positivo al servo: collega il positivo dell'alimentatore al filo rosso del servo, non al pin 5V di Arduino.
- Unisci le masse: collega il negativo dell'alimentatore sia al filo marrone del servo sia al pin GND di Arduino; senza massa comune il servo non legge correttamente gli impulsi.
- Aggiungi un condensatore: metti un condensatore elettrolitico da 470 µF / 16 V sulla linea di alimentazione dei servo, vicino ai servo; con più servo aggiungi circa 100 µF per servo. Il terminale con la striscia va al negativo.
- Collega il segnale: collega il filo arancione al pin D9 di Arduino Uno e alimenta Arduino separatamente dall'USB o dal jack DC.
Intervallo di impulsi 500–2400 µs e libreria Servo
Con la libreria Servo inclusa nell'IDE di Arduino, scrivendo servo.attach(9) l'intervallo predefinito è 544–2400 µs e write(0) e write(180) vengono associati a questi due estremi. La maggior parte degli MG90S richiede per 0 gradi un impulso più breve di 544 µs, quindi con l'impostazione predefinita il servo resta qualche grado indietro a un estremo. Indicare l'intervallo con servo.attach(9, 500, 2400) risolve il problema. È un dettaglio importante, perché nemmeno writeMicroseconds() può uscire dai limiti passati ad attach: senza limiti, i 500 µs che scrivi vengono portati in silenzio a 544. Nell'intervallo 500–2400 un grado vale circa 1900 / 180 ≈ 10,6 µs. Dato che la banda morta dell'MG90S è di 5 µs, con writeMicroseconds() puoi fare perfino passi di mezzo grado.
| Angolo | attach(9) predefinito (544–2400) | attach(9, 500, 2400) | Nota |
|---|---|---|---|
| 0° | 544 µs | 500 µs | All'estremo cambia di qualche grado |
| 45° | 1008 µs | 975 µs | — |
| 90° | 1472 µs | 1450 µs | Il centro reale di solito è tra 1450 e 1550 µs |
| 135° | 1936 µs | 1925 µs | — |
| 180° | 2400 µs | 2400 µs | Restringi se arriva al fine corsa meccanico |
I valori della tabella sono calcolati: su un servo reale l'impulso per i 90 gradi può essere 1500 o 1520 µs invece di 1450. Alcuni datasheet indicano che 1000–2000 µs danno l'escursione completa, ma in pratica con questo intervallo l'MG90S ruota solo di 90–100 gradi. Se spingi l'impulso oltre il limite meccanico, il servo va a battere sul fermo interno, ronza, assorbe la corrente di stallo e si scalda; siccome gli ingranaggi in metallo sopportano questo sforzo in silenzio, te ne accorgi più tardi che con un SG90. Per questo la prima cosa da fare è misurare i limiti del tuo servo.
Calibrazione dell'angolo: trova i limiti del tuo MG90S
Il codice qui sotto muove il servo a passi di 10 µs con i caratteri che scrivi nel Monitor seriale. + allunga l'impulso, - lo accorcia e c torna al centro (1500 µs); con n salvi il valore attuale come limite inferiore e con x come limite superiore. Dopo ogni salvataggio il codice stampa la riga attach pronta da usare negli sketch successivi. Per fare più passi alla volta scrivi +++++ e premi Invio: il servo avanza di cinque passi, cioè 50 µs.
1#include <Servo.h>
2
3const byte SERVO_PIN = 9; // turuncu sinyal kablosu / orange signal wire
4const int STEP_US = 10; // her + ya da - için 10 µs / 10 µs per + or -
5
6Servo servo;
7int pulseUs = 1500; // ortadan başla / start at the center
8int minUs = 1000; // bulunacak alt sınır / lower limit to find
9int maxUs = 2000; // bulunacak üst sınır / upper limit to find
10
11void printPulse() {
12 Serial.print(F("Darbe / pulse: "));
13 Serial.print(pulseUs);
14 Serial.println(F(" us"));
15}
16
17void setup() {
18 Serial.begin(115200);
19 servo.writeMicroseconds(pulseUs); // önce darbe, sonra attach / pulse first, then attach
20 servo.attach(SERVO_PIN, 500, 2500); // geniş aralık: sınırı sen bulacaksın / wide range: you find the limits
21 Serial.println(F("+ / - : 10 us | c: 1500 us | n: min | x: max"));
22 printPulse();
23}
24
25void loop() {
26 if (!Serial.available()) return;
27 char key = Serial.read();
28 if (key == '+') pulseUs += STEP_US;
29 else if (key == '-') pulseUs -= STEP_US;
30 else if (key == 'c') pulseUs = 1500;
31 else if (key == 'n') minUs = pulseUs; // alt sınırı kaydet / save the lower limit
32 else if (key == 'x') maxUs = pulseUs; // üst sınırı kaydet / save the upper limit
33 else return; // Enter ve diğer tuşları yok say / ignore Enter and other keys
34
35 pulseUs = constrain(pulseUs, 500, 2500);
36 servo.writeMicroseconds(pulseUs);
37 printPulse();
38
39 if (key == 'n' || key == 'x') { // hazır attach satırı / ready-made attach line
40 Serial.print(F("servo.attach(9, "));
41 Serial.print(minUs);
42 Serial.print(F(", "));
43 Serial.print(maxUs);
44 Serial.println(F(");"));
45 }
46}- Collega il servo senza carico, carica il codice e apri il Monitor seriale a 115200 baud.
- Scrivi c e premi Invio: il servo va a 1500 µs. Monta la squadretta sul dente più vicino al centro del tuo meccanismo.
- Vai verso l'estremo inferiore con -. Quando il servo non gira più, ronza o trema, torna indietro di 3–4 passi (30–40 µs) e scrivi n.
- Ripeti per l'estremo superiore con + e scrivi x. Annota la riga servo.attach(9, MIN, MAX) che compare nel Monitor seriale.
- Trova i 90 gradi con un goniometro disegnato su carta o stampato: salva come US_90 l'impulso con cui la squadretta sta perfettamente verticale.
A causa della dentatura dell'albero, la squadretta si può montare solo a scatti fissi, quindi raramente resta esattamente al centro e i pochi gradi di differenza si correggono via software. Inoltre il rapporto tra impulso e angolo di un servo non è perfettamente lineare: una mappatura a due punti che centra 0 e 180 gradi può sbagliare di 3–5 gradi a metà corsa. La calibrazione a tre punti elimina questo errore: usi i tre impulsi misurati per 0, 90 e 180 gradi e chiami la funzione map() separatamente per le due metà. Il codice qui sotto usa questo metodo per trasferire al servo l'angolo letto da un potenziometro collegato ad A0.
1#include <Servo.h>
2
3const byte SERVO_PIN = 9; // turuncu kablo / orange wire
4const byte POT_PIN = A0; // potansiyometre orta bacağı / potentiometer wiper
5
6// Kalibrasyonda ölçtüğün üç nokta / the three points you measured
7const int US_0 = 520; // 0 derece / 0 degrees
8const int US_90 = 1480; // korna tam dik / horn exactly upright
9const int US_180 = 2380; // 180 derece / 180 degrees
10
11Servo servo;
12float smoothAngle = 90; // süzülmüş açı / filtered angle
13int lastAngle = -1;
14
15int angleToUs(int angle) {
16 angle = constrain(angle, 0, 180);
17 if (angle <= 90) return map(angle, 0, 90, US_0, US_90); // alt yarı / lower half
18 return map(angle, 90, 180, US_90, US_180); // üst yarı / upper half
19}
20
21void setup() {
22 servo.writeMicroseconds(angleToUs(90)); // açılışta ortada başla / start centered
23 servo.attach(SERVO_PIN, US_0, US_180);
24}
25
26void loop() {
27 int target = map(analogRead(POT_PIN), 0, 1023, 0, 180);
28 smoothAngle += (target - smoothAngle) * 0.15; // gürültüyü süz / filter the noise
29 int angle = (int)(smoothAngle + 0.5);
30 if (abs(angle - lastAngle) >= 2) { // 2 derecelik ölü bant / 2-degree deadband
31 servo.writeMicroseconds(angleToUs(angle));
32 lastAngle = angle;
33 }
34 delay(15);
35}Sostituisci US_0, US_90 e US_180 con le tue misure. angleToUs() mappa 0–90 tra i primi due punti e 90–180 tra gli ultimi due, così la posizione in cui la squadretta è verticale corrisponde davvero a 90 gradi. Usare writeMicroseconds() evita anche l'arrotondamento al grado intero di write(). Le poche unità di rumore nella lettura del potenziometro vengono attenuate da un semplice filtro con coefficiente 0,15 e da una banda morta di 2 gradi; senza banda morta il servo continua a vibrare sul posto. Abbiamo trattato in dettaglio le altre cause in servo che trema. Su Arduino Uno la libreria Servo usa il Timer1, quindi con un servo collegato analogWrite() non funziona sui pin D9 e D10.
MG90S con ESP32: controllo dal telefono con uno slider
Sull'ESP32 la libreria Servo standard di Arduino non funziona: installa la libreria ESP32Servo dal Gestore librerie. Funziona sia con le versioni 2.x sia con le 3.x del core ESP32, riceve il periodo con setPeriodHertz(50) e non accetta limiti fuori da 500–2500 µs. L'uscita del segnale dell'ESP32 è a 3,3 V e praticamente tutti gli MG90S la leggono senza problemi. Il codice qui sotto collega l'ESP32 alla rete Wi-Fi; apri l'indirizzo IP mostrato nel Monitor seriale su un telefono connesso alla stessa rete e vedrai uno slider: appena lo rilasci, il servo ruota a quell'angolo.
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4
5const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7const int SERVO_PIN = 18; // turuncu kablo / orange wire
8const int MIN_US = 500; // kalibrasyon değerlerin / your calibration values
9const int MAX_US = 2400;
10
11WebServer server(80);
12Servo servo;
13int currentAngle = 90;
14
15const char PAGE[] = R"rawliteral(<!DOCTYPE html><html><head>
16<meta name="viewport" content="width=device-width,initial-scale=1"><title>MG90S</title></head>
17<body style="font-family:sans-serif;text-align:center">
18<h2>MG90S: <span id="v">90</span>°</h2>
19<input id="s" type="range" min="0" max="180" value="90" style="width:90%">
20<script>
21const s = document.getElementById('s'), v = document.getElementById('v');
22s.oninput = () => v.textContent = s.value;
23s.onchange = () => fetch('/set?a=' + s.value);
24</script></body></html>)rawliteral";
25
26void handleRoot() {
27 server.send(200, "text/html", PAGE);
28}
29
30void handleSet() {
31 if (server.hasArg("a")) {
32 currentAngle = constrain(server.arg("a").toInt(), 0, 180); // 0–180 ile sınırla / clamp to 0–180
33 servo.write(currentAngle);
34 }
35 server.send(200, "text/plain", String(currentAngle));
36}
37
38void setup() {
39 Serial.begin(115200);
40 servo.setPeriodHertz(50); // 50 Hz servo sinyali / 50 Hz servo signal
41 servo.attach(SERVO_PIN, MIN_US, MAX_US);
42 servo.write(currentAngle);
43
44 WiFi.begin(ssid, password);
45 while (WiFi.status() != WL_CONNECTED) delay(300);
46 Serial.print(F("IP: "));
47 Serial.println(WiFi.localIP()); // bu adresi telefonda aç / open this address on your phone
48
49 server.on("/", handleRoot);
50 server.on("/set", handleSet);
51 server.begin();
52}
53
54void loop() {
55 server.handleClient();
56}Quando attiva il Wi-Fi, l'ESP32 assorbe per un attimo fino a 250 mA; se anche la corrente di spunto del servo passa dalla stessa linea USB, la scheda scrive "Brownout detector was triggered" e si riavvia. Alimenta il servo con un 5 V separato e unisci le masse; trovi i dettagli in errore brownout dell'ESP32. Per il segnale vanno bene GPIO 13, 18, 19, 23, 25, 26 e 27; non usare i GPIO 6–11, collegati alla flash, né i 34–39, che sono solo ingressi.
MG90S con Raspberry Pi Pico (MicroPython)
Sul Raspberry Pi Pico non serve nessuna libreria aggiuntiva: imposti il PWM a 50 Hz e indichi la durata dell'impulso in nanosecondi con duty_ns(). La piccola classe MicroServo qui sotto memorizza i valori di calibrazione di ogni servo e avanza di un grado alla volta per un movimento fluido. Nell'esempio il polso di un braccio robotico è su GP15 e la pinza su GP14. Sul Pico questi due pin condividono la stessa slice PWM (slice 7) e quindi la stessa frequenza; non è un problema perché entrambi usano 50 Hz, ma se imposti a 1 kHz un altro pin della stessa slice per la luminosità di un LED, anche il servo impazzisce. Con due servo usa un 5 V esterno invece di VBUS e unisci le masse.
1from machine import Pin, PWM
2import time
3
4class MicroServo:
5 def __init__(self, pin, min_us=500, max_us=2400):
6 self.pwm = PWM(Pin(pin))
7 self.pwm.freq(50) # 50 Hz = 20 ms periyot / 20 ms period
8 self.min_us = min_us # bu servonun kalibrasyonu / this servo's calibration
9 self.max_us = max_us
10 self.angle = None
11
12 def write(self, angle):
13 angle = max(0, min(180, angle)) # 0–180 ile sınırla / clamp to 0–180
14 us = self.min_us + (self.max_us - self.min_us) * angle / 180
15 self.pwm.duty_ns(int(us * 1000)) # µs -> ns
16 self.angle = angle
17
18 def move_to(self, target, ms_per_degree=10):
19 if self.angle is None: # ilk komut: doğrudan git / first command: go directly
20 self.write(target)
21 return
22 step = 1 if target > self.angle else -1
23 for a in range(int(self.angle), int(target) + step, step):
24 self.write(a) # derece derece ilerle / move degree by degree
25 time.sleep_ms(ms_per_degree)
26
27 def off(self):
28 self.pwm.duty_ns(0) # sinyali kes, servo serbest / stop the signal, servo goes limp
29
30wrist = MicroServo(15, 520, 2380) # bilek GP15 / wrist on GP15
31gripper = MicroServo(14, 600, 2300) # kıskaç GP14, aynı PWM dilimi / gripper on GP14, same PWM slice
32
33wrist.write(90)
34gripper.write(20)
35time.sleep(1)
36
37while True:
38 gripper.move_to(70) # kıskacı kapat / close the gripper
39 wrist.move_to(150)
40 time.sleep(0.5)
41 wrist.move_to(30)
42 gripper.move_to(20) # kıskacı aç / open the gripper
43 time.sleep(1)MG90S in un braccio robotico: per quale articolazione va bene?
I piccoli bracci robotici a 4 assi in acrilico o stampati in 3D di solito montano quattro micro servo, e qui l'MG90S dura molto più dell'SG90: quando il braccio urta qualcosa o la pinza viene forzata a mano, la prima cosa a rompersi sono gli ingranaggi in plastica. Su un braccio più grande l'MG90S si usa solo nelle articolazioni finali. Il calcolo è semplice: moltiplica il peso di ogni parte che viene dopo l'articolazione per la sua distanza dall'albero e somma tutto. Una pinza da 40 g a 6 cm e un oggetto da 50 g a 8 cm caricano il servo del polso con 0,04 × 6 + 0,05 × 8 = 0,64 kg·cm, sotto il limite sicuro dell'MG90S di circa 1 kg·cm a 5 V.
| Articolazione | Carico tipico | L'MG90S va bene? |
|---|---|---|
| Base (rotazione) | Basso se il peso del braccio poggia su un cuscinetto | Sì sui bracci piccoli, MG996R su quelli grandi |
| Spalla | Il più alto, 2–5 kg·cm | Solo su bracci molto leggeri; di solito MG996R |
| Gomito | Medio, 1–3 kg·cm | Sì sui bracci corti |
| Polso | Basso, 0,3–1 kg·cm | Sì, ideale |
| Pinza | Basso, ma rischio di stringere di continuo | Sì; limita l'angolo di chiusura in base all'oggetto |
L'errore più comune con la pinza è mandare il servo oltre l'angolo in cui afferra l'oggetto. Non potendo raggiungere la posizione, il servo assorbe di continuo la corrente di stallo, si scalda e in pochi minuti il motore o la scheda di controllo possono danneggiarsi. Imposta l'angolo di chiusura nel punto in cui le ganasce toccano appena l'oggetto, oppure arretra di qualche grado dopo la presa. Trovi il calcolo completo della coppia e la costruzione di un braccio a 6 assi nella guida al braccio robotico con Arduino; se vuoi pilotare più di sei servo con una sola scheda, il driver per servo PCA9685 ti semplifica la vita.
Idee di progetto con l'MG90S
- Supporto pan-tilt per telecamera: fai ruotare un modulo ESP32-CAM in orizzontale e in verticale con due MG90S; gli ingranaggi in metallo reggono le vibrazioni.
- Radar con Arduino: fai scansionare a un MG90S un sensore HC-SR04 da 0 a 180 gradi e disegna lo schermo radar; la costruzione è in progetto radar con Arduino.
- Pattumiera intelligente: una pattumiera intelligente che apre un coperchio leggero quando avvicini la mano.
- Distributore automatico di cibo: un distributore di crocchette che apre e chiude uno sportellino a orari fissi.
- Robot che evita gli ostacoli: un servo che fa da collo e gira il sensore di distanza a destra e a sinistra; vedi la guida al robot che evita gli ostacoli.
- Mini inseguitore solare: trova la direzione della luce con due LDR e orienta un piccolo pannello con un MG90S; i dettagli sono in inseguitore solare.
- Lavori che richiedono rotazione continua: per una ruota o un nastro trasportatore usa un servo a 360 gradi al posto dell'MG90S.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Il servo resta qualche grado indietro a un estremo | L'intervallo predefinito 544–2400 µs | Scrivi attach(9, 500, 2400) e calibra |
| All'estremo ronza e si scalda | L'impulso supera il limite meccanico | Restringi ai valori MIN e MAX trovati con la calibrazione |
| Arduino si resetta quando il servo si muove | Il servo è alimentato dall'USB tramite il pin 5V | Alimentatore esterno da 5 V, GND comune e condensatore da 470 µF |
| Trema da fermo | Alimentazione debole, cavi lunghi e sottili o rumore del potenziometro | Cavi spessi, condensatore, filtro e banda morta |
| Non risponde o si muove a caso | Il GND dell'alimentatore esterno non è collegato ad Arduino | Collega il negativo dell'alimentatore al GND di Arduino |
| Sotto carico fa clic e l'albero slitta | Un dente dell'ingranaggio è rotto o la vite della squadretta è allentata | Sostituisci il set di ingranaggi e stringi la vite centrale |
| Coppia molto più bassa del previsto, il servo pesa 9 g | Copia con ingranaggi in plastica | Pesa il servo: un MG90S originale pesa circa 13–14 g |
| All'accensione il servo scatta di colpo | attach() invia 1500 µs come primo impulso | Prima di attach() dai l'impulso iniziale con writeMicroseconds() |
L'MG90S è la scelta giusta per ogni progetto che vuole un servo più robusto e un po' più forte senza uscire dalle dimensioni dell'SG90. Ricorda le regole: alimentazione esterna a 5 V per tutto ciò che non è un carico leggero, GND comune, un condensatore vicino al servo, un intervallo di impulsi che parte da 500–2400 µs e si restringe con la calibrazione e un angolo di chiusura limitato sulla pinza. Nell'app BlueGrays trovi il controllo dei servo con potenziometro e joystick, una serratura RFID con servo per ESP32 e una coreografia con 32 servo, ognuno con schema del circuito passo passo e codice pronto.
Domande frequenti
Che differenza c'è tra servo MG90S e SG90?
Hanno le stesse dimensioni e gli stessi fili, ma l'MG90S ha ingranaggi in metallo e a 6 V arriva a 2,2 kg·cm di coppia, mentre l'SG90, con ingranaggi in plastica, si ferma intorno a 1,8 kg·cm e si spana facilmente negli urti. L'MG90S pesa circa 13,4 g contro i 9 g dell'SG90 e in stallo assorbe un po' più di corrente. Nel codice non cambia nulla: entrambi funzionano con la stessa libreria Servo.
Quanto peso può sollevare un servo MG90S?
La coppia di stallo dell'MG90S è di 1,8 kg·cm a 4,8 V e 2,2 kg·cm a 6 V: a 1 cm dall'albero riesce appena a trattenere circa 2 kg. Per l'uso continuo calcola metà della coppia: circa 200 g all'estremità di un braccio di 5 cm e circa 100 g all'estremità di un braccio di 10 cm.
Posso alimentare il servo MG90S dal pin 5V di Arduino?
Per prove senza carico un solo MG90S funziona dal pin 5V di Arduino. Ma quando il servo viene forzato, una corrente vicina a 1 A supera il limite di 500 mA dell'USB e Arduino si resetta. Nei progetti con carico o con più servo usa un alimentatore esterno da 5 V e unisci le masse.
Di quanti gradi ruota l'MG90S? Esiste la versione a 360 gradi?
L'MG90S standard ruota di circa 180 gradi; per l'escursione completa servono di solito impulsi tra 500 e 2400 µs e i limiti cambiano da esemplare a esemplare. Esistono anche versioni a rotazione continua da 360 gradi, ma con quelle controlli velocità e direzione, non l'angolo.
Perché il servo MG90S trema o ronza?
La causa più frequente è un'alimentazione debole: un servo alimentato dall'USB fa calare la tensione a ogni partenza. Se ronza agli estremi, l'intervallo degli impulsi supera il limite meccanico: restringilo con la calibrazione. Se trema quando lo comandi con un potenziometro, filtra la lettura e aggiungi una banda morta di 1–2 gradi.
L'MG90S funziona con ESP32 e segnale a 3,3 V?
Sì. La scheda di controllo dell'MG90S legge senza problemi un segnale a 3,3 V; sull'ESP32 basta la libreria ESP32Servo, sul Pico la classe PWM di MicroPython. L'alimentazione del servo deve restare a 5 V: non alimentarlo dal pin 3,3 V.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Utilizzo del servomotore
Il braccio di un piccolo servomotore ruota a turno in tre posizioni: tutto all'inizio, esattamente a metà e tutto alla fine, aspettando due secondi a ogni fermata.

Funzionamento del servomotore con potenziometro
Mentre giri la manopola del potenziometro, il braccio del servomotore ruota insieme a lei: un'estremità della manopola corrisponde a zero gradi, l'altra a mezzo giro.

Servocomando con joystick
Comanda due motori con un joystick, proprio come se girassi una telecamera di sicurezza.

Servomotore ESP32 (controllo tramite potenziometro)
In questo progetto controlliamo un servomotore SG90 tramite un potenziometro. Regoliamo l'angolo del servomotore mappando il valore analogico letto dal potenziometro su un intervallo compreso tra 0 e 180 gradi. La libreria ESP32Servo genera segnali per servomotori sui GPIO adatti dell'ESP32 che possono funzionare come uscite; in questo progetto si utilizza GPIO 18. Si tratta di un metodo di controllo fondamentale per bracci robotici, gimbal per telecamere e meccanismi di porte automatiche.

Serratura RFID ESP32 (RC522 + servomotore + OLED + cicalino + LED)
Costruiamo una serratura smart con ESP32, modulo RFID RC522, servo SG90, display OLED SSD1306, buzzer attivo e 2 LED. Quando passi una tessera, il suo UID viene confrontato con quelle autorizzate definite nel codice; se corrisponde, il servo apre (LED verde + 2 bip brevi) e richiude dopo 5 secondi. Con una tessera sconosciuta si accende il LED rosso, suonano 3 bip rapidi e l'OLED mostra l'UID.

Coreografia di servo in cerchio - Animazioni con 32 servomotori
Un progetto di animazione visiva con 32 servomotori disposti in cerchio su un Arduino Mega. I servo sono gestiti in un unico array, collegati ai pin 22–53 del Mega, e mostrano quattro sequenze di movimento: una vibrazione caotica ad angoli casuali, una spazzata sincronizzata, un'onda che gira lungo il cerchio e un ago di bussola che oscilla a destra e a sinistra.

Robot che evita gli ostacoli
Che ne dite di costruire un veicolo intelligente che trova la propria strada? L'Obstacle Avoiding Robot scruta costantemente l'ambiente circostante grazie al sensore a ultrasuoni posto davanti a lui.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

