Componenti · 14 min di lettura

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.

Micro servo MG90S con ingranaggi in metallo
MG90S: stesse dimensioni dell'SG90, ingranaggi in metallo e tre fili marrone, rosso e arancione.

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?.

CaratteristicaValore
Tensione di lavoro4,8–6 V
Coppia di stallo1,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 riposoCirca 5–10 mA (albero fermo, senza carico)
Corrente in movimentoCirca 120–250 mA (senza carico)
Corrente di stalloCirca 0,7–1 A
Banda morta5 µs
EscursioneCirca 180° con 500–2400 µs (varia da esemplare a esemplare)
Segnale50 Hz (periodo di 20 ms), posizione data dalla durata dell'impulso
IngranaggiIn metallo, cuscinetto sull'albero d'uscita
Peso e dimensioni13,4 g, 22,8 × 12,2 × 28,5 mm
CavoCirca 25 cm; marrone GND, rosso positivo, arancione segnale
Temperatura di esercizio0–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.

CaratteristicaSG90MG90SMG996R
IngranaggiPlasticaMetalloMetallo, doppio cuscinetto
Coppia di stallo1,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 morta10 µs5 µs5 µs
Peso9 g13,4 g55 g
Dimensioni22,2 × 11,8 × 31 mm22,8 × 12,2 × 28,5 mm40,7 × 19,7 × 42,9 mm
Tensione di lavoro4,8–6 V4,8–6 V4,8–7,2 V
Corrente di stalloCirca 0,6–0,75 ACirca 0,7–1 A2,5 A (6 V)
Resistenza agli urtiBassa, gli ingranaggi si spanano facilmenteBuonaOttima
Dal pin 5V di ArduinoUn servo, carico leggeroUn servo, carico leggeroNo, sempre alimentazione esterna
Uso tipicoPrimi esperimenti, coperchi leggeriPolso, pinza, pan-tilt, piccoli robotSpalla del braccio robotico, coperchi pesanti, sterzo
SG90
SG90
MG90S
MG90S
MG996R
MG996R

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)FunzioneAltre marcheDove si collega
MarroneGND (negativo)NeroNegativo dell'alimentatore e GND di Arduino
RossoPositivo (4,8–6 V)Rosso5 V o positivo esterno 5–6 V
ArancioneSegnale (PWM)Giallo o biancoUn pin digitale della scheda
CollegamentoArduino UnoESP32Raspberry Pi Pico
Arancione (segnale)D9GPIO 18GP15
Rosso (positivo): un servo, carico leggeroPin 5VPin 5V (VIN), da USBPin VBUS (5 V da USB)
Rosso (positivo): con carico o più servoEsterno 5–6 VEsterno 5–6 VEsterno 5–6 V
Marrone (GND)GND e negativo dell'alimentatoreGND e negativo dell'alimentatoreGND e negativo dell'alimentatore
Potenziometro (esempio Uno)Centrale su A0, laterali su 5V e GND——
Secondo servo (esempio Pico)——GP14
Non collegare mai il filo rosso a un pin da 3,3 V: il servo lavora debole e mette sotto sforzo il piccolo regolatore della scheda. Alimenta un solo MG90S dal pin 5V di Arduino solo per prove senza carico; quando il servo va in stallo, una corrente vicina a 1 A supera il limite di 500 mA dell'USB e la scheda si resetta. Una batteria LiPo 2S da 7,4 V supera il limite di 6 V dell'MG90S: collegata direttamente può bruciare la scheda di controllo. Con un alimentatore esterno non dimenticare di unire le masse; spieghiamo il perché in Che cos'è il GND?.

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 servoIn movimentoCaso peggiore (tutti in stallo)Alimentazione consigliata
10,12–0,25 ACirca 1 A5V di Arduino per prove a vuoto, 5 V 1 A sotto carico
2 (pan-tilt)0,25–0,5 A2 A5 V, 2 A
4 (piccolo braccio robotico)0,5–1 A4 A5 V, 3–4 A
60,75–1,5 A6 A5–6 V, 5 A e codice che muove i servo uno alla volta
16 (PCA9685)2–4 A16 AAlimentatore switching 5–6 V da 10 A o più
  1. 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.
  2. Porta il positivo al servo: collega il positivo dell'alimentatore al filo rosso del servo, non al pin 5V di Arduino.
  3. 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.
  4. 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.
  5. Collega il segnale: collega il filo arancione al pin D9 di Arduino Uno e alimenta Arduino separatamente dall'USB o dal jack DC.
