Componentes · 14 min de leitura

Servo MG90S com Arduino: comparação com o SG90, ligação e calibração

Usando o servo MG90S com Arduino: engrenagens metálicas x SG90, torque de 2,2 kg·cm, cores dos fios, calibração em 500–2400 µs, alimentação e código para Uno, ESP32 e Pico.

O servo MG90S é um micro servo do mesmo tamanho do SG90, mas com engrenagens metálicas: o corpo de 13,4 g entrega 1,8 kg·cm de torque de travamento em 4,8 V e 2,2 kg·cm em 6 V, e aguenta pancadas, batidas do braço e giros acidentais com a mão muito melhor que o SG90 de engrenagens plásticas. Usar o servo MG90S com Arduino é tão fácil quanto um SG90: os mesmos três fios, a mesma biblioteca Servo e o mesmo sinal de 50 Hz. As diferenças estão nos detalhes; ele consome um pouco mais de corrente, a faixa de pulso varia de unidade para unidade e ele precisa de calibração se você quiser ângulos precisos.

Neste guia você vai comparar as especificações do MG90S com as do SG90 e do MG996R e ver as cores dos fios e as ligações para Arduino Uno, ESP32 e Raspberry Pi Pico. Depois vai aprender como a faixa de pulso de 500–2400 µs vira ângulo, como achar os limites do seu servo pelo Monitor Serial e como corrigir erros de ângulo com calibração em três pontos. As últimas seções tratam do dimensionamento de uma fonte separada, do controle pelo celular com ESP32, do código MicroPython para a Pico e de quais juntas de um braço robótico combinam com o MG90S.

Micro servo motor MG90S com engrenagens metálicas
MG90S: as mesmas medidas de corpo do SG90, engrenagens metálicas e três fios nas cores marrom, vermelho e laranja.

O que é o servo MG90S e como ele funciona?

Dentro do MG90S há um pequeno motor DC, uma caixa de engrenagens metálica que reduz a velocidade do motor e multiplica o torque, um potenciômetro que mede o ângulo do eixo de saída e uma placa de controle que comanda tudo. A cada 20 ms (50 Hz), a placa mede a largura do pulso que chega pelo fio de sinal, compara com o ângulo informado pelo potenciômetro e aciona o motor até a diferença sumir. Um pulso de cerca de 1500 µs significa a posição central; pulsos mais curtos giram o eixo para um lado, e mais longos para o outro. A banda morta de 5 µs do datasheet é metade dos 10 µs do SG90, então o MG90S reage a mudanças menores de pulso e mantém a posição com mais precisão. Vimos o básico do funcionamento dos servos em O que é um servo motor?.

CaracterísticaValor
Tensão de operação4,8–6 V
Torque de travamento1,8 kg·cm (4,8 V), 2,2 kg·cm (6 V) ≈ 0,18–0,22 N·m
Velocidade (a cada 60°)0,10 s (4,8 V), 0,08 s (6 V)
Corrente em repousoCerca de 5–10 mA (eixo parado, sem carga)
Corrente em movimentoCerca de 120–250 mA (sem carga)
Corrente de travamentoCerca de 0,7–1 A
Banda morta5 µs
RotaçãoCerca de 180° com 500–2400 µs (varia de unidade para unidade)
Sinal50 Hz (período de 20 ms), posição definida pela largura de pulso
EngrenagensEngrenagens metálicas, rolamento no eixo de saída
Peso e tamanho13,4 g, 22,8 × 12,2 × 28,5 mm
CaboCerca de 25 cm; marrom GND, vermelho positivo, laranja sinal
Temperatura de operação0–55 °C

MG90S x SG90: engrenagens, torque e corrente

