Guias · 14 min de leitura

Servo motor tremendo: como resolver no Arduino, ESP32 e Pico

Seu servo motor treme, gira sozinho ou faz o Arduino reiniciar? Resolva com a fonte de alimentação certa, GND comum, capacitores e os ajustes de PWM no ESP32 e no Pico.

A tremedeira do servo motor é um dos defeitos mais comuns e mais confusos em projetos com Arduino: o servo zumbe e treme onde deveria ficar parado, gira sozinho sem nenhum comando ou, no instante em que se move, o Arduino reinicia e o código começa do zero. A boa notícia é que a maioria desses sintomas não significa que o servo está com defeito; eles vêm de cinco causas básicas: alimentação insuficiente, falta de GND comum, falta de capacitor, ruído no sinal ou conflito de bibliotecas.

Neste guia explicamos por que cada causa acontece, como detectá-la com um multímetro e como resolvê-la de forma definitiva. Você vai encontrar cálculos de corrente para os servos mais comuns (SG90, MG90S e MG996R), a ligação correta, um código para Arduino que elimina a tremedeira por software, ajustes de PWM com LEDC no ESP32 e uma solução em MicroPython para o Raspberry Pi Pico. Se você ainda não conhece o básico de como um servo funciona, dê uma olhada antes em O que é servo motor?.

Problema de tremedeira no servo motor SG90
Micro servo SG90: fio marrom GND, vermelho alimentação, laranja sinal. A maioria dos problemas de tremedeira se resume a como esses três fios são alimentados.

Por que o servo treme? Entendendo como ele funciona

Dentro de um servo de hobby há um pequeno motor CC, uma caixa de engrenagens, um potenciômetro preso ao eixo de saída e um circuito de controle. O Arduino envia ao servo um pulso a cada 20 milissegundos (50 Hz); a largura do pulso define o ângulo desejado: cerca de 0,5–1 ms significa 0 grau, 1,5 ms significa 90 graus e 2–2,4 ms significa 180 graus. O circuito de controle compara esse pulso com a posição real que lê no potenciômetro e, se houver diferença, aciona o motor para corrigi-la. Por causa dessa malha fechada, o servo trata cada pequena variação na largura do pulso como um novo comando. Se o pulso desviar alguns microssegundos, se a tensão de alimentação cair ou se até um pouco de interferência for captada, o servo fica se corrigindo o tempo todo; esse é o zumbido que você ouve e a tremedeira que você vê. Servos como o SG90 têm uma zona morta (deadband) de cerca de 10 µs; quando a variação no sinal passa disso, o motor começa a se mover.

CaracterísticaSG90MG90SMG996R
Tensão de operação4,8–6 V4,8–6 V4,8–7,2 V
EngrenagensPlásticoMetalMetal
Torque (4,8 V)Cerca de 1,8 kg·cmCerca de 1,8 kg·cmCerca de 9,4 kg·cm
Corrente em movimento100–250 mA150–300 mA500–900 mA
Corrente de travamento (stall)Cerca de 650–750 mACerca de 0,7–1 ACerca de 2,5 A
Fonte recomendada (um servo)5 V 1 A5 V 1 A6 V 3 A

Sintomas e causas prováveis

SintomaCausa provávelO que fazer primeiro
O servo zumbe o tempo todo e treme levemente quando paradoSinal com ruído, leitura instável do potenciômetro, servo forçando contra um limite mecânicoAdicione um filtro e uma zona morta no código, reduza a faixa de ângulo para 5–175 graus
O Arduino reinicia quando o servo se moveA tensão de alimentação despenca (brownout)Alimente o servo com uma fonte externa de 5–6 V
O servo gira sozinho de forma aleatóriaSem GND comum, ou o fio de sinal está soltoLigue o GND da fonte externa ao GND do Arduino
O servo dá um salto ao ligarO comando de 90 graus no attach(), pinos de boot no ESP32Defina um ângulo inicial, escolha um pino seguro como o GPIO 18 no ESP32
O servo treme só quando outro módulo está funcionandoUma biblioteca desativa as interrupções, ou há conflito de timerEncontre a biblioteca em conflito, use um driver PCA9685 se necessário
O servo força e esquenta em uma das extremidadesA faixa de pulsos ultrapassa o limite mecânico do servoCalibre a faixa de pulsos com attach(pin, min, max)
Um servo de 360 graus gira devagar quando deveria pararO ponto central (cerca de 1,500 µs) saiu do ajusteGire o trimpot do servo ou faça o ajuste fino do valor de parada

