Projetos com servo motor e Arduino: 15 ideias, SG90 ou MG996R
15 projetos com servo motor e Arduino: radar, braço robótico, fechadura, rastreador solar e alimentador para pets; como escolher entre SG90, MG90S e MG996R, alimentá-los e usar um PCA9685.
Projetos com servo motor e Arduino são o jeito mais fácil de fazer algo se mexer de verdade: com um único fio você passa um ângulo ao servo, ele vai até lá e fica. Neste guia reunimos 15 projetos com servo motor, de um radar ultrassônico a um braço robótico, uma fechadura com RFID, um rastreador solar e um alimentador automático para pets. Para cada projeto você encontra, em uma única tabela, qual servo escolher, quantos são necessários, se dá para acioná-los direto do Arduino ou por um driver PCA9685 e como alimentá-los.
Antes dos projetos, vamos ver as diferenças entre o SG90, o MG90S e o MG996R, como escolher a fonte de alimentação conforme o número de servos e quantos servos um Arduino Uno, um ESP32 e um Raspberry Pi Pico conseguem acionar ao mesmo tempo. Depois vêm modelos de código compilados e prontos para usar para os projetos de radar, braço robótico e rastreador solar. Se servos são novidade para você, sugerimos ler primeiro O que é um servo motor?.

Qual servo escolher: SG90, MG90S ou MG996R?
O primeiro número a conferir na hora de escolher um servo é o torque: ele é dado em kg·cm e indica quantos quilos o servo consegue segurar a 1 cm do eixo. Quanto mais longo o braço, menos ele levanta, na mesma proporção; um SG90 de 1,8 kg·cm mal segura 300 gramas na ponta de um braço de 6 cm, e não de forma contínua. O segundo ponto é o material das engrenagens: as de plástico espanam sob esforço, enquanto as de metal aguentam trancos. O terceiro é a corrente: servo grande pede fonte grande. Na prática, o SG90 serve para tampas leves e para girar sensores, o MG90S para mecanismos pequenos que trabalham com frequência ou sob carga, e o MG996R para o ombro de um braço robótico e para tampas pesadas.
| Modelo | Torque | Engrenagens | Corrente com eixo travado | Alimentação recomendada | Projeto típico |
|---|---|---|---|---|---|
| SG90 | 1,8 kg·cm (4,8 V) | Plástico | 650-750 mA | 5 V | Radar, pan-tilt, tampa pequena |
| MG90S | 1,8-2,2 kg·cm | Metal | 0,7-1 A | 5-6 V | Fechadura, garra, robô aranha |
| MG996R | 9,4-11 kg·cm | Metal, dois rolamentos | 2,5 A (6 V) | 6 V, 3 A por servo | Ombro de braço robótico, cortina, tampa pesada |
| FS90R (360°) | 1,5 kg·cm | Plástico | até 800 mA | 5 V | Rodas, base giratória |