Por fora, os dois servos são quase idênticos: os furos de fixação, a largura do corpo e os braços são compatíveis, então você encaixa um MG90S direto em um suporte feito para o SG90. A diferença real está dentro. As engrenagens plásticas do SG90 pulam dentes e quebram quando o braço bate em algo ou o eixo é forçado com a mão; as engrenagens metálicas do MG90S costumam aguentar a mesma pancada sem problema. Em 6 V o torque sobe de 1,8 para 2,2 kg·cm e a velocidade cai para 0,08 segundo a cada 60 graus. Em troca, o MG90S é cerca de 4,4 gramas mais pesado, consome um pouco mais de corrente quando travado e geralmente custa duas a três vezes o preço de um SG90. Engrenagens metálicas também podem ter uma pequena folga; em um braço preciso, isso aparece como um ou dois graus de jogo quando a carga muda de direção.

CaracterísticaSG90MG90SMG996R
EngrenagensPlásticoMetalMetal, rolamento duplo
Torque de travamento1,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)
Velocidade (a cada 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
Tamanho22,2 × 11,8 × 31 mm22,8 × 12,2 × 28,5 mm40,7 × 19,7 × 42,9 mm
Tensão de operação4,8–6 V4,8–6 V4,8–7,2 V
Corrente de travamentoCerca de 0,6–0,75 ACerca de 0,7–1 A2,5 A (6 V)
Resistência a impactosBaixa, as engrenagens espanam fácilBoaMuito boa
Pelo pino 5V do ArduinoUm servo, carga leveUm servo, carga leveNão, sempre com fonte externa
Uso típicoPrimeiros experimentos, tampas levesPunho, garra, pan-tilt, robôs pequenosOmbro de braço robótico, tampa pesada, direção
SG90
SG90
MG90S
MG90S
MG996R
MG996R

Para escolher, calcule primeiro o torque necessário: torque é o peso da carga multiplicado pela distância até o eixo. Uma carga de 100 g a 5 cm do eixo precisa de 0,1 × 5 = 0,5 kg·cm. Em 5 V o MG90S dá cerca de 2 kg·cm, mas esse é o limite de travamento, em que o eixo para; em uso contínuo, ficar em no máximo metade disso, uns 1 kg·cm, mantém o servo frio e faz as engrenagens durarem mais. Por essa regra, o MG90S carrega com folga até 200 g na ponta de um braço de 5 cm e até 100 g na ponta de um braço de 10 cm. Se você precisa de mais de 1 kg·cm, suba para o servo MG996R; se está só experimentando ou girando uma peça de poucos gramas, um SG90 basta.

Cores dos fios e ligação do MG90S

Os três fios do MG90S seguem o padrão de cores da TowerPro. Alguns fabricantes usam outras cores, mas a ordem é quase sempre a mesma, com o positivo no meio. Se você encaixar o conector invertido, o servo geralmente não estraga, só não funciona; mesmo assim, corrija na hora, porque a corrente de terra do servo tenta passar pelo pino de sinal do Arduino.

Fio (TowerPro)FunçãoOutras marcasLigar em
MarromGND (negativo)PretoNegativo da fonte e GND do Arduino
VermelhoPositivo (4,8–6 V)Vermelho5 V ou positivo externo de 5–6 V
LaranjaSinal (PWM)Amarelo ou brancoUm pino digital da placa
LigaçãoArduino UnoESP32Raspberry Pi Pico
Laranja (sinal)D9GPIO 18GP15
Vermelho (positivo): um servo, carga levePino 5VPino 5V (VIN), pelo USBPino VBUS (5 V do USB)
Vermelho (positivo): carga ou vários servosExterno de 5–6 VExterno de 5–6 VExterno de 5–6 V
Marrom (GND)GND e negativo da fonteGND e negativo da fonteGND e negativo da fonte
Potenciômetro (exemplo do Uno)Cursor no A0, pernas externas no 5V e no GND——
Segundo servo (exemplo da Pico)——GP14
Nunca ligue o fio vermelho em um pino de 3,3 V: o servo funciona fraco e força o pequeno regulador da placa. Alimente um único MG90S pelo pino 5V do Arduino só em testes sem carga; quando o servo trava, uma corrente perto de 1 A passa do limite de 500 mA do USB e a placa reinicia. Uma bateria LiPo 2S de 7,4 V passa do limite de 6 V do MG90S; ligada direto, pode queimar a placa de controle. Ao usar uma fonte externa, não esqueça de ligar os GNDs; explicamos o motivo em O que é GND?.

Alimentação separada: quantos servos, quanta corrente?

Um MG90S consome 120–250 mA ao se mover sem carga, mas nos primeiros milissegundos de cada partida e quando o eixo é forçado, a corrente pula para 0,7–1 A. Com mais servos, esses picos se somam. Considere também a fiação: os contatos da protoboard e jumpers finos chegam fácil a 0,2 Ω. Faça a conta com a lei de Ohm: com um pico de 3,2 A de quatro servos partindo juntos, 3,2 × 0,2 = 0,64 V se perdem só nos fios; a fonte de 5 V chega aos servos como 4,4 V, e eles enfraquecem e tremem. Distribuir a alimentação dos servos por um borne com parafuso ou um barramento soldado, em vez da protoboard, reduz muito essa perda.

Número de servosEm movimentoPior caso (todos travados)Fonte recomendada
10,12–0,25 ACerca de 1 A5V do Arduino para testes sem carga, 5 V 1 A com carga
2 (pan-tilt)0,25–0,5 A2 A5 V, 2 A
4 (braço robótico pequeno)0,5–1 A4 A5 V, 3–4 A
60,75–1,5 A6 A5–6 V, 5 A e código que move os servos um por vez
16 (PCA9685)2–4 A16 AFonte chaveada de 5–6 V, 10 A ou mais
  1. Escolha a fonte: use um adaptador chaveado de 5 V ou 4 pilhas AA NiMH (4,8 V). Pilhas alcalinas novas chegam a 1,6 V cada, então um suporte de 4 pilhas pode dar 6,4 V, um pouco acima do limite do MG90S.
  2. Leve o positivo ao servo: ligue o positivo da fonte no fio vermelho do servo; não ligue no pino 5V do Arduino.
  3. Ligue os GNDs: ligue o negativo da fonte tanto no fio marrom do servo quanto no pino GND do Arduino; sem GND comum, o servo não lê os pulsos corretamente.
  4. Coloque um capacitor: ponha um capacitor eletrolítico de 470 µF / 16 V na alimentação dos servos, perto deles; com vários servos, acrescente uns 100 µF por servo. A perna com a faixa vai no negativo.
  5. Ligue o sinal: ligue o fio laranja no pino D9 do Uno e alimente o Arduino separadamente pelo USB ou pelo conector P4.
Se você tem um adaptador de 12 V, pode ajustar a saída de um módulo LM2596 para 5–6 V e alimentar com folga até três servos MG90S. Em um projeto com bateria, estime a autonomia com a calculadora de duração de bateria; a corrente média dos servos pode variar dez vezes conforme eles se movem o tempo todo ou só de vez em quando.

A faixa de pulso de 500–2400 µs e a biblioteca Servo

Com a biblioteca Servo que vem com a Arduino IDE, escrever servo.attach(9) dá uma faixa padrão de 544–2400 µs, e write(0) e write(180) são mapeados para essas duas pontas. A maioria dos MG90S precisa de um pulso menor que 544 µs para 0 grau, então, com a configuração padrão, o servo fica alguns graus aquém em uma das pontas. Especificar a faixa com servo.attach(9, 500, 2400) resolve isso. Esse detalhe importa porque writeMicroseconds() também não pode sair dos limites passados ao attach; sem eles, os 500 µs que você escreve sobem em silêncio para 544. Na faixa de 500–2400 µs, um grau equivale a cerca de 1900 / 180 ≈ 10,6 µs. Como a banda morta do MG90S é de 5 µs, dá até para fazer passos de meio grau com writeMicroseconds().

ÂnguloPadrão attach(9) (544–2400)attach(9, 500, 2400)Observação
0°544 µs500 µsAlguns graus de diferença na ponta
45°1008 µs975 µs—
90°1472 µs1450 µsO centro real geralmente fica entre 1450 e 1550 µs
135°1936 µs1925 µs—
180°2400 µs2400 µsEstreite se bater no batente mecânico

Os valores da tabela são calculados; em um servo real, o pulso necessário para 90 graus pode ser 1500 ou 1520 µs em vez de 1450. Alguns datasheets dizem que 1000–2000 µs dão o curso completo, mas na prática um MG90S gira só 90–100 graus nessa faixa. Se você levar o pulso além do limite mecânico, o servo força o batente interno, zumbe, puxa corrente de travamento e esquenta; como as engrenagens metálicas aguentam esse esforço em silêncio, você não percebe o problema tão rápido quanto com um SG90. Por isso a primeira tarefa é medir os limites do seu próprio servo.

Calibração do ângulo: ache os limites do seu MG90S

O código abaixo move o servo em passos de 10 µs com os caracteres que você digita no Monitor Serial. + aumenta o pulso, - diminui e c volta ao centro (1500 µs); n grava o valor atual como limite inferior e x como limite superior. Depois de cada gravação, o código mostra uma linha attach pronta para os seus próximos sketches. Para dar vários passos de uma vez, digite +++++ e aperte Enter; o servo anda cinco passos, ou 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. Ligue o servo sem carga, carregue o código e abra o Monitor Serial a 115200 baud.
  2. Digite c e aperte Enter; o servo vai para 1500 µs. Encaixe o braço na posição do estriado mais próxima do centro do seu mecanismo.
  3. Vá em direção à ponta inferior com -. Quando o servo parar de girar, zumbir ou tremer, volte 3–4 passos (30–40 µs) e digite n.
  4. Faça o mesmo na ponta superior com + e digite x. Anote a linha servo.attach(9, MIN, MAX) mostrada no Monitor Serial.
  5. Ache os 90 graus com um transferidor desenhado em papel ou impresso: grave como US_90 o pulso em que o braço fica exatamente na vertical.

Por causa dos dentes do eixo do servo, o braço só encaixa em passos fixos, então raramente fica exatamente no centro, e você corrige os poucos graus de diferença no software. Além disso, a relação entre pulso e ângulo de um servo não é perfeitamente linear: um mapeamento de dois pontos que acerta 0 e 180 graus pode errar 3–5 graus no meio. A calibração em três pontos elimina esse erro: você usa os três pulsos medidos para 0, 90 e 180 graus e chama a função map() separadamente para cada metade. O código abaixo usa esse método para passar ao servo o ângulo lido de um potenciômetro no 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}

