Servo MG996R con Arduino: coppia, corrente, alimentazione, codice

Il servo MG996R è il servomotore di riferimento per i lavori pesanti nei progetti Arduino, grazie agli ingranaggi in metallo e a una coppia che arriva a 11 kg·cm a 6 V. Con i suoi 55 grammi solleva la spalla di un braccio robotico, apre un coperchio pesante o fa ruotare un supporto pan-tilt per videocamera. Questa forza però ha un prezzo: sotto sforzo il MG996R assorbe fino a 2,5 A. Per questo non puoi collegarlo semplicemente al pin 5V di Arduino come faresti con un SG90; ha bisogno di un'alimentazione esterna da 5–6 V, di una massa comune (GND) e di un condensatore vicino al servo. Se ignori queste regole, il servo trema, Arduino si resetta di continuo e il computer può persino disattivare la porta USB.

In questa guida imparerai a interpretare la coppia e la corrente del MG996R con numeri reali, a scegliere l'alimentatore giusto, a usare l'intervallo di 500–2500 µs con la libreria Servo per trovare i limiti del tuo servo e a evitare tremolii e reset. Poi passeremo al codice per ESP32 e Raspberry Pi Pico, al modulo PCA9685 che pilota 16 servo con due fili, alla scelta dei servo per un braccio robotico e al confronto con SG90 e MG90S.

Che cos'è il servo MG996R e come funziona?

Il MG996R è una versione migliorata del vecchio MG995 di TowerPro: la scheda di controllo e gli ingranaggi riprogettati si centrano in modo più affidabile e lasciano meno gioco. Dentro il corpo ci sono un piccolo motore DC, un riduttore a 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. La scheda legge ogni 20 ms (50 Hz) la larghezza dell'impulso che arriva sul filo del segnale, confronta l'angolo richiesto con quello indicato dal potenziometro e fa girare il motore finché la differenza non si annulla. Un impulso di circa 1500 µs corrisponde alla posizione centrale; impulsi più corti fanno ruotare l'albero da una parte, quelli più lunghi dall'altra. La banda morta di 5 µs indicata nel datasheet significa che il servo non reagisce a variazioni più piccole. Abbiamo spiegato il funzionamento generale dei servo in Cos'è un servomotore?.

Che cosa significa coppia? Leggere bene il valore in kg·cm

La coppia è la capacità del servo di far ruotare un carico a una certa distanza dal suo albero e si misura come forza × distanza. 11 kg·cm significa che può sostenere 11 kg a 1 cm dall'albero oppure 1,1 kg a 10 cm; se la distanza raddoppia, il carico che può muovere si dimezza. Per convertire in newton metro moltiplica per 0,098: 11 kg·cm ≈ 1,08 N·m. Il dettaglio fondamentale è questo: il valore del datasheet è la coppia di stallo, cioè il limite in cui l'albero si ferma, la corrente è massima e il servo si scalda. Nell'uso continuo, restare al massimo alla metà di quel valore mantiene il servo fresco, riduce i tremolii e allunga la vita degli ingranaggi.

La tabella considera solo il carico all'estremità. In un meccanismo reale si aggiungono alla coppia il peso del braccio stesso, gli altri servo montati sopra e la pinza; devi moltiplicare la massa di ogni pezzo per la sua distanza dall'albero e sommare tutto. Per esempio, se un braccio di 15 cm porta all'estremità una pinza da 150 g e un oggetto da 100 g, solo questi due valgono 0,25 × 15 = 3,75 kg·cm; con il peso del braccio il totale può arrivare a 5 kg·cm. È poco meno della metà della coppia di stallo del MG996R a 6 V, quindi è la scelta giusta. Trovi il calcolo della coppia pezzo per pezzo, con un esempio, nella guida al braccio robotico con Arduino.

Corrente: perché il MG996R non si alimenta dal pin 5V di Arduino?

