Servo MG996R com Arduino: torque, corrente, alimentação e código

O servo MG996R é o servo padrão para trabalhos pesados em projetos com Arduino, graças às engrenagens de metal e a um torque de até 11 kg·cm a 6 V. Com um corpo de 55 gramas, ele levanta o ombro de um braço robótico, abre uma tampa pesada ou gira um suporte pan-tilt de câmera. Mas essa força tem um preço: quando está sob esforço, o MG996R puxa até 2,5 A. Por isso, ao contrário de um SG90, não dá para simplesmente ligá-lo no pino 5V do Arduino; ele precisa de uma fonte externa de 5–6 V, GND comum e um capacitor perto do servo. Se essas regras forem ignoradas, o servo treme, o Arduino reinicia sem parar e o computador pode até desligar a porta USB.

Neste guia, você vai aprender a interpretar os valores de torque e corrente do MG996R com números reais, escolher a fonte de alimentação certa, usar a faixa de 500–2500 µs com a biblioteca Servo para encontrar os limites do seu próprio servo e evitar tremedeira e reinicializações. Depois, passamos para o código no ESP32 e no Raspberry Pi Pico, o módulo PCA9685 que controla 16 servos com dois fios, a escolha de servos para um braço robótico e uma comparação com o SG90 e o MG90S.

O que é o servo MG996R e como ele funciona?

O MG996R é uma versão melhorada do antigo MG995 da TowerPro: a placa de controle e as engrenagens redesenhadas centralizam com mais precisão e têm menos folga. Dentro da carcaça há um pequeno motor CC, uma caixa de engrenagens de metal que reduz a rotação do motor e multiplica o torque, um potenciômetro que mede o ângulo do eixo de saída e uma placa de controle que gerencia tudo isso. A placa lê a largura do pulso que chega pelo fio de sinal a cada 20 ms (50 Hz), compara o ângulo pedido com o ângulo informado pelo potenciômetro e gira o motor até a diferença desaparecer. Um pulso de cerca de 1500 µs corresponde à posição central; pulsos mais curtos giram o eixo para um lado e pulsos mais longos, para o outro. A zona morta de 5 µs do datasheet significa que o servo ignora mudanças menores que isso. Explicamos o funcionamento dos servos em geral em O que é um servo motor?.

O que significa torque? Como ler corretamente o valor em kg·cm

Torque é a capacidade do servo de girar uma carga a uma certa distância do eixo e é medido como força × distância. 11 kg·cm significa que ele segura 11 kg a 1 cm do eixo, ou 1,1 kg a 10 cm; dobre a distância e a carga suportada cai pela metade. Para converter em newton-metro, multiplique por 0,098: 11 kg·cm ≈ 1,08 N·m. O detalhe principal é este: o valor do datasheet é o torque de travamento, o limite em que o eixo para, a corrente chega ao pico e o servo esquenta. Para uso contínuo, ficar em no máximo metade desse valor mantém o servo frio, reduz a tremedeira e faz as engrenagens durarem mais.

A tabela considera só a carga na ponta. Em um mecanismo real, o peso do próprio braço, os outros servos montados nele e a garra também somam torque; é preciso multiplicar a massa de cada parte pela distância até o eixo e somar tudo. Por exemplo, se um braço de 15 cm leva na ponta uma garra de 150 g e um objeto de 100 g, só esses dois já dão 0,25 × 15 = 3,75 kg·cm; com o peso do próprio braço, o total pode chegar a 5 kg·cm. Isso fica um pouco abaixo da metade do torque de travamento do MG996R a 6 V, então ele é a escolha certa. Você encontra um cálculo de torque peça por peça, com exemplo, no guia do braço robótico com Arduino.

Corrente: por que o MG996R não funciona no pino 5V do Arduino?