Troque US_0, US_90 e US_180 pelas suas medições. angleToUs() mapeia 0–90 entre os dois primeiros pontos e 90–180 entre os dois últimos, então a posição em que o braço fica na vertical é de fato 90 graus. Usar writeMicroseconds() também evita que o write() arredonde para graus inteiros. O ruído de poucas unidades na leitura do potenciômetro é suprimido por um filtro simples com fator 0,15 e uma banda morta de 2 graus; sem a banda morta, o servo fica dando trancos no lugar. Tratamos das outras causas de tremida em detalhes em problema de servo tremendo. No Uno, a biblioteca Servo usa o Timer1, então analogWrite() não funciona nos pinos D9 e D10 enquanto houver um servo ligado.

MG90S com ESP32: controle pelo celular com um slider

A biblioteca Servo padrão do Arduino não funciona no ESP32; instale a biblioteca ESP32Servo pelo Gerenciador de Bibliotecas. Ela funciona com as versões 2.x e 3.x do core do ESP32, recebe o período com setPeriodHertz(50) e não aceita limites fora de 500–2500 µs. A saída de sinal do ESP32 é de 3,3 V, e praticamente todo MG90S a lê sem problema. O código abaixo conecta o ESP32 à sua rede Wi-Fi; abra o endereço IP mostrado no Monitor Serial em um celular na mesma rede e você verá um slider; no instante em que você o soltar, o servo gira para aquele ângulo.

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 o ESP32 liga o Wi-Fi, ele puxa por um instante até 250 mA; se a corrente de partida do servo cair na mesma linha USB, a placa mostra "Brownout detector was triggered" e reinicia. Alimente o servo por uma fonte de 5 V separada e ligue os GNDs; os detalhes estão em erro de brownout no ESP32. GPIO 13, 18, 19, 23, 25, 26 e 27 são boas escolhas para o sinal; não use os GPIO 6–11, ligados à flash, nem os 34–39, que são só entrada.