Causa 1: alimentação insuficiente e Arduino reiniciando

A causa número um da tremedeira e das reinicializações é alimentar o servo pelo pino 5V do Arduino. Um SG90 consome só alguns miliampères parado, mas nos primeiros milissegundos de movimento, principalmente com carga ou se o eixo bater em um obstáculo, pode passar de 650 mA. Quando um Arduino Uno é alimentado pela USB, a linha de 5 V fica limitada pela porta USB do computador e pelo fusível rearmável de 500 mA da placa. Durante um consumo repentino de corrente, a linha de 5 V pode cair abaixo de 4 V. Mesmo que a proteção de brownout do ATmega328P só entre em ação por volta de 2,7 V, essa queda já bagunçou o circuito de controle do servo, os sensores e a comunicação serial. Se a tensão despencar o suficiente, o microcontrolador reinicia, o código roda de novo a partir do setup(), o servo volta à posição inicial, puxa corrente outra vez e você fica preso em um ciclo. Esse é o caso clássico do Arduino reiniciando sozinho.

Confirmar o problema é fácil: ligue um multímetro entre 5V e GND e movimente o servo. Se a tensão medida cair abaixo de 4,6 V, ou se o valor ficar pulando enquanto o servo se move, a causa é a alimentação. Para resolver, alimente os servos com uma fonte separada e faça o cálculo de corrente com base na corrente de travamento: para um braço robótico com quatro SG90, 4 × 0,7 A = 2,8 A, então faz sentido usar um adaptador de pelo menos 5 V 3 A ou um conversor buck LM2596. Com servos potentes como o MG996R, conte com 2,5 A por servo. Para funcionar com bateria, 4 pilhas AA (cerca de 6 V com alcalinas, 4,8 V com NiMH) ou 6 V obtidos de um pack Li-ion 2S com abaixador funcionam bem; com a calculadora Autonomia da bateria você vê com antecedência quanto tempo o seu projeto vai durar.

Não alimente o servo com uma bateria de 9 V nem pelo pino VIN do Arduino. Uma bateria de 9 V não consegue fornecer a corrente momentânea do servo, e a tensão dela está acima do limite de 6 V do SG90, então pode danificar o circuito de controle do servo. Para testar um único SG90 pequeno sem carga, o pino 5V muitas vezes basta, mas qualquer aplicação com dois ou mais servos ou com carga precisa de uma fonte externa.

Ligação correta: alimentação externa e GND comum

Fio do servoArduino UnoESP32Raspberry Pi PicoFonte externa de 5–6 V
Marrom / preto (GND)GNDGNDGNDNegativo (-)
Vermelho (V+)Não ligarNão ligarNão ligarPositivo (+)
Laranja / amarelo (sinal)D9GPIO 18GP15Não ligar
GND da fonte externaGND (comum)GND (comum)GND (comum)Negativo (-)

A linha mais importante desta tabela é a última. O servo mede o pulso no fio de sinal em relação ao próprio GND. Se o negativo da fonte externa não estiver ligado ao GND do Arduino, o sinal fica sem ponto de referência; o servo interpreta tensões parasitas nos fios e interferências vindas da rede elétrica como pulsos aleatórios e começa a girar sozinho. Explicamos em detalhes por que um terra comum é essencial no artigo GND e terra comum. Se você estiver montando na protoboard, o módulo de alimentação MB102 é uma forma prática de alimentar a linha dos servos; porém, o regulador dele fica limitado a cerca de 700–800 mA na prática, então serve no máximo para um ou dois servos pequenos.