Se hai un alimentatore da 12 V, con un modulo LM2596 puoi regolare l'uscita a 5–6 V e alimentare tranquillamente fino a tre MG90S. In un progetto a batteria stima l'autonomia con il calcolatore di durata della batteria: la corrente media dei servo può cambiare di dieci volte a seconda che si muovano di continuo o solo ogni tanto.

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.

Angoloattach(9) predefinito (544–2400)attach(9, 500, 2400)Nota
0°544 µs500 µsAll'estremo cambia di qualche grado
45°1008 µs975 µs—
90°1472 µs1450 µsIl centro reale di solito è tra 1450 e 1550 µs
135°1936 µs1925 µs—
180°2400 µs2400 µsRestringi 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.

C++ (Arduino IDE)
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}
  1. Collega il servo senza carico, carica il codice e apri il Monitor seriale a 115200 baud.
  2. Scrivi c e premi Invio: il servo va a 1500 µs. Monta la squadretta sul dente più vicino al centro del tuo meccanismo.
  3. 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.
  4. Ripeti per l'estremo superiore con + e scrivi x. Annota la riga servo.attach(9, MIN, MAX) che compare nel Monitor seriale.
  5. 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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>&deg;</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.

MicroPython
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.

ArticolazioneCarico tipicoL'MG90S va bene?
Base (rotazione)Basso se il peso del braccio poggia su un cuscinettoSì sui bracci piccoli, MG996R su quelli grandi
SpallaIl più alto, 2–5 kg·cmSolo su bracci molto leggeri; di solito MG996R
GomitoMedio, 1–3 kg·cmSì sui bracci corti
PolsoBasso, 0,3–1 kg·cmSì, ideale
PinzaBasso, ma rischio di stringere di continuoSì; 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

SintomoCausa probabileSoluzione
Il servo resta qualche grado indietro a un estremoL'intervallo predefinito 544–2400 µsScrivi attach(9, 500, 2400) e calibra
All'estremo ronza e si scaldaL'impulso supera il limite meccanicoRestringi ai valori MIN e MAX trovati con la calibrazione
Arduino si resetta quando il servo si muoveIl servo è alimentato dall'USB tramite il pin 5VAlimentatore esterno da 5 V, GND comune e condensatore da 470 µF
Trema da fermoAlimentazione debole, cavi lunghi e sottili o rumore del potenziometroCavi spessi, condensatore, filtro e banda morta
Non risponde o si muove a casoIl GND dell'alimentatore esterno non è collegato ad ArduinoCollega il negativo dell'alimentatore al GND di Arduino
Sotto carico fa clic e l'albero slittaUn dente dell'ingranaggio è rotto o la vite della squadretta è allentataSostituisci il set di ingranaggi e stringi la vite centrale
Coppia molto più bassa del previsto, il servo pesa 9 gCopia con ingranaggi in plasticaPesa il servo: un MG90S originale pesa circa 13–14 g
All'accensione il servo scatta di colpoattach() invia 1500 µs come primo impulsoPrima di attach() dai l'impulso iniziale con writeMicroseconds()
Se il servo non deve tenere un carico, quando arriva in posizione interrompi il segnale con servo.detach(): il servo si zittisce e non assorbe quasi nulla. Senza segnale però sparisce anche la coppia di tenuta, quindi non usare detach sulle articolazioni del braccio che portano carico. Forzare l'albero a mano magari non rompe gli ingranaggi in metallo, ma affatica il motore e il potenziometro interni: gira la squadretta sempre con delicatezza e a servo spento.

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.

Vedi tutti i progetti
Utilizzo del servomotore
AR-35Principiante
Premium

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.

4.7(48)
67
Funzionamento del servomotore con potenziometro
AR-36Principiante
Premium

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.

4.6(37)
53
Servocomando con joystick
AR-60Intermedio
Premium

Servocomando con joystick

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

4.7(42)
58
Servomotore ESP32 (controllo tramite potenziometro)
ES-16Intermedio
Premium

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.

4.3(29)
42
Serratura RFID ESP32 (RC522 + servomotore + OLED + cicalino + LED)
ES-35Avanzato
Premium

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.

4.8(9)
16
Coreografia di servo in cerchio - Animazioni con 32 servomotori
AR-97Avanzato
Premium

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.

4.5(40)
62
Robot che evita gli ostacoli
AR-81Avanzato
Premium

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.

5.0(38)
49