MG90S com Raspberry Pi Pico (MicroPython)

Na Raspberry Pi Pico você não precisa de biblioteca extra: define o PWM em 50 Hz e passa a largura de pulso em nanossegundos com duty_ns(). A pequena classe MicroServo abaixo guarda os valores de calibração de cada servo e anda um grau por vez para um movimento suave. No exemplo, o punho de um braço robótico está no GP15 e a garra no GP14. Na Pico, esses dois pinos compartilham a mesma fatia de PWM (slice 7), portanto a mesma frequência; tudo bem, porque os dois usam 50 Hz, mas se você colocar outro pino da mesma fatia em 1 kHz para o brilho de um LED, o servo também sai do eixo. Para dois servos, use uma fonte externa de 5 V em vez do VBUS e ligue os GNDs.

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 em um braço robótico: para qual junta ele serve?

Braços robóticos pequenos de 4 eixos feitos de acrílico ou impressão 3D geralmente usam quatro micro servos, e nesses braços o MG90S dura muito mais que o SG90: quando o braço bate em algo ou a garra é forçada com a mão, as engrenagens plásticas são as primeiras a quebrar. Em um braço maior, o MG90S só é usado nas juntas da ponta. A conta é simples: multiplique o peso de cada parte depois da junta pela distância até o eixo dela e some tudo. Uma garra de 40 g a 6 cm e um objeto de 50 g a 8 cm colocam 0,04 × 6 + 0,05 × 8 = 0,64 kg·cm no servo do punho, abaixo do limite seguro do MG90S de cerca de 1 kg·cm em 5 V.