Nunca ligue o positivo (+) da fonte externa ao pino 5V do Arduino; as duas fontes diferentes trabalhariam uma contra a outra e poderiam mandar corrente de volta para a porta USB. A única linha que você une é o GND. Um bom hábito é ligar primeiro o GND, depois a alimentação e, por último, o fio de sinal.

Adicionando um capacitor: qual valor e onde?

Mesmo com uma fonte externa, toda vez que o motor do servo arranca surgem pulsos de corrente que duram alguns milissegundos. Se os fios forem finos e compridos, esses pulsos criam quedas momentâneas na tensão; o circuito de controle do servo fica instável nessas quedas e a tremedeira começa. A solução é adicionar um reservatório local de energia na linha de alimentação do servo: o mais perto possível do conector do servo, ligue um capacitor eletrolítico de 470–1000 µF entre positivo e negativo, com um capacitor cerâmico de 100 nF em paralelo. O eletrolítico supre a demanda de corrente grande e de curta duração, enquanto o cerâmico filtra o ruído de alta frequência gerado pelas escovas do motor. A tensão nominal do capacitor deve ser pelo menos 1,5–2 vezes a tensão de alimentação; para uma linha de servo de 5–6 V, um capacitor de 10 V ou 16 V é adequado. Com vários servos, colocar um 470 µF separado ao lado de cada servo funciona melhor do que um único capacitor grande.

A perna mais longa do capacitor eletrolítico é o positivo (+), e a perna do lado da faixa no corpo é o negativo (-). Um capacitor ligado invertido esquenta e pode estourar. Para decifrar marcações como “104” nos capacitores cerâmicos, você pode usar a calculadora Código do capacitor; 104 significa 100 nF.

Ruído no sinal e organização dos fios

  • Mantenha os fios curtos: procure não deixar o fio de sinal do servo com mais de 50 cm. Se precisar estendê-lo, passe os fios de sinal e GND trançados juntos (par trançado).
  • Adicione um resistor em série: colocar um resistor de 220–470 Ω entre o pino da placa e o fio de sinal do servo reduz reflexões e oscilações em linhas longas; ele também protege o pino contra curtos-circuitos.
  • Separe alimentação e sinal: não passe fios que carregam corrente de motor ou relé em paralelo com a linha de sinal do servo; se precisarem se cruzar, cruze-os em ângulo reto.
  • Verifique o contato da protoboard: jumpers frouxos e contatos gastos da protoboard causam interrupções momentâneas; se a tremedeira muda quando você encosta em um fio, a causa é mau contato.
  • Ruído do potenciômetro: se você controla o servo com um potenciômetro, o valor do analogRead oscila algumas unidades e essa oscilação vai direto para o ângulo. Um capacitor de 100 nF entre o cursor do potenciômetro e o GND, mais um filtro no código, resolve isso.
  • Sinal de 3,3 V: o ESP32 e o Pico geram pulsos de 3,3 V. A maioria dos servos, como o SG90 e o MG996R, reconhece isso sem problemas; para o servo raro que se comporta de forma instável, dá para usar um conversor de nível lógico.

Evitando a tremedeira no código: filtro e zona morta

Mesmo com o hardware em ordem, o software pode fazer o servo tremer. Os erros mais comuns são chamar attach() a cada passagem do loop(), mandar o valor bruto do potenciômetro direto para o write() e empurrar o servo até os limites físicos (0 ou 180 graus). Em servos baratos, o batente mecânico costuma ficar um pouco antes de 0 e 180 graus; o servo não consegue chegar ao alvo, continua forçando, zumbe e esquenta. O código abaixo toma três cuidados de uma vez: suaviza a leitura com uma média exponencial, mantém o ângulo entre 5–175 graus e só envia um novo comando ao servo quando o ângulo muda pelo menos 2 graus. Para ver os métodos de filtragem de forma mais ampla, confira o artigo filtragem de dados de sensores.

