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

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ística | SG90 | MG90S | MG996R |
|---|---|---|---|
| Tensão de operação | 4,8–6 V | 4,8–6 V | 4,8–7,2 V |
| Engrenagens | Plástico | Metal | Metal |
| Torque (4,8 V) | Cerca de 1,8 kg·cm | Cerca de 1,8 kg·cm | Cerca de 9,4 kg·cm |
| Corrente em movimento | 100–250 mA | 150–300 mA | 500–900 mA |
| Corrente de travamento (stall) | Cerca de 650–750 mA | Cerca de 0,7–1 A | Cerca de 2,5 A |
| Fonte recomendada (um servo) | 5 V 1 A | 5 V 1 A | 6 V 3 A |
Sintomas e causas prováveis
| Sintoma | Causa provável | O que fazer primeiro |
|---|---|---|
| O servo zumbe o tempo todo e treme levemente quando parado | Sinal com ruído, leitura instável do potenciômetro, servo forçando contra um limite mecânico | Adicione 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 move | A 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ória | Sem GND comum, ou o fio de sinal está solto | Ligue o GND da fonte externa ao GND do Arduino |
| O servo dá um salto ao ligar | O comando de 90 graus no attach(), pinos de boot no ESP32 | Defina um ângulo inicial, escolha um pino seguro como o GPIO 18 no ESP32 |
| O servo treme só quando outro módulo está funcionando | Uma biblioteca desativa as interrupções, ou há conflito de timer | Encontre a biblioteca em conflito, use um driver PCA9685 se necessário |
| O servo força e esquenta em uma das extremidades | A faixa de pulsos ultrapassa o limite mecânico do servo | Calibre a faixa de pulsos com attach(pin, min, max) |
| Um servo de 360 graus gira devagar quando deveria parar | O ponto central (cerca de 1,500 µs) saiu do ajuste | Gire 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.
Ligação correta: alimentação externa e GND comum
| Fio do servo | Arduino Uno | ESP32 | Raspberry Pi Pico | Fonte externa de 5–6 V |
|---|---|---|---|---|
| Marrom / preto (GND) | GND | GND | GND | Negativo (-) |
| Vermelho (V+) | Não ligar | Não ligar | Não ligar | Positivo (+) |
| Laranja / amarelo (sinal) | D9 | GPIO 18 | GP15 | Não ligar |
| GND da fonte externa | GND (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.
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.
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.
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 / comando | Para 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:
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.
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
- 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.
- 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”.
- 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.
- 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.
- Encurte o fio de sinal, adicione um resistor em série de 220–470 Ω se necessário e deixe firmes os contatos da protoboard.
- 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.
- 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.
- 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.
Projetos para montar depois desta leitura
Ver todos os projetos
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.

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.

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…

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.

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.

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.

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.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