JuntaCarga típicaO MG90S serve?
Base (rotação)Baixa se o peso do braço estiver sobre um rolamentoSim em braços pequenos, MG996R nos grandes
OmbroA maior, 2–5 kg·cmSó em braços muito leves; geralmente MG996R
CotoveloMédia, 1–3 kg·cmSim em braços curtos
PunhoBaixa, 0,3–1 kg·cmSim, ideal
GarraBaixa, mas com risco de apertar sem pararSim; limite o ângulo de fechamento ao objeto

O erro mais comum na garra é mandar o servo além do ângulo em que ele agarra o objeto. Como não consegue chegar ao alvo, o servo puxa corrente de travamento o tempo todo, esquenta e, em poucos minutos, o motor ou a placa de controle podem se danificar. Ajuste o ângulo de fechamento até o ponto em que as garras mal encostam no objeto, ou recue o ângulo alguns graus depois que ele segurar. O cálculo completo de torque e como montar um braço de 6 eixos estão no guia braço robótico com Arduino; se você quiser controlar mais de seis servos por uma placa, um driver de servo PCA9685 facilita o trabalho.

Ideias de projetos com MG90S

  • Suporte pan-tilt para câmera: gire um módulo ESP32-CAM na horizontal e na vertical com dois servos MG90S; as engrenagens metálicas aguentam a vibração.
  • Radar com Arduino: varra um sensor HC-SR04 de 0 a 180 graus com um MG90S e desenhe uma tela de radar; a montagem está em projeto de radar com Arduino.
  • Lixeira inteligente: uma lixeira inteligente que abre uma tampa leve quando a mão se aproxima.
  • Alimentador automático de pets: um alimentador de pets que abre e fecha uma pequena portinhola em horários definidos.
  • Robô que desvia de obstáculos: um servo de pescoço que gira o sensor de distância para a esquerda e para a direita; veja o guia robô que desvia de obstáculos.
  • Mini rastreador solar: ache a direção da luz com dois LDRs e gire um painel pequeno com um MG90S; detalhes em rastreador solar.
  • Tarefas que pedem rotação contínua: para uma roda ou uma esteira, use um servo de 360 graus em vez do MG90S.