C++ (Arduino IDE)
1#include <Servo.h>
2
3const int SERVO_PIN = 9;     // servo sinyal pini / servo signal pin
4const int POT_PIN = A0;      // potansiyometre orta ucu / potentiometer wiper
5const int DEADBAND = 2;      // derece cinsinden ölü bölge / dead band in degrees
6
7Servo servo;
8float filtered = 0;          // filtrelenmiş okuma / filtered reading
9int lastAngle = -1;          // son gönderilen açı / last angle sent
10
11void setup() {
12  servo.write(90);              // attach öncesi başlangıç açısı (AVR) / start angle before attach (AVR)
13  servo.attach(SERVO_PIN);      // yalnızca bir kez / only once
14  filtered = analogRead(POT_PIN);
15}
16
17void loop() {
18  int raw = analogRead(POT_PIN);
19  filtered = filtered * 0.9 + raw * 0.1;            // üstel ortalama / exponential moving average
20  int angle = map((int)filtered, 0, 1023, 5, 175);  // sınırlara dayanma / stay away from end stops
21
22  if (lastAngle < 0 || abs(angle - lastAngle) >= DEADBAND) {
23    servo.write(angle);         // yalnızca belirgin değişimde / only on a real change
24    lastAngle = angle;
25  }
26  delay(15);
27}
Linha / comandoPara que serve
servo.write(90) (antes do attach)Faz o primeiro pulso começar em 90 graus na biblioteca Servo padrão do AVR; reduz o salto ao ligar.
filtered = filtered * 0.9 + raw * 0.1 (média exponencial)Média móvel exponencial: suprime oscilações bruscas e deixa passar as mudanças lentas. Quanto menor o coeficiente 0.1, mais forte o filtro, porém mais lenta a resposta.
map(..., 5, 175) (faixa de ângulo)Faz o servo funcionar sem forçá-lo contra os batentes mecânicos.
DEADBAND = 2 (zona morta)Não envia um novo comando se o ângulo mudou menos de 2 graus; a zona morta corta as pequenas tremidas.
delay(15) (espera)Dá tempo para o servo chegar à nova posição e limita a taxa de leitura.
attach(pin, 500, 2400) (calibração)Serve para calibrar a faixa de pulsos de acordo com os limites reais do servo; os valores padrão são 544 e 2,400 µs.
servo.detach() (soltar o servo)Interrompe os pulsos quando o servo chega ao alvo; o zumbido para, mas o servo perde o torque de retenção.

Conflitos de bibliotecas e de timers

A biblioteca Servo padrão no Arduino Uno gera os pulsos usando o Timer1 de hardware e interrupções. Esse projeto permite que um único timer controle até 12 servos, mas tem dois efeitos colaterais: não funciona junto com outra biblioteca que use o Timer1, e a precisão dos pulsos depende de as interrupções rodarem na hora certa. Qualquer código que desative as interrupções por algumas centenas de microssegundos estica o pulso que está sendo gerado naquele momento, e o servo dá um tranco. Se a tremedeira só começa quando determinado módulo entra em ação, você quase certamente está diante dessa situação.

  • analogWrite nos pinos 9 e 10: quando a biblioteca Servo está em uso, o PWM não funciona nesses dois pinos do Uno; mude qualquer LED ou driver de motor ligado a eles para o pino 3, 5, 6 ou 11.
  • Bibliotecas de RF 433 MHz: a VirtualWire e o driver RH_ASK da RadioHead também usam o Timer1 por padrão; você verá erros de compilação ou movimentos irregulares do servo. Veja os detalhes no artigo módulo RF 433 MHz.
  • Fitas NeoPixel: a Adafruit NeoPixel e a FastLED desativam as interrupções enquanto enviam dados; em uma fita longa isso dura milissegundos e o servo dá um tranco a cada atualização. Se uma WS2812B e um servo forem usados juntos, atualize a fita com menos frequência.
  • SoftwareSerial e DHT: ambos desativam as interrupções por um instante ao receber bytes ou ler o sensor; essa é uma causa frequente da tremedeira em braços com servos controlados por módulo Bluetooth.
  • A solução definitiva: use um driver de servo PCA9685, que gera os pulsos com o próprio hardware; assim, sinais sem tremedeira chegam a até 16 servos, não importa o que o Arduino esteja fazendo.