Em repouso e sem carga, o MG996R puxa só cerca de 10 mA (segurar uma carga aumenta esse valor conforme a carga), mas em movimento a corrente sobe para 0,5–0,9 A e, com o eixo sob carga e nos primeiros milissegundos de cada partida, chega perto de 2,5 A. Quando um Arduino Uno é alimentado pela USB, a corrente total que se pode tirar do pino 5V é limitada pelo fusível de 500 mA da placa, e a própria placa consome parte disso. No instante em que o servo parte, a linha de 5 V cai bastante por alguns milissegundos, o processador fica instável e a placa reinicia. O computador também pode desligar uma porta USB que fica um tempo com corrente excessiva.

Os fios também fazem parte do problema. Os jumpers finos e os contatos da protoboard somam facilmente 0,2 Ω. Faça a conta com a lei de Ohm: num pico de 2,5 A, 2,5 × 0,2 = 0,5 V se perdem só na fiação, então uma fonte de 5 V chega ao servo como 4,5 V, e o servo fica mais fraco e treme. Além disso, os contatos da protoboard são projetados para cerca de 1 A. Ligue os fios de alimentação do MG996R diretamente a um borne com parafuso ou a um barramento de distribuição soldado, e não à protoboard, e use fio de 20–22 AWG.

Alimentação correta: fonte externa de 5–6 V, GND comum e capacitor

1. Escolha a fonte: use uma fonte chaveada de 5 V ou 6 V que entregue a corrente da tabela acima para o seu número de servos. Em projetos portáteis, 4 pilhas AA NiMH (4,8 V) ou uma LiPo 2S com um regulador abaixador (UBEC) ajustado para 6 V funcionam bem.
2. Leve o positivo só para o servo: ligue o positivo da fonte ao fio vermelho do MG996R; não o ligue ao pino 5V do Arduino.
3. Una os GNDs: ligue o negativo da fonte tanto ao fio marrom do servo quanto ao pino GND do Arduino. O sinal é uma tensão medida em relação ao GND; sem GND comum, o servo não entende os pulsos.
4. Ligue o sinal: conecte o fio laranja ao pino D9 do Arduino Uno (GPIO 18 no ESP32, GP15 no Pico).
5. Adicione um capacitor: coloque um capacitor eletrolítico de 470–1000 µF / 16 V entre os terminais de alimentação do servo, o mais perto possível dele; a perna marcada com a faixa vai no negativo. Com vários servos, conte cerca de 100 µF por servo.
6. Alimente o Arduino separadamente: ligue a placa pela USB ou pelo conector DC. Assim, as quedas de tensão causadas pelo servo não chegam ao processador.

A biblioteca Servo e a faixa de 500–2500 µs

A biblioteca Servo do Arduino já vem com a IDE. Quando você escreve servo.attach(9), a biblioteca usa a faixa padrão de 544–2400 µs e associa write(0) e write(180) a essas duas pontas; nessa faixa, muitos MG996R não chegam bem a 180 graus. Para ampliá-la, escreva servo.attach(9, 500, 2500). Esse detalhe importa porque writeMicroseconds() também não passa dos limites dados ao attach: se você escrever writeMicroseconds(2500) sem definir os limites, a biblioteca corta o valor para 2400 sem avisar. Além disso, write() trata números menores que 544 como ângulo e números maiores como microssegundos.

No Arduino Uno, a biblioteca Servo aceita até 12 servos e, como usa o Timer1, o analogWrite não funciona nos pinos 9 e 10 enquanto houver um servo conectado. O limite mecânico de cada MG996R também é um pouco diferente: o datasheet do fabricante indica cerca de 120 graus de rotação com os pulsos padrão de 1000–2000 µs, enquanto com a faixa ampliada a maioria dos servos chega perto de 180 graus. Um servo forçado além do limite bate no batente interno, puxa a corrente de travamento, zumbe e esquenta. Por isso, a primeira tarefa é encontrar a faixa de pulso segura do seu servo com o sketch abaixo.

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. Carregue o sketch, abra o Monitor Serial a 115200 baud e ajuste o final de linha para Nova linha.
2. Digite 1500; o servo vai para o centro. Encaixe o braço do servo nesse momento, apontando para a posição central do seu mecanismo.
3. Desça em direção ao limite inferior em passos de 50 µs, com valores como 1000, 800 e 700. Se o servo parar de se mover ou começar a zumbir, volte 30–50 µs a partir do último valor e anote esse número como MIN_US.
4. Faça o mesmo para o limite superior, com valores como 2000, 2200 e 2300, e encontre o MAX_US. Você vai usar esses dois números nos próximos sketches.