Erros comuns e como resolver

SintomaCausa provávelSolução
O servo fica alguns graus aquém em uma pontaA faixa padrão de 544–2400 µsEscreva attach(9, 500, 2400) e calibre
Ele zumbe e esquenta na pontaO pulso passa do limite mecânicoEstreite para os valores MIN e MAX que você achou
O Arduino reinicia quando o servo se moveO servo é alimentado pelo USB via pino 5VFonte externa de 5 V, GND comum e capacitor de 470 µF
Ele treme paradoFonte fraca, fios longos e finos ou ruído do potenciômetroFios grossos, capacitor, filtro e banda morta
Nenhuma resposta, ou movimento aleatórioO GND da fonte externa não está ligado ao ArduinoLigue o negativo da fonte no GND do Arduino
Estalos com carga, o eixo escorregaUm dente de engrenagem quebrou ou o parafuso do braço está soltoTroque o jogo de engrenagens, aperte o parafuso central
Torque bem menor que o esperado, o servo pesa 9 gUma cópia com engrenagens plásticasPese o servo: um MG90S original tem cerca de 13–14 g
O servo dá um pulo ao ligarO attach() envia 1500 µs como primeiro pulsoDê o pulso inicial com writeMicroseconds() antes do attach()
Se o servo não precisa segurar carga, corte o sinal com servo.detach() quando ele chegar ao alvo; o servo fica em silêncio e quase não consome corrente. O torque de retenção some junto com o sinal, então não use detach nas juntas de um braço que sustentam carga. Forçar o eixo com a mão pode não quebrar engrenagens metálicas, mas força o motor e o potenciômetro internos; gire o braço sempre com cuidado e com o servo desligado.

O MG90S é a escolha certa para qualquer projeto que queira um servo mais resistente e um pouco mais forte sem sair do tamanho de um SG90. Lembre as regras: fonte externa de 5 V para qualquer coisa além de cargas leves, GND comum, capacitor perto do servo, faixa de pulso que começa em 500–2400 µs e é estreitada pela calibração, e ângulo de fechamento limitado nas garras. No app BlueGrays você encontra controle de servo com potenciômetro e joystick, uma fechadura RFID com servo no ESP32 e um projeto de coreografia com 32 servos, cada um com esquema de ligação passo a passo e código pronto.

Perguntas frequentes

Qual a diferença entre o MG90S e o SG90?

Eles têm o mesmo tamanho e a mesma ligação, mas o MG90S tem engrenagens metálicas e dá 2,2 kg·cm de torque em 6 V, enquanto as engrenagens plásticas do SG90 dão cerca de 1,8 kg·cm e espanam fácil com impactos. O MG90S pesa cerca de 13,4 g contra os 9 g do SG90 e consome um pouco mais de corrente quando travado. No código não há diferença; os dois funcionam com a mesma biblioteca Servo.

Quanto peso um servo MG90S consegue levantar?

O torque de travamento do MG90S é de 1,8 kg·cm em 4,8 V e 2,2 kg·cm em 6 V, então a 1 cm do eixo ele mal segura cerca de 2 kg. Para uso contínuo, conte com metade do torque: cerca de 200 g na ponta de um braço de 5 cm e cerca de 100 g na ponta de um braço de 10 cm.

Posso alimentar um MG90S pelo pino 5V do Arduino?

Em testes sem carga, um único MG90S funciona pelo pino 5V do Arduino. Mas, quando o servo é forçado, uma corrente perto de 1 A passa do limite de 500 mA do USB e o Arduino reinicia. Em projetos com carga ou vários servos, use uma fonte externa de 5 V e ligue os GNDs.

O MG90S é de 180 ou de 360 graus?

O MG90S padrão gira cerca de 180 graus; o curso completo geralmente pede pulsos de 500–2400 µs, e os limites variam de unidade para unidade. Também são vendidas versões de rotação contínua de 360 graus, mas nelas você controla velocidade e sentido, não o ângulo.