Ajustes de PWM para servo no ESP32

A biblioteca Servo padrão do Arduino não funciona no ESP32; no lugar dela você usa a biblioteca ESP32Servo ou diretamente a unidade de PWM LEDC integrada. Como o LEDC é baseado em hardware, ele não é afetado por interrupções e gera pulsos muito estáveis; a única exigência é ajustar a frequência para 50 Hz e a resolução para um valor suficiente. Com resolução de 14 bits, o período de 20 ms é dividido em 16.384 passos; cada passo tem cerca de 1,22 µs, precisão mais do que suficiente para um servo. Escolhemos 14 bits porque chips mais novos, como o ESP32-S3 e o ESP32-C3, também suportam esse valor. Como as funções do LEDC mudaram na versão 3.x do core ESP32 para Arduino, o código abaixo foi escrito para compilar com as duas versões:

C++ (Arduino IDE)
1// ESP32 Arduino core 2.x ve 3.x uyumlu / compatible with ESP32 Arduino core 2.x and 3.x
2const int SERVO_PIN = 18;      // güvenli bir GPIO / a safe GPIO
3const int PWM_FREQ = 50;       // 50 Hz = 20 ms periyot / 20 ms period
4const int PWM_BITS = 14;       // ESP32, S3 ve C3 destekler / supported by ESP32, S3 and C3
5const int MIN_US = 500;        // 0 derece darbesi / 0 degree pulse
6const int MAX_US = 2400;       // 180 derece darbesi / 180 degree pulse
7
8#if ESP_ARDUINO_VERSION_MAJOR < 3
9const int PWM_CHANNEL = 0;     // 2.x için LEDC kanalı / LEDC channel for 2.x
10#endif
11
12uint32_t usToDuty(uint32_t us) {
13  return us * ((1UL << PWM_BITS) - 1) / 20000UL;  // mikrosaniyeyi duty değerine çevir / convert microseconds to duty
14}
15
16void servoWriteUs(uint32_t us) {
17#if ESP_ARDUINO_VERSION_MAJOR >= 3
18  ledcWrite(SERVO_PIN, usToDuty(us));     // 3.x: pin numarası / pin number
19#else
20  ledcWrite(PWM_CHANNEL, usToDuty(us));   // 2.x: kanal numarası / channel number
21#endif
22}
23
24void servoWriteAngle(int angle) {
25  angle = constrain(angle, 0, 180);
26  servoWriteUs(map(angle, 0, 180, MIN_US, MAX_US));
27}
28
29void setup() {
30#if ESP_ARDUINO_VERSION_MAJOR >= 3
31  ledcAttach(SERVO_PIN, PWM_FREQ, PWM_BITS);
32#else
33  ledcSetup(PWM_CHANNEL, PWM_FREQ, PWM_BITS);
34  ledcAttachPin(SERVO_PIN, PWM_CHANNEL);
35#endif
36  servoWriteAngle(90);           // başlangıç konumu / start position
37}
38
39void loop() {
40  for (int a = 30; a <= 150; a++) {   // yumuşak tarama / smooth sweep
41    servoWriteAngle(a);
42    delay(15);
43  }
44  for (int a = 150; a >= 30; a--) {
45    servoWriteAngle(a);
46    delay(15);
47  }
48}

Há mais duas armadilhas específicas do ESP32. A primeira são os pinos de boot: pinos como GPIO 0, 2, 12, 14 e 15, além dos pinos 1 e 3 da porta serial, podem gerar pulsos curtos durante a inicialização; se o servo estiver nesses pinos, ele dá um salto a cada reset. GPIO 13, 18, 19, 23, 25, 26, 27, 32 e 33 são escolhas seguras para servos; os pinos 34–39 são somente entrada e não conseguem controlar um servo. A segunda é a sensibilidade da alimentação: com o Wi-Fi ligado, o ESP32 já puxa pulsos de corrente acima de 300 mA, e se o servo for alimentado pela mesma linha você verá a mensagem "Brownout detector was triggered" no Monitor Serial. Explicamos a solução desse erro no artigo brownout e Guru Meditation no ESP32; em resumo, alimente o servo com uma fonte separada e una os GNDs.