A riposo e senza carico il MG996R assorbe solo circa 10 mA (se sostiene un carico il valore sale con il carico), ma in movimento la corrente sale a 0,5–0,9 A, e quando l'albero è sotto sforzo e nei primi millisecondi di ogni avvio si avvicina a 2,5 A. Quando un Arduino Uno è alimentato via USB, la corrente totale che puoi prelevare dal pin 5V è limitata dal fusibile da 500 mA della scheda, e una parte la usa la scheda stessa. Nell'istante in cui il servo parte, la linea dei 5 V cala vistosamente per qualche millisecondo, il processore diventa instabile e la scheda si riavvia. Il computer può anche disattivare per un po' una porta USB che rileva troppa corrente.

Anche i fili fanno parte del problema. I cavetti jumper sottili e i contatti della breadboard arrivano facilmente a 0,2 Ω in totale. Fai il calcolo con la legge di Ohm: con un picco di 2,5 A si perdono 2,5 × 0,2 = 0,5 V solo nei cavi, quindi l'alimentazione da 5 V arriva al servo come 4,5 V e il servo perde forza e trema. Inoltre i contatti della breadboard sono pensati per circa 1 A. Collega i fili di alimentazione del MG996R direttamente a un morsetto a vite o a una linea di distribuzione saldata invece che alla breadboard, e usa cavo da 20–22 AWG.

Alimentarlo bene: 5–6 V esterni, massa comune e condensatore