Movimento suave: código que reduz picos de corrente e trancos

Um único comando como servo.write(160) joga o servo até o alvo em velocidade máxima, percorrendo 60 graus em 0,14 segundo a 6 V. Enquanto isso, o motor puxa uma corrente próxima à de travamento, o mecanismo dá um tranco e o objeto que está sendo segurado pode cair. Dividir o movimento em passos pequenos reduz tanto os picos de corrente quanto o choque mecânico. O sketch abaixo avança o servo 1 grau a cada 15 ms (cerca de 67°/s) e, como usa millis(), você pode fazer outras coisas ao mesmo tempo.

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}

A função angleToUs() mapeia o ângulo entre os valores MIN_US e MAX_US que você encontrou na calibração, então 0 e 180 graus passam a ser os pontos finais reais e seguros do servo. O servo não se lembra da posição quando está desligado e vai para o ângulo comandado em velocidade máxima assim que recebe o primeiro pulso. Chamar writeMicroseconds() antes de attach() faz a biblioteca pular o pulso padrão de 1500 µs e enviar direto o seu ângulo inicial; se você levar o mecanismo de volta à mesma posição inicial antes de desligar, o salto ao ligar quase desaparece. Ajuste a velocidade com STEP_MS: 30 ms dá um movimento lento e suave; 5 ms, um movimento rápido, mas com trancos. Se quiser controlar o servo com um potenciômetro, basta converter a leitura em ângulo e escrevê-la na variável target.

Tremedeira e reinicialização do Arduino: causas e soluções

Controlando o MG996R com o ESP32

A biblioteca Servo padrão do Arduino não funciona no ESP32; instale a biblioteca ESP32Servo pelo Gerenciador de Bibliotecas. O uso é quase igual: você define o período com setPeriodHertz(50), e a biblioteca não aceita limites fora de 500–2500 µs. A saída de sinal do ESP32 é de 3,3 V, e a grande maioria dos MG996R a lê sem problemas; se o seu servo não responder ou se comportar de forma estranha, adicione um conversor de nível lógico na linha de sinal. No exemplo abaixo, um potenciômetro ligado ao GPIO 34 gira o servo. Como o ADC do ESP32 é de 12 bits, as leituras vão de 0 a 4095 e têm um pouco de ruído; por isso o código usa filtragem e zona 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 com o Raspberry Pi Pico (MicroPython)

No Raspberry Pi Pico não é preciso biblioteca extra: ajuste o PWM para 50 Hz e informe a largura do pulso em nanossegundos com duty_ns(); 500 µs são 500000 ns. O sinal do Pico também é de 3,3 V. Não alimente o servo pelo pino VBUS ou VSYS do Pico; a corrente desses pinos vem da porta USB do computador, e o pico de corrente do MG996R reinicia o Pico. Alimente o servo com uma fonte externa e una os GNDs. O código abaixo move o servo suavemente, grau a grau, entre três posições.

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 servos com PCA9685: vários MG996R com dois fios

Quando o número de servos cresce, ou quando você trabalha com bibliotecas que desativam as interrupções, o módulo PCA9685 facilita a vida. Essa placa é um gerador de PWM de 16 canais e 12 bits que conversa com o Arduino por I2C usando só os fios SDA e SCL. Como gera os pulsos com o próprio clock, o sinal fica estável mesmo quando o processador está ocupado com outras tarefas. O endereço padrão é 0x40; mudando o endereço com os jumpers de solda A0–A5 da placa, você pode ligar 62 placas no mesmo barramento, ou seja, 992 servos na teoria. A 50 Hz, o período de 20 ms é dividido em 4096 passos, e cada passo tem cerca de 4,9 µs: 500 µs são cerca de 102 passos e 2500 µs, cerca de 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}