Servo no Raspberry Pi Pico (MicroPython)

Todo pino GPIO do Raspberry Pi Pico pode gerar PWM por hardware; o chip tem 8 fatias (slices) de PWM e 16 canais no total. No MicroPython, depois de ajustar a frequência do objeto PWM para 50 Hz, você pode informar a largura do pulso diretamente em nanossegundos com duty_ns(); isso é muito mais seguro do que ficar mexendo com porcentagens ou cálculos de duty em 16 bits. O código abaixo controla o servo no GP15 com o potenciômetro no GP26 e aplica exatamente a mesma lógica de filtro e zona morta do exemplo para Arduino. A saída 3V3 do Pico não serve para alimentar um servo, nem em tensão nem em corrente; alimente o servo com uma fonte externa de 5 V e deixe o GND comum.

MicroPython
1from machine import Pin, PWM, ADC
2import time
3
4servo = PWM(Pin(15))          # servo sinyali GP15 / servo signal on GP15
5servo.freq(50)                # 50 Hz = 20 ms
6pot = ADC(26)                 # potansiyometre GP26 (ADC0) / potentiometer on GP26 (ADC0)
7
8MIN_US = 500                  # 0 derece / 0 degrees
9MAX_US = 2400                 # 180 derece / 180 degrees
10DEADBAND = 2                  # ölü bölge (derece) / dead band (degrees)
11
12def write_angle(angle):
13    angle = max(5, min(175, angle))              # sınırlara dayanma / stay away from end stops
14    us = MIN_US + (MAX_US - MIN_US) * angle // 180
15    servo.duty_ns(us * 1000)                     # mikrosaniye -> nanosaniye / microseconds -> nanoseconds
16
17filtered = pot.read_u16()
18last = -100
19write_angle(90)               # başlangıç konumu / start position
20
21while True:
22    filtered = filtered * 0.9 + pot.read_u16() * 0.1   # üstel ortalama / exponential moving average
23    angle = int(filtered * 180 / 65535)
24    if abs(angle - last) >= DEADBAND:
25        write_angle(angle)
26        last = angle
27    time.sleep_ms(20)

Checklist passo a passo

  1. Desconecte o servo da placa e alimente-o só com uma fonte externa de 5–6 V; confira se a corrente da fonte cobre o número de servos × corrente de travamento.
  2. Ligue o GND da fonte externa ao GND do Arduino, ESP32 ou Pico; esse único fio acaba com a maioria dos problemas de “girar sozinho”.
  3. Com o servo em movimento, meça a tensão de alimentação com um multímetro; se cair abaixo de 4,6 V, use uma fonte mais forte ou fios mais grossos.
  4. Adicione um capacitor eletrolítico de 470–1000 µF e um cerâmico de 100 nF ao lado do conector do servo e confira a polaridade.
  5. Encurte o fio de sinal, adicione um resistor em série de 220–470 Ω se necessário e deixe firmes os contatos da protoboard.
  6. No código, confira se o attach() é chamado só no setup(), se o ângulo fica entre 5–175 graus e se você usa filtro e zona morta.
  7. Se o servo treme quando outro módulo funciona, encontre o conflito desativando as bibliotecas uma de cada vez; passe para um PCA9685 se necessário.
  8. Se ainda tremer, teste trocando por outro servo; servos com potenciômetro gasto ou engrenagens quebradas tremem em qualquer condição.

Cuidados em projetos com servo

  • Braço robótico: em um braço robótico com quatro ou seis servos, não mova todos os servos ao mesmo tempo; escalone os comandos com 100–200 ms de intervalo para que os picos de corrente não se somem.
  • Projeto de radar: em projetos que fazem varredura contínua, como um radar com Arduino, gire o servo grau a grau e espere 15–30 ms a cada passo; saltos grandes e bruscos significam tanto tremedeira quanto pico de corrente.
  • Cargas pesadas: para trabalhos com carga, como uma fechadura de porta ou um suporte de câmera, use um MG996R com engrenagens de metal em vez de um SG90 e escolha uma fonte de pelo menos 3 A.
  • Servos de rotação contínua: se servos de 360 graus como o FS90R se arrastam no ponto de parada, isso não é tremedeira, e sim problema de calibração; faça o ajuste fino do valor de parada em torno de 1,500 µs.
  • Projetos com bateria: soltar o servo com detach() quando o movimento termina para o zumbido e aumenta a autonomia da bateria; é muito eficaz se o mecanismo não escorrega com o próprio peso.