Por que o meu servo MG90S treme ou zumbe?

A causa mais comum é uma fonte fraca: um servo alimentado pelo USB derruba a tensão ao partir. Se ele zumbe nas pontas, a faixa de pulso passa do limite mecânico, então estreite-a calibrando. Se treme no controle por potenciômetro, filtre a leitura e acrescente uma banda morta de 1–2 graus.

O MG90S funciona com ESP32 e sinal de 3,3 V?

Sim. A placa de controle do MG90S lê um sinal de 3,3 V sem problema; basta a biblioteca ESP32Servo no ESP32 ou a classe PWM do MicroPython na Pico. A alimentação do servo continua sendo de 5 V; não o alimente pelo pino de 3,3 V.

Ver todos os projetos
Uso de servo motor
AR-35Iniciante
Premium

Uso de servo motor

O braço de um pequeno servo motor gira para três posições em sequência: o início, o meio e o fim do percurso, esperando dois segundos em cada parada.

4.7(48)
67
Uso de servo motor com potenciômetro
AR-36Iniciante
Premium

Uso de servo motor com potenciômetro

Conforme você gira o botão do potenciômetro, o braço do servo motor gira junto: uma extremidade do botão corresponde a zero grau, e a outra, a meia volta.

4.6(37)
53
Controle de servos com joystick
AR-60Intermediário
Premium

Controle de servos com joystick

Controle dois motores com um joystick, como ao girar uma câmera de segurança. Empurre a alavanca para os lados e o servo motor inferior gira lentamente; mova para cima ou para baixo e o servo…

4.7(42)
58
Servo motor com ESP32 (controle por potenciômetro)
ES-16Intermediário
Premium

Servo motor com ESP32 (controle por potenciômetro)

Neste projeto, controlamos um servo motor SG90 com um potenciômetro. Ajustamos o ângulo do servo mapeando o valor analógico lido do potenciômetro para a faixa de 0 a 180 graus. A biblioteca ESP32Servo gera sinais para o servo nos GPIOs do ESP32 adequados e capazes de operar como saída; este projeto usa o GPIO 18. Esse é um método básico de controle para braços robóticos, estabilizadores de câmera e mecanismos de portas automáticas.

4.3(29)
42
Fechadura RFID com ESP32 (RC522 + servo + OLED + buzzer + LED)
ES-35Avançado
Premium

Fechadura RFID com ESP32 (RC522 + servo + OLED + buzzer + LED)

Vamos montar uma fechadura inteligente com ESP32, módulo RFID RC522, servo motor SG90, display OLED SSD1306, buzzer ativo e 2 LEDs. Ao ler um cartão, seu UID é comparado à lista de cartões autorizados definida no código. Se estiver autorizado, o servo motor gira para abrir a fechadura (LED verde + 2 bipes curtos), que trava novamente após 5 segundos. Com um cartão não autorizado, o LED vermelho acende, 3 bipes rápidos soam e o UID lido aparece no OLED.

4.8(9)
16
Coreografia em círculo: animações com 32 servos
AR-97Avançado
Premium

Coreografia em círculo: animações com 32 servos

Um projeto de animação visual com 32 servo motores dispostos em círculo e controlados por um Arduino Mega. Os servos são gerenciados em um único array e conectados aos pinos 22–53 do Mega. Eles executam quatro sequências de movimento: uma vibração caótica em que todos vão para ângulos aleatórios, uma varredura sincronizada em que todos se movem ao mesmo tempo, uma onda que gira suavemente pelo círculo e, por fim, uma agulha de bússola que oscila de um lado para o outro.

4.5(40)
62
Robô que desvia de obstáculos
AR-81Avançado
Premium

Robô que desvia de obstáculos

Que tal construir um veículo inteligente que encontra seu próprio caminho? O robô que desvia de obstáculos monitora o ambiente constantemente com o sensor ultrassônico na parte da frente.

5.0(38)
49