1. Scegli l'alimentatore: Usa un alimentatore switching da 5 V o 6 V in grado di fornire la corrente della tabella precedente per il tuo numero di servo. Nei progetti portatili funzionano bene 4 pile AA NiMH (4,8 V) oppure una LiPo 2S con un regolatore step-down (UBEC) impostato a 6 V.
2. Porta il positivo solo al servo: Collega il positivo dell'alimentatore al filo rosso del MG996R; non collegarlo 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. Il segnale è una tensione misurata rispetto a GND, quindi senza massa comune il servo non capisce gli impulsi.
4. Collega il segnale: Collega il filo arancione al pin D9 di Arduino Uno (GPIO 18 sull'ESP32, GP15 sul Pico).
5. Aggiungi un condensatore: Metti un condensatore elettrolitico da 470–1000 µF / 16 V tra i fili di alimentazione del servo, il più vicino possibile al servo; il piedino segnato dalla striscia va al negativo. Con più servo calcola circa 100 µF per servo.
6. Alimenta Arduino separatamente: Fai funzionare la scheda via USB o dal jack DC. Così i cali di tensione provocati dal servo non raggiungono il processore.

La libreria Servo e l'intervallo di 500–2500 µs

La libreria Servo di Arduino è inclusa nell'IDE. Quando scrivi servo.attach(9), la libreria usa di default l'intervallo 544–2400 µs e associa write(0) e write(180) a questi due estremi; con questo intervallo molti MG996R restano un po' sotto i 180 gradi. Per allargarlo scrivi servo.attach(9, 500, 2500). Il dettaglio è importante perché nemmeno writeMicroseconds() può uscire dai limiti indicati in attach: se scrivi writeMicroseconds(2500) senza averli impostati, la libreria riduce silenziosamente il valore a 2400. Inoltre write() interpreta i numeri minori di 544 come angoli e quelli maggiori come microsecondi.

Su Arduino Uno la libreria Servo gestisce fino a 12 servo e, poiché usa il Timer1, analogWrite non funziona sui pin 9 e 10 finché c'è un servo collegato. Anche il limite meccanico cambia leggermente da un MG996R all'altro: il datasheet del produttore indica circa 120 gradi di rotazione con gli impulsi standard di 1000–2000 µs, mentre con l'intervallo più ampio la maggior parte dei servo si avvicina ai 180 gradi. Un servo spinto oltre il suo limite va a sbattere contro il fine corsa interno, assorbe la corrente di stallo, ronza e si scalda. Per questo la prima cosa da fare è trovare l'intervallo di impulsi sicuro del tuo servo con lo sketch seguente.

1#include <Servo.h>
2
3const byte SERVO_PIN = 9;          // turuncu sinyal kablosu / orange signal wire
4Servo servo;
5int pulseUs = 1500;                // orta konum / center position
6
7void setup() {
8  Serial.begin(115200);
9  servo.writeMicroseconds(pulseUs);      // önce darbe, sonra attach / pulse first, then attach
10  servo.attach(SERVO_PIN, 500, 2500);    // aralığı genişlet / widen the range
11  Serial.println(F("500-2500 arasi bir deger yaz / type a value between 500 and 2500"));
12}
13
14void loop() {
15  if (Serial.available()) {
16    long value = Serial.parseInt();             // yazılan sayıyı oku / read the typed number
17    while (Serial.available()) Serial.read();   // satır sonunu temizle / clear the line ending
18    if (value >= 500 && value <= 2500) {
19      int step = (value > pulseUs) ? 10 : -10;  // 10 µs adımlarla yavaşça git / move slowly in 10 µs steps
20      while (abs(value - pulseUs) >= 10) {
21        pulseUs += step;
22        servo.writeMicroseconds(pulseUs);
23        delay(5);
24      }
25      pulseUs = value;
26      servo.writeMicroseconds(pulseUs);
27      Serial.print(F("Darbe / pulse: "));
28      Serial.print(pulseUs);
29      Serial.println(F(" us"));
30    }
31  }
32}

1. Carica lo sketch, apri il Monitor seriale a 115200 baud e imposta il fine riga su A capo (NL).
2. Scrivi 1500: il servo va al centro. Monta la squadretta in questo momento in modo che punti verso la posizione centrale del tuo meccanismo.
3. Scendi verso il limite inferiore a passi di 50 µs con valori come 1000, 800 e 700. Se il servo non si muove più o comincia a ronzare, torna indietro di 30–50 µs rispetto all'ultimo valore e annota quel numero come MIN_US.
4. Fai lo stesso per il limite superiore con valori come 2000, 2200 e 2300 e trova MAX_US. Userai questi due numeri negli sketch successivi.

Movimento morbido: codice che riduce i picchi di corrente e gli scossoni

Un solo comando come servo.write(160) lancia il servo verso l'obiettivo alla massima velocità, percorrendo 60 gradi in 0,14 secondi a 6 V. Nel frattempo il motore assorbe quasi la corrente di stallo, il meccanismo dà uno scossone e l'oggetto tenuto può cadere. Suddividere il movimento in piccoli passi riduce sia i picchi di corrente sia l'urto meccanico. Lo sketch seguente fa avanzare il servo di 1 grado ogni 15 ms (circa 67°/s) e, poiché usa millis(), nel frattempo puoi fare altro.

1#include <Servo.h>
2
3const byte SERVO_PIN = 9;
4const int MIN_US = 550;            // kalibrasyonda bulduğun alt sınır / lower limit from calibration
5const int MAX_US = 2450;           // kalibrasyonda bulduğun üst sınır / upper limit from calibration
6const byte STEP_MS = 15;           // derece başına süre: 15 ms ≈ 67°/sn / time per degree: 15 ms ≈ 67°/s
7
8const int POSES[] = {20, 160, 90, 45, 135};    // sırayla gidilecek açılar / angles to visit in order
9const byte POSE_COUNT = sizeof(POSES) / sizeof(POSES[0]);
10
11Servo servo;
12int current = 90;                  // şu anki açı / current angle
13int target = 90;                   // hedef açı / target angle
14byte poseIndex = 0;
15unsigned long lastStep = 0;
16unsigned long arrivedAt = 0;
17
18int angleToUs(int angle) {
19  return map(angle, 0, 180, MIN_US, MAX_US);   // açıyı darbeye çevir / angle to pulse width
20}
21
22void setup() {
23  servo.writeMicroseconds(angleToUs(current)); // önce konum, sonra attach / position first, then attach
24  servo.attach(SERVO_PIN, MIN_US, MAX_US);
25  arrivedAt = millis();
26}
27
28void loop() {
29  unsigned long now = millis();
30
31  // Hedefe 1 derecelik adımlarla yaklaş / approach the target in 1-degree steps
32  if (current != target && now - lastStep >= STEP_MS) {
33    lastStep = now;
34    current += (target > current) ? 1 : -1;
35    servo.writeMicroseconds(angleToUs(current));
36    if (current == target) arrivedAt = now;
37  }
38
39  // Hedefte 1 sn bekle, sonra sıradaki poza geç / wait 1 s at the target, then take the next pose
40  if (current == target && now - arrivedAt >= 1000) {
41    target = POSES[poseIndex];
42    poseIndex = (poseIndex + 1) % POSE_COUNT;
43  }
44
45  // Burada başka işler de yapılabilir / other tasks can run here too
46}

La funzione angleToUs() converte l'angolo in un impulso compreso tra i valori MIN_US e MAX_US trovati durante la calibrazione; così 0 e 180 gradi diventano gli estremi reali e sicuri del servo. Un servo spento non ricorda la sua posizione e, appena riceve il primo impulso, raggiunge quell'angolo alla massima velocità. Chiamare writeMicroseconds() prima di attach() fa sì che la libreria salti il suo impulso predefinito di 1500 µs e invii subito il tuo angolo di partenza; se riporti il meccanismo nella stessa posa iniziale prima di spegnerlo, il salto all'accensione quasi sparisce. Regola la velocità con STEP_MS: 30 ms danno un movimento lento e morbido, 5 ms uno veloce ma a scatti. Se vuoi muovere il servo con un potenziometro, basta convertire la lettura in un angolo e scriverla nella variabile target.

Tremolii e reset di Arduino: cause e soluzioni

Controllare il MG996R con un ESP32

La libreria Servo standard di Arduino non funziona sull'ESP32; installa la libreria ESP32Servo dal Gestore librerie. Si usa quasi allo stesso modo: imposti il periodo con setPeriodHertz(50) e la libreria non accetta limiti fuori da 500–2500 µs. L'uscita del segnale dell'ESP32 è a 3,3 V e la stragrande maggioranza dei MG996R la riconosce senza problemi; se il tuo servo non risponde o si comporta in modo instabile, aggiungi un convertitore di livello logico sulla linea del segnale. Nell'esempio seguente un potenziometro collegato a GPIO 34 fa ruotare il servo. Poiché l'ADC dell'ESP32 è a 12 bit, le letture vanno da 0 a 4095 e sono un po' rumorose; per questo il codice filtra e usa una banda morta.

1#include <ESP32Servo.h>
2
3const int SERVO_PIN = 18;          // servo sinyali / servo signal
4const int POT_PIN = 34;            // pot orta bacağı (ADC1) / pot wiper (ADC1)
5const int MIN_US = 500;            // ESP32Servo bu aralığın dışına çıkmaz / ESP32Servo stays within 500–2500
6const int MAX_US = 2500;
7
8Servo servo;
9float smooth = 0;                  // süzülmüş pot değeri / filtered pot value
10int lastAngle = -1;
11
12void setup() {
13  Serial.begin(115200);
14  ESP32PWM::allocateTimer(0);              // servo için zamanlayıcı ayır / reserve a timer for the servo
15  servo.setPeriodHertz(50);                // 50 Hz = 20 ms periyot / 20 ms period
16  servo.attach(SERVO_PIN, MIN_US, MAX_US);
17  smooth = analogRead(POT_PIN);
18}
19
20void loop() {
21  smooth += (analogRead(POT_PIN) - smooth) * 0.1;   // ADC gürültüsünü süz / filter ADC noise
22  int angle = map((int)smooth, 0, 4095, 0, 180);    // 12 bit ADC: 0–4095
23  if (abs(angle - lastAngle) >= 2) {                // ölü bant: titremeyi keser / deadband stops jitter
24    servo.write(angle);
25    lastAngle = angle;
26    Serial.println(angle);
27  }
28  delay(20);
29}

MG996R con il Raspberry Pi Pico (MicroPython)

Sul Raspberry Pi Pico non serve nessuna libreria aggiuntiva: imposti il PWM a 50 Hz e dai la larghezza dell'impulso in nanosecondi con duty_ns(); 500 µs sono 500000 ns. Anche il segnale del Pico è a 3,3 V. Non alimentare il servo dal pin VBUS o VSYS del Pico: la corrente su questi pin arriva dalla porta USB del computer e il picco di corrente del MG996R farà riavviare il Pico. Alimenta il servo con una fonte esterna e unisci le masse. Il codice seguente muove il servo in modo morbido, grado per grado, tra tre posizioni.

1from machine import Pin, PWM
2import time
3
4MIN_NS = 500000                   # 500 µs = 0 derece / 0 degrees
5MAX_NS = 2500000                  # 2500 µs = 180 derece / 180 degrees
6
7servo = PWM(Pin(15))              # turuncu kablo GP15'e / orange wire to GP15
8servo.freq(50)                    # 50 Hz servo sinyali / 50 Hz servo signal
9
10def write_angle(angle):
11    angle = max(0, min(180, angle))                           # 0–180 ile sınırla / clamp to 0–180
12    servo.duty_ns(MIN_NS + (MAX_NS - MIN_NS) * angle // 180)  # açıyı darbeye çevir / angle to pulse
13
14def move_slow(start, end, ms_per_degree=15):
15    step = 1 if end > start else -1
16    for a in range(start, end + step, step):  # 1 derecelik adımlar / 1-degree steps
17        write_angle(a)
18        time.sleep_ms(ms_per_degree)
19
20write_angle(90)                   # ortadan başla / start at the center
21time.sleep(1)
22
23while True:
24    move_slow(90, 170)
25    time.sleep(1)
26    move_slow(170, 10)
27    time.sleep(1)
28    move_slow(10, 90)
29    time.sleep(1)

16 servo con un PCA9685: tanti MG996R con due fili

Quando il numero di servo cresce, o quando lavori con librerie che disattivano gli interrupt, il modulo PCA9685 ti semplifica la vita. Questa scheda è un generatore PWM a 16 canali e 12 bit che comunica con Arduino via I2C usando solo i fili SDA e SCL. Poiché genera gli impulsi con il proprio clock, il segnale resta stabile anche quando il processore è occupato con altro. L'indirizzo predefinito è 0x40; cambiando l'indirizzo con i ponticelli a saldare A0–A5 della scheda puoi collegare 62 schede allo stesso bus, cioè in teoria 992 servo. A 50 Hz il periodo di 20 ms è diviso in 4096 passi e ogni passo vale circa 4,9 µs: 500 µs corrispondono a circa 102 passi e 2500 µs a circa 512.

1#include <Wire.h>
2#include <Adafruit_PWMServoDriver.h>
3
4Adafruit_PWMServoDriver pca = Adafruit_PWMServoDriver(0x40);   // varsayılan adres / default address
5
6const byte SERVO_COUNT = 16;
7const uint16_t MIN_US = 500;       // kalibrasyonla daralt / narrow it after calibration
8const uint16_t MAX_US = 2500;
9
10uint16_t angleToUs(float angle) {
11  return MIN_US + (uint16_t)(angle * (MAX_US - MIN_US) / 180.0);
12}
13
14void setup() {
15  pca.begin();
16  pca.setOscillatorFrequency(27000000);   // kartın gerçek saatine yakın / close to the real board clock
17  pca.setPWMFreq(50);                     // servolar için 50 Hz / 50 Hz for servos
18  delay(10);
19  for (byte ch = 0; ch < SERVO_COUNT; ch++) {
20    pca.writeMicroseconds(ch, angleToUs(90));   // hepsini ortala / center them all
21    delay(200);                                 // sırayla başlat: akım darbesini dağıt / one by one: spread the current surge
22  }
23}
24
25void loop() {
26  // Dalga: her servo komşusundan biraz geride / wave: each servo slightly behind its neighbour
27  float t = millis() / 1000.0;
28  for (byte ch = 0; ch < SERVO_COUNT; ch++) {
29    float angle = 90 + 40 * sin(t * 2.0 - ch * 0.4);   // 50–130° arası / between 50° and 130°
30    pca.writeMicroseconds(ch, angleToUs(angle));
31  }
32  delay(20);
33}

Per usare lo sketch installa la libreria Adafruit PWM Servo Driver dal Gestore librerie. La riga setOscillatorFrequency(27000000) è importante: sulla carta il clock interno del PCA9685 è di 25 MHz, ma in realtà varia tra circa 23 e 27 MHz e gli esempi di Adafruit usano 27 MHz. Senza questa impostazione gli impulsi impostati con writeMicroseconds() possono scostarsi di qualche punto percentuale. Avviare i servo uno alla volta, a 200 ms di distanza, evita che tutti e 16 assorbano insieme la corrente di spunto. Se ogni servo ha limiti diversi, trasforma MIN_US e MAX_US in array da 16 elementi e calibra ogni canale. Lo sketch funziona senza modifiche anche sull'ESP32, perché lì la libreria Wire usa di default GPIO 21 e 22.

MG996R, SG90 e MG90S a confronto

A decidere sono il carico e la lunghezza del braccio. Se devi ruotare un pezzo di pochi grammi o vuoi solo sperimentare, basta l'SG90. Se vuoi le stesse dimensioni con ingranaggi in metallo resistenti agli urti, scegli il MG90S. Se la coppia necessaria supera 1 kg·cm, per esempio per portare 100 g all'estremità di un braccio di 10 cm, passa al MG996R. Il MG996R ha circa cinque volte la coppia dell'SG90, ma è più lento, sei volte più pesante e assorbe da tre a quattro volte più corrente, quindi pianifica di conseguenza alimentazione e fissaggio meccanico. Se anche 11 kg·cm non bastano, guarda i servo più grandi della classe da 20 kg·cm, come il DS3218.

Scegliere i servo per un braccio robotico

• Base: MG996R. Non far gravare tutto il peso del braccio sull'albero del servo; metti un cuscinetto nella base così il servo deve solo farlo ruotare.
• Spalla: È l'articolazione più sollecitata. Usa un MG996R; se il braccio supera i 20 cm, aggiungi un servo della classe da 20 kg·cm o un contrappeso.
• Gomito: MG996R. Portare il servo pesante all'altezza della spalla e muovere il gomito con un'asta di spinta riduce il carico sulla spalla.
• Polso e rotazione del polso: Basta un MG90S; usare qui un MG996R aggiunge solo peso che la spalla deve portare.
• Pinza: SG90 o MG90S. Imposta l'angolo di chiusura nel punto in cui le dita toccano appena l'oggetto; un servo che continua a stringere assorbe la corrente di stallo.
• Fissaggio: Monta una squadretta metallica sull'albero a 25 denti del MG996R e bloccala con la vite centrale; le squadrette di plastica si spanano presto con questa coppia.

Idee di progetto con il MG996R

• Braccio robotico: Un braccio a 6 servo con MG996R su base, spalla e gomito e MG90S su polso e pinza; la costruzione è nella guida al braccio robotico.
• Telecamera pan-tilt: Fai ruotare un modulo ESP32-CAM in orizzontale e in verticale con due MG996R.
• Inseguitore solare: Trova la direzione della luce con quattro LDR e orienta un piccolo pannello verso il sole con un MG996R; i dettagli sono nell'articolo sull'inseguitore solare.
• Cestino intelligente: Un cestino intelligente che apre un coperchio pesante quando si avvicina una mano.
• Serratura a tessera: Tira un chiavistello con un MG996R quando l'RFID RC522 legge la tessera giusta.
• Gru con joystick: Una piccola gru o escavatore che si muove su due assi con un joystick.
• Trazione continua: Una ruota lenta ma potente con la versione a 360 gradi del MG996R; la differenza è spiegata nell'articolo sul servo a 360 gradi.

Se alimentato bene, il MG996R è un motore robusto ed economico che si fa carico senza fatica di lavori impossibili per i servo piccoli. Ricorda le regole: alimentazione esterna da 5–6 V, massa comune, un condensatore vicino al servo, un intervallo di impulsi calibrato e movimenti morbidi, e un PCA9685 quando i servo aumentano. Nell'app BlueGrays trovi progetti come il controllo dei servo con potenziometro e joystick, una serratura RFID con ESP32 e servo e una coreografia con 32 servo, ognuno con lo schema passo passo e il codice pronto all'uso.