A tremedeira do servo pode parecer complicada no começo, mas quase sempre se resolve na mesma ordem: primeiro a alimentação, depois o GND comum, em seguida o capacitor, a fiação e, por último, o software. Seguindo essa ordem, raramente você vai precisar trocar o próprio servo. Para os detalhes dos cálculos de alimentação, confira também o guia alimentação do Arduino. No app BlueGrays você encontra, passo a passo, os esquemas do circuito e os códigos de projetos como controle de servo com potenciômetro, servo com joystick, servo com ESP32 e fechadura RFID, para colocar em prática na hora o que aprendeu aqui.

Perguntas frequentes

Por que o servo motor treme?

A causa mais comum da tremedeira é uma tensão de alimentação insuficiente ou instável; quando o servo é alimentado pelo pino 5V do Arduino, a tensão cai nos consumos repentinos de corrente e o circuito de controle fica instável. A falta de GND comum, um sinal com ruído, valores instáveis do potenciômetro e forçar o servo contra o limite mecânico também podem causar o problema. Uma fonte externa de 5–6 V, GND comum e um capacitor de 470–1000 µF resolvem a maioria dos casos.

Por que meu servo motor gira sozinho?

Se o servo gira sem nenhum comando, geralmente a linha de sinal está sem referência: o GND da fonte externa não está ligado ao GND do Arduino, ou o fio de sinal está frouxo. Nesse caso, o servo interpreta a interferência nos fios como pulsos. Nos servos de 360 graus, a rotação lenta vem do desajuste da calibração do ponto central (cerca de 1,500 µs) e é corrigida com o trimpot do servo.

Por que meu Arduino reinicia quando o servo funciona?

Ao começar a se mover, um servo pode puxar centenas de miliampères, e mais de 2 A nos servos grandes. Se essa corrente vem da linha USB ou do regulador do Arduino, os 5 V despencam e o microcontrolador reinicia. Quando você alimenta o servo com uma fonte separada e une apenas os GNDs, as reinicializações param.

Quantos µF de capacitor devo usar no servo?

Para um único SG90 ou MG90S, 470 µF perto do conector do servo é um bom começo; para servos grandes como o MG996R, use um capacitor eletrolítico de 1000 µF. Adicionar um capacitor cerâmico de 100 nF ao lado também filtra o ruído de alta frequência. A tensão nominal do capacitor deve ser de pelo menos 10 V para uma linha de 5–6 V, e a polaridade precisa estar correta.

Posso alimentar um servo motor pelo pino 5V do Arduino?

Para testar um único SG90 sem carga, o pino 5V muitas vezes basta, mas não é uma solução confiável. A linha USB é limitada a cerca de 500 mA e um servo travado ultrapassa esse valor. Se você usa dois ou mais servos, um servo com carga ou um MG996R, use sempre uma fonte externa.

Por que meu servo treme ou não funciona no ESP32?

A biblioteca Servo padrão do Arduino não funciona no ESP32; você precisa usar a biblioteca ESP32Servo ou o PWM LEDC ajustado para 50 Hz. Ligar o servo em pinos de boot como GPIO 0, 2, 12 ou 15 causa saltos no reset, e alimentá-lo pela própria linha do ESP32 causa erros de brownout. Um pino seguro como o GPIO 18 e uma fonte de 5 V separada resolvem o problema.

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
Servo motor de 360 graus com motor de passo
AR-68Intermediário
Premium

Servo motor de 360 graus com motor de passo

Ensine um motor de passo comum a ir até qualquer ângulo que você quiser, ao longo de uma volta completa.

4.5(22)
33
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