Tabela de alimentação de servos: quantos servos, quanta corrente?
A maioria dos problemas em projetos com servo vem da alimentação, não do código. No instante em que começa a se mover, o servo puxa um pico rápido de corrente; se o pino 5V do Arduino, alimentado pela USB, não der conta, a tensão cai, a placa reinicia e o servo treme. A regra é simples: dá para ligar um único SG90 com pouca carga no pino 5V do Arduino, mas, para qualquer coisa além disso, alimente os servos com uma fonte externa de 5-6 V, ligue o negativo da fonte ao GND do Arduino e coloque um capacitor de 470-1000 µF na linha de alimentação dos servos. Para dimensionar a fonte, some as correntes de funcionamento dos servos e deixe pelo menos 50% de folga.
| Montagem | Corrente em funcionamento (aprox.) | Fonte recomendada |
|---|---|---|
| 1 × SG90, carga leve | 100-250 mA | O pino 5V do Arduino basta |
| 2 × SG90 ou MG90S | 0,3-0,6 A | Externa de 5 V, 2 A |
| 4 × MG90S (braço robótico pequeno) | 0,6-1,2 A | Externa de 5 V, 3 A |
| 1 × MG996R | 0,5-0,9 A (2,5 A travado) | 6 V, 3 A |
| 6 × MG996R (braço robótico grande) | 3-5,4 A | Fonte chaveada de 6 V, 10 A |
| 12 × MG90S (robô aranha) | 1,8-3,6 A | 5-6 V, 5 A, ou LiPo 2S com BEC de 5 A |
Acionar os servos direto ou com um PCA9685?
Acionar alguns servos direto pelos pinos do microcontrolador é o caminho mais simples. A biblioteca Servo do Arduino Uno usa o Timer1 para gerar pulsos para até 12 servos, mas, enquanto isso, o analogWrite deixa de funcionar nos pinos 9 e 10. O ESP32 dá a cada servo seu próprio canal de PWM por hardware, e o Pico tem 16 canais PWM. Quando você passa de 5 ou 6 servos, quando os pulsos começam a oscilar ou quando precisa dos pinos para outras tarefas, entra em cena a placa driver PCA9685: ela aciona 16 servos usando apenas dois pinos I2C e, como gera os pulsos com o próprio clock, tira esse peso do microcontrolador. Explicamos a montagem em detalhes no guia do driver de servo PCA9685.
| Plataforma | Biblioteca | Servos diretos | Atenção |
|---|---|---|---|
| Arduino Uno / Nano | Servo (já incluída) | Até 12 | Usa o Timer1: o analogWrite não funciona em D9 e D10 |
| Arduino Mega | Servo (já incluída) | Até 48 | Muitos servos ainda exigem alimentação externa |
| ESP32 | ESP32Servo | Até 16 | GPIO 18, 19, 21, 22, 23, 25, 26 e 27 são seguros; 34-39 são só de entrada |
| Raspberry Pi Pico | machine.PWM (MicroPython) | Até 16 | Dois pinos no mesmo slice de PWM compartilham a frequência; sem problema em 50 Hz |
| PCA9685 (com qualquer placa) | Adafruit PWM Servo Driver | 16 por placa, até 62 placas encadeadas | A alimentação dos servos entra no borne V+ da placa |
15 projetos com servo motor: servo, quantidade e forma de acionamento
| # | Projeto | Servo | Quantidade | Acionamento | Nível |
|---|---|---|---|---|---|
| 1 | Controle de ângulo com potenciômetro | SG90 | 1 | Direto | Iniciante |
| 2 | Radar ultrassônico | SG90 | 1 | Direto | Iniciante |
| 3 | Tampa de lixeira automática | MG90S | 1 | Direto | Iniciante |
| 4 | Alimentador automático para pets | MG90S ou MG996R | 1 | Direto | Intermediário |
| 5 | Fechadura com RFID ou teclado | MG90S | 1 | Direto | Intermediário |
| 6 | Termômetro de ponteiro com servo | SG90 | 1 | Direto | Iniciante |
| 7 | Cabeça giratória para robô que desvia de obstáculos | SG90 | 1 | Direto | Intermediário |
| 8 | Suporte pan-tilt de câmera com joystick | SG90 | 2 | Direto | Iniciante |
| 9 | Rastreador solar | MG90S | 2 | Direto | Intermediário |
| 10 | Cancela de passagem de nível (maquete) | SG90 | 2 | Direto | Iniciante |
| 11 | Abridor de cortina ou de ventilação por Wi-Fi | MG996R | 1 | Direto (ESP32) | Intermediário |
| 12 | Plataforma autonivelante com MPU6050 | MG90S | 2 | Direto | Avançado |
| 13 | Braço robótico de mesa com 4 eixos | MG90S ou SG90 | 4 | Direto ou PCA9685 | Intermediário |
| 14 | Braço robótico de 6 eixos | MG996R e MG90S | 6 | PCA9685 | Avançado |
| 15 | Robô aranha quadrúpede | MG90S | 12 | PCA9685 | Avançado |
Projetos com um servo (1-7)
- 1. Controle de ângulo com potenciômetro: o “hello world” dos servos. Você converte a leitura de 0-1023 do potenciômetro em 0-180 graus com map() e a escreve no servo. O código e a ligação estão em O que é um servo motor?; você vai reaproveitar a mesma lógica em todos os projetos daqui em diante.
- 2. Radar ultrassônico: um sensor de distância HC-SR04 é colado em cima de um SG90, o servo varre entre 15 e 165 graus e a distância em cada ângulo é enviada pela porta serial. Um sketch em Processing no computador transforma os dados na clássica tela verde de radar. Os detalhes estão no projeto de radar com Arduino, e o código está mais abaixo.
- 3. Tampa de lixeira automática: um HC-SR04 na frente detecta uma mão a menos de 20 cm, o servo abre a tampa e a fecha alguns segundos depois. Se a tampa for pesada, use um MG90S com engrenagens de metal no lugar do SG90; veja o guia da lixeira inteligente.
- 4. Alimentador automático para pets: em horários definidos, o servo abre por alguns segundos a portinhola sob o reservatório de ração. Um módulo RTC fornece a hora, e o tempo que a portinhola fica aberta define a porção. Alimentadores de rosca sem-fim pedem mais torque, então um MG996R ou um servo de 360 graus é a melhor escolha; veja o alimentador automático para pets.
- 5. Fechadura com RFID ou teclado: quando o cartão RFID certo é aproximado ou o código certo é digitado em um teclado matricial, o servo desliza o trinco. Como o trinco tem atrito, um MG90S com engrenagens de metal dura muito mais.
- 6. Termômetro de ponteiro com servo: prenda um ponteiro no braço do servo e coloque atrás dele um cartão com uma escala de 0-40 °C; a temperatura medida por um DHT11 é convertida em ângulo com map(). A mesma ideia serve como mostrador de umidade, de nível de som ou de número de inscritos.
- 7. Cabeça giratória para robô que desvia de obstáculos: quando o robô para, o HC-SR04 montado no servo olha para a esquerda e para a direita, e o robô vira para o lado mais livre. Esse acréscimo simples o deixa muito mais esperto do que um robô com sensor fixo; veja o robô que desvia de obstáculos.
Projetos com dois servos (8-12)
- 8. Suporte pan-tilt de câmera com joystick: dois SG90 são montados um sobre o outro: o de baixo gira na horizontal (pan) e o de cima na vertical (tilt). Os eixos X e Y de um módulo joystick são mapeados para os dois servos; em cima você pode instalar uma câmera pequena, um laser ou um sensor.
- 9. Rastreador solar: quatro LDRs medem de que lado a luz está mais forte, e dois servos giram o painel na horizontal e na vertical em direção ao ponto mais claro. O vento força o braço do painel, então servos MG90S são uma boa ideia. Os detalhes estão no guia do rastreador solar, e o código para ESP32 está mais abaixo.
- 10. Cancela de passagem de nível: para uma maquete de ferrovia ou um trabalho de escola, dois SG90 baixam e levantam as cancelas, LEDs vermelhos piscam alternadamente e um buzzer soa o aviso. Um sensor infravermelho ou um reed switch detecta o trem se aproximando; deixar o servo mais lento dá um efeito realista.
- 11. Abridor de cortina ou de ventilação por Wi-Fi: um ESP32 roda um pequeno servidor web, e tocar em um botão no celular faz um MG996R puxar o cordão da cortina ou mover uma aleta de ventilação. Por ser um MG996R, uma fonte externa de 6 V é obrigatória.
- 12. Plataforma autonivelante com MPU6050: o acelerômetro MPU6050 mede a inclinação da plataforma, e dois servos a corrigem no sentido oposto para manter a superfície nivelada. O resultado é um gimbal simples que mantém firme um copo d'água ou uma câmera pequena; uma resposta rápida exige servos MG90S e um bom filtro.
Projetos com vários servos: braço robótico e robô aranha (13-15)
- 13. Braço robótico de mesa com 4 eixos: quatro servos cuidam da base, do ombro, do cotovelo e da garra. Para braços pequenos de acrílico ou impressos em 3D, servos MG90S bastam, e os quatro podem ser acionados direto pelo Uno; os servos devem ser alimentados por uma fonte externa de 5 V 3 A. Você pode acrescentar controle manual com potenciômetros, um joystick ou movimentos gravados que se repetem; veja o braço robótico com Arduino.
- 14. Braço robótico de 6 eixos: braços maiores, de metal, usam servos MG996R na base, no ombro e no cotovelo e servos MG90S no punho e na garra. Acionar os seis por um PCA9685 organiza a fiação; uma fonte de 6 V 10 A e um código que move os servos um depois do outro, e não todos de uma vez, mantêm os picos de corrente baixos. Para a carga no ombro, consulte a tabela de torque do MG996R.
- 15. Robô aranha quadrúpede: com três articulações por perna você precisa de 12 servos, e com essa quantidade um PCA9685 é praticamente obrigatório. O peso importa, então a preferência é pelos servos MG90S, e o robô funciona com uma bateria LiPo 2S e um BEC de 5 A. A caminhada é feita com uma tabela de poses que muda os ângulos de cada perna em sequência; o modelo de braço robótico mais abaixo é um bom ponto de partida para isso também.
Ligação comum: Arduino Uno, ESP32 e Pico
| Fio do servo | Arduino Uno | ESP32 | Raspberry Pi Pico | Fonte externa de 5-6 V |
|---|---|---|---|---|
| Marrom / preto (GND) | GND | GND | GND | Negativo (-) |
| Vermelho (V+) | 5V (só um SG90) | Não conectado | Não conectado | Positivo (+) |
| Laranja / amarelo (sinal) | D9 | GPIO 18 | GP15 | Não conectado |
| GND da fonte | GND (comum) | GND (comum) | GND (comum) | Negativo (-) |
Código do projeto 2: radar ultrassônico com Arduino
O servo vai no D9, o TRIG do HC-SR04 no D10 e o ECHO no D11. O servo para a cada 2 graus, espera 30 ms e mede a distância; o resultado é impresso na porta serial no formato “ângulo,distância”. A tela de radar do Processing ou o Plotter Serial da Arduino IDE conseguem ler esse formato diretamente. O timeout de 30 ms passado ao pulseIn corresponde a cerca de 5 metros; se nenhum eco voltar, é impresso -1. A matemática da distância está explicada no guia do HC-SR04.
1#include <Servo.h>
2
3const int SERVO_PIN = 9; // servo sinyali / servo signal
4const int TRIG_PIN = 10; // HC-SR04 TRIG
5const int ECHO_PIN = 11; // HC-SR04 ECHO
6
7Servo radar;
8
9int readDistanceCm() {
10 digitalWrite(TRIG_PIN, LOW);
11 delayMicroseconds(2);
12 digitalWrite(TRIG_PIN, HIGH); // 10 µs tetik darbesi / 10 µs trigger pulse
13 delayMicroseconds(10);
14 digitalWrite(TRIG_PIN, LOW);
15 unsigned long us = pulseIn(ECHO_PIN, HIGH, 30000UL); // en fazla 30 ms (~5 m) / max 30 ms (~5 m)
16 if (us == 0) return -1; // yankı yok / no echo
17 return us * 0.0343 / 2; // µs -> cm
18}
19
20void scanTo(int angle) {
21 radar.write(angle);
22 delay(30); // servo yerine otursun / let the servo settle
23 int d = readDistanceCm();
24 Serial.print(angle); // "açı,mesafe" satırı / "angle,distance" line
25 Serial.print(',');
26 Serial.println(d);
27}
28
29void setup() {
30 Serial.begin(9600);
31 pinMode(TRIG_PIN, OUTPUT);
32 pinMode(ECHO_PIN, INPUT);
33 radar.attach(SERVO_PIN);
34}
35
36void loop() {
37 for (int a = 15; a <= 165; a += 2) scanTo(a); // soldan sağa / left to right
38 for (int a = 165; a >= 15; a -= 2) scanTo(a); // sağdan sola / right to left
39}Código do projeto 13: braço robótico com vários servos, sem delay
Em um braço robótico, todas as articulações precisam se mover ao mesmo tempo e com suavidade. Se você escrever o ângulo de destino de cada servo direto com write(), os servos saltam para lá a toda velocidade, o braço balança e os picos de corrente aumentam. O modelo abaixo move cada articulação em direção ao destino um grau de cada vez usando millis(); o array STEP_MS define a velocidade de cada articulação. Acrescente linhas à tabela POSES para escrever sua própria sequência de movimentos e use a mesma estrutura em um pan-tilt, uma cancela ou um robô aranha.
1#include <Servo.h>
2
3// 4 eksenli robot kol: taban, omuz, dirsek, kıskaç / 4-axis robot arm: base, shoulder, elbow, gripper
4const byte JOINTS = 4;
5const byte PINS[JOINTS] = {3, 5, 6, 9};
6const unsigned int STEP_MS[JOINTS] = {15, 20, 20, 8}; // 1 derece için bekleme (ms) / wait per degree (ms)
7
8// Hareket sırası: her satır bir poz / move sequence: each row is a pose
9const int POSES[][JOINTS] = {
10 {90, 90, 90, 30}, // başlangıç / home
11 {40, 120, 60, 30}, // nesneye uzan / reach the object
12 {40, 120, 60, 90}, // kıskacı kapat / close the gripper
13 {140, 80, 100, 90}, // taşı / carry
14 {140, 80, 100, 30} // bırak / release
15};
16const byte POSE_COUNT = sizeof(POSES) / sizeof(POSES[0]);
17
18Servo servos[JOINTS];
19int current[JOINTS], target[JOINTS];
20unsigned long lastStep[JOINTS];
21byte pose = 0;
22
23// Servoyu hedefe 1 derece yaklaştırır, delay kullanmaz / moves a servo 1 degree closer, no delay
24bool updateJoint(byte i) {
25 if (current[i] == target[i]) return true; // hedefte / at target
26 if (millis() - lastStep[i] < STEP_MS[i]) return false;
27 lastStep[i] = millis();
28 current[i] += (target[i] > current[i]) ? 1 : -1;
29 servos[i].write(current[i]);
30 return current[i] == target[i];
31}
32
33void setup() {
34 for (byte i = 0; i < JOINTS; i++) {
35 current[i] = target[i] = POSES[0][i];
36 servos[i].write(current[i]); // attach öncesi başlangıç açısı / start angle before attach
37 servos[i].attach(PINS[i]);
38 }
39 delay(1000);
40}
41
42void loop() {
43 bool allDone = true;
44 for (byte i = 0; i < JOINTS; i++) {
45 if (!updateJoint(i)) allDone = false; // hepsi aynı anda hareket eder / all move together
46 }
47 if (allDone) { // poz tamam, sıradakine geç / pose reached, next one
48 delay(500);
49 pose = (pose + 1) % POSE_COUNT;
50 for (byte i = 0; i < JOINTS; i++) target[i] = POSES[pose][i];
51 }
52}Chamar write() antes de attach() impede que o servo salte para 90 graus ao ligar, antes de ir para a pose inicial. Os servos estão em D3, D5, D6 e D9; como a biblioteca Servo pode usar qualquer pino digital, o pino não precisa ter a marca de PWM. Se o Arduino reiniciar enquanto o braço se move, o problema é a alimentação, não o código; siga a lista de verificação do guia sobre servo tremendo.
Código do projeto 9: rastreador solar com ESP32
A biblioteca Servo do Arduino não funciona no ESP32; instale no lugar dela a biblioteca ESP32Servo, que roda o mesmo código nos cores 2.x e 3.x. Cada um dos quatro LDRs vai entre o 3V3 e um pino analógico, com um resistor de 10 kΩ desse pino ao GND; a leitura sobe conforme a luz fica mais forte. Usamos os pinos do ADC1 (32-35) para os LDRs porque os pinos do ADC2 não podem ser lidos com o Wi-Fi ligado. Se o painel girar para o lado errado, a montagem do seu servo é diferente; basta trocar o 1 e o -1 no código. Como os LDRs medem a luz está explicado no guia do sensor de luz LDR.
1#include <ESP32Servo.h>
2
3const int PAN_PIN = 18; // yatay servo / horizontal servo
4const int TILT_PIN = 19; // dikey servo / vertical servo
5// LDR'ler ADC1 pinlerinde (Wi-Fi ile çakışmaz) / LDRs on ADC1 pins (no Wi-Fi conflict)
6const int LDR_TL = 32, LDR_TR = 33, LDR_BL = 34, LDR_BR = 35;
7const int TOLERANCE = 80; // bu farkın altında hareket etme / ignore smaller differences
8
9Servo pan, tilt;
10int panAngle = 90, tiltAngle = 45;
11
12void setup() {
13 analogReadResolution(12); // 0-4095
14 pan.setPeriodHertz(50); // standart servo 50 Hz / standard servo 50 Hz
15 tilt.setPeriodHertz(50);
16 pan.attach(PAN_PIN, 500, 2400); // darbe aralığı (µs) / pulse range (µs)
17 tilt.attach(TILT_PIN, 500, 2400);
18 pan.write(panAngle);
19 tilt.write(tiltAngle);
20}
21
22void loop() {
23 int tl = analogRead(LDR_TL), tr = analogRead(LDR_TR);
24 int bl = analogRead(LDR_BL), br = analogRead(LDR_BR);
25 int top = (tl + tr) / 2, bottom = (bl + br) / 2;
26 int left = (tl + bl) / 2, right = (tr + br) / 2;
27
28 // Daha aydınlık tarafa 1 derece dön / turn 1 degree toward the brighter side
29 if (abs(left - right) > TOLERANCE) panAngle += (left > right) ? 1 : -1;
30 if (abs(top - bottom) > TOLERANCE) tiltAngle += (top > bottom) ? 1 : -1;
31 panAngle = constrain(panAngle, 5, 175);
32 tiltAngle = constrain(tiltAngle, 10, 90);
33
34 pan.write(panAngle);
35 tilt.write(tiltAngle);
36 delay(25);
37}Servo com Raspberry Pi Pico (MicroPython)
O Pico não precisa de biblioteca extra: machine.PWM gera um sinal de 50 Hz e você define a largura do pulso em nanossegundos. A função set_angle() abaixo converte 0-180 graus em uma faixa de 500-2400 µs; se o seu servo zumbir nas extremidades, estreite esses limites. Os pinos do Pico fornecem 3,3 V, e o SG90, o MG90S e o MG996R funcionam bem com esse nível de sinal, mas a alimentação do servo ainda precisa vir do VBUS (5 V da USB) ou de uma fonte externa. Aplicando a mesma função a uma lista de objetos PWM, você consegue levar todos os projetos acima para o Pico.
1from machine import Pin, PWM
2import time
3
4servo = PWM(Pin(15)) # GP15 sinyal / GP15 signal
5servo.freq(50) # 50 Hz = 20 ms periyot / 20 ms period
6
7def set_angle(angle, min_us=500, max_us=2400):
8 angle = max(0, min(180, angle)) # 0-180 arası sınırla / clamp to 0-180
9 us = min_us + (max_us - min_us) * angle / 180 # açı -> darbe (µs) / angle -> pulse (µs)
10 servo.duty_ns(int(us * 1000)) # µs -> ns
11
12while True:
13 for a in range(0, 181, 2): # 0 -> 180 derece / degrees
14 set_angle(a)
15 time.sleep_ms(15)
16 for a in range(180, -1, -2): # 180 -> 0 derece / degrees
17 set_angle(a)
18 time.sleep_ms(15)Erros comuns em projetos com servo
- O Arduino reinicia quando o servo se move: os servos estão alimentados pelo pino 5V, que vem da USB. Use uma fonte externa, GND comum e um capacitor de 470-1000 µF.
- O servo zumbe e esquenta nas extremidades: em 0 ou 180 graus ele está forçando contra o batente mecânico. Reduza a faixa para 5-175 graus ou calibre os limites de pulso no attach().
- O servo treme: alimentação fraca, fios longos e finos ou um potenciômetro ruidoso. Use fios mais grossos, filtre a leitura e adicione uma zona morta que ignore pequenas variações.
- O analogWrite não funciona em D9 e D10: no Uno, a biblioteca Servo usa o Timer1. Passe o PWM do LED ou do motor para D3, D5, D6 ou D11.
- O braço não levanta a carga: o torque é dividido pelo comprimento do braço. Encurte o braço, alivie a carga ou suba um tamanho de servo (do SG90 para o MG90S, do MG90S para o MG996R).
- As engrenagens de plástico espanaram: o mecanismo trava o servo, ou o braço foi girado à força com a mão. Use servos com engrenagens de metal onde houver carga constante e não gire o braço do servo com a mão.
Depois que você entende como eles funcionam, os servo motores abrem as portas para infinitos projetos; as mesmas poucas linhas de código movem tanto um radar quanto um braço robótico. Se quiser montar vários deles passo a passo, o app BlueGrays tem controle de servo com potenciômetro, controle de servo com joystick, servo com ESP32, uma fechadura com servo e RFID, um robô que desvia de obstáculos e uma coreografia em círculo com 32 servos, cada um com esquema do circuito e código.
Perguntas frequentes
O que dá para fazer com um servo motor?
Tudo que precise ir até um ângulo e ficar nele: radares, braços robóticos, fechaduras, rastreadores solares, alimentadores automáticos para pets, suportes pan-tilt de câmera e robôs que andam são os exemplos mais populares. Com servos de 360 graus também dá para montar pequenos robôs com rodas.
Quantos servos um Arduino consegue controlar?
A biblioteca Servo do Arduino Uno consegue acionar até 12 servos diretamente, e a do Mega até 48. O limite real costuma ser a fonte de alimentação, não a quantidade de pinos. Para mais de 5 ou 6 servos, um driver PCA9685 reduz a fiação e a oscilação dos pulsos; uma placa aciona 16, e placas encadeadas podem acionar centenas.
Devo comprar um SG90 ou um MG996R?
Um SG90 basta para tampas leves, para girar sensores e para braços pequenos. Cargas pesadas, o ombro de um braço robótico ou mecanismos sob esforço constante pedem o MG996R, com engrenagens de metal e até 11 kg·cm de torque, mas ele precisa de uma fonte externa capaz de fornecer 3 A por servo.
Dá para alimentar um servo pelo pino 5V do Arduino?
Só um único SG90 com carga leve. Se você ligar mais servos ou um servo grande, os picos de corrente derrubam a tensão e o Arduino reinicia. Use uma fonte externa de 5-6 V e ligue o GND dela ao GND do Arduino.
Por que meu servo treme?
A causa mais comum é alimentação insuficiente, seguida de falta de GND comum, leituras ruidosas do potenciômetro e o servo forçando contra o batente mecânico. Uma fonte externa, um capacitor, filtrar a leitura e uma faixa mais estreita, como 5-175 graus, resolvem a maioria dos casos.
Como controlar um servo com um ESP32?
No ESP32 você usa a biblioteca ESP32Servo no lugar da biblioteca Servo padrão; attach(pin, 500, 2400) e write(angle) funcionam igual ao Arduino. Escolha pinos que possam ser saída, como GPIO 18, 19 ou 25, e alimente o servo com uma fonte de 5 V, não pelo pino de 3,3 V do ESP32.
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.

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.

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