Para rodar o sketch, instale a biblioteca Adafruit PWM Servo Driver pelo Gerenciador de Bibliotecas. A linha setOscillatorFrequency(27000000) é importante: no papel, o clock interno do PCA9685 é de 25 MHz, mas na prática varia entre cerca de 23 e 27 MHz, e os exemplos da Adafruit usam 27 MHz. Sem esse ajuste, os pulsos definidos com writeMicroseconds() podem errar alguns por cento. Ligar os servos um por um, com 200 ms de intervalo, no setup evita que os 16 puxem a corrente de partida ao mesmo tempo. Se cada servo tiver limites diferentes, transforme MIN_US e MAX_US em arrays de 16 elementos e calibre cada canal. O sketch também roda sem mudanças no ESP32, porque lá a biblioteca Wire usa os GPIO 21 e 22 por padrão.

MG996R, SG90 ou MG90S

Quem decide são a carga e o comprimento do braço. Se você vai girar uma peça de poucos gramas ou só está experimentando, o SG90 basta. Se quer o mesmo tamanho com engrenagens de metal resistentes a impactos, escolha o MG90S. Se o torque necessário passa de 1 kg·cm, por exemplo para levar 100 g na ponta de um braço de 10 cm, suba para o MG996R. O MG996R tem cerca de cinco vezes o torque do SG90, mas é mais lento, seis vezes mais pesado e puxa de três a quatro vezes mais corrente; planeje a alimentação e a fixação mecânica de acordo. Se 11 kg·cm ainda não forem suficientes, procure servos maiores da classe de 20 kg·cm, como o DS3218.

Como escolher os servos de um braço robótico

• Base: MG996R. Não coloque todo o peso do braço sobre o eixo do servo; adicione um rolamento na base para que o servo só precise girá-la.
• Ombro: é a articulação mais exigida. Use um MG996R; se o braço tiver mais de 20 cm, adicione um servo da classe de 20 kg·cm ou um contrapeso.
• Cotovelo: MG996R. Levar o servo pesado para a altura do ombro e acionar o cotovelo com uma haste de transmissão reduz a carga no ombro.
• Punho e rotação do punho: um MG90S basta; usar um MG996R aqui só acrescenta peso para o ombro carregar.
• Garra: SG90 ou MG90S. Ajuste o ângulo de fechamento até o ponto em que os dedos apenas encostam no objeto; um servo que continua tentando apertar puxa corrente de travamento.
• Fixação: encaixe um braço de metal no eixo de 25 dentes do MG996R e prenda com o parafuso central; braços de plástico espanam rápido com esse torque.

Ideias de projetos com o MG996R

• Braço robótico: um braço de 6 servos com MG996R na base, no ombro e no cotovelo e servos MG90S no punho e na garra; veja a montagem no guia do braço robótico.
• Câmera pan-tilt: gire um módulo ESP32-CAM na horizontal e na vertical com dois MG996R.
• Seguidor solar: encontre a direção da luz com quatro LDRs e vire um painel pequeno para o sol com um MG996R; detalhes no artigo sobre o seguidor solar.
• Lixeira inteligente: uma lixeira inteligente que abre uma tampa pesada quando uma mão se aproxima.
• Fechadura com cartão: puxe um ferrolho com um MG996R quando o cartão certo for lido em um leitor RFID RC522.
• Guindaste controlado por joystick: um pequeno guindaste ou escavadeira que se move em dois eixos com um joystick.
• Tração contínua: uma roda lenta, mas forte, usando a versão de 360 graus do MG996R; a diferença é explicada no artigo sobre o servo de 360 graus.

Bem alimentado, o MG996R é um motor robusto e barato que dá conta com facilidade de tarefas que servos pequenos não aguentam. Lembre-se das regras: fonte externa de 5–6 V, GND comum, capacitor perto do servo, faixa de pulso calibrada e movimento suave, e um PCA9685 quando o número de servos crescer. No app BlueGrays, você encontra projetos como controle de servo com potenciômetro e com joystick, fechadura RFID com ESP32 e servo e uma coreografia com 32 servos, cada um com esquema do circuito passo a passo e código pronto para usar.