Motor CC, servo motor e motor de passo: diferenças e qual escolher

A diferença entre motor CC, servo motor e motor de passo cabe em uma frase: o motor CC gira sem parar e rápido enquanto você o alimenta, o servo vai até o ângulo que você pede e fica lá, e o motor de passo gira em passos pequenos e contáveis. Então, se você precisa girar uma roda, escolhe um motor CC; para abrir uma tampa em 90 graus, um servo; para mover uma peça com precisão de um décimo de milímetro, um motor de passo. Sempre que algo precisa se mexer em um projeto com Arduino, ESP32 ou Raspberry Pi Pico, você vai encontrar um desses três.

Neste guia comparamos o que há dentro de cada motor, números reais de velocidade, torque e precisão de posição de modelos populares (motor TT, SG90, MG996R, 28BYJ-48, NEMA 17), qual driver cada um precisa (L298N, um sinal PWM, ULN2003, A4988), quanta corrente eles consomem e qual é usado em cada projeto. No final você encontra códigos para Arduino, ESP32 e Pico que acionam os três ao mesmo tempo, uma breve introdução aos motores sem escovas (BLDC) e aos ESCs, e os erros mais comuns.

Resposta curta: os três motores comparados em uma tabela

A linha mais importante da tabela é a da realimentação. O servo sabe onde está graças ao potenciômetro interno e, quando algo o empurra, ele volta para a posição. O motor de passo não sabe onde está; você apenas conta quantos passos ele deu, e essa contagem está certa enquanto o motor não for sobrecarregado e não perder passos. O motor CC não faz ideia de quanto girou; se você precisa de posição, tem de colocar um encoder no eixo dele. A escolha do motor depende em grande parte de o seu projeto precisar ou não dessa informação.

Como funciona um motor CC?

Quase todo motor CC dos projetos hobby é um motor CC com escovas. Dentro dele há ímãs fixos e uma bobina que gira (o rotor); escovas de carvão e um comutador de cobre invertem o sentido da corrente conforme o rotor gira, e assim ele continua girando. Ele tem dois fios: aplique tensão e ele gira; inverta os fios e ele gira para o outro lado. A tensão define a velocidade e a corrente que ele consome define o torque. Enquanto o motor gira, as bobinas geram uma tensão contrária chamada força contraeletromotriz (back EMF), que limita a corrente; quando o eixo é bloqueado, essa força contraeletromotriz desaparece e a corrente salta para a corrente de travamento (stall).

Um motor CC pequeno sem redução gira a milhares de RPM, mas tem pouquíssimo torque; é por isso que robôs sempre usam motores com redução. A caixa de redução de 1:48 de um motor TT baixa cerca de 12.000 RPM no eixo do motor para 250 RPM na roda e multiplica o torque por aproximadamente 48 (menos as perdas nas engrenagens). Você muda a velocidade com PWM e o sentido com uma ponte H; os detalhes estão em Controle de motor CC com o L298N. O ponto fraco do motor CC é a posição: o mesmo valor de PWM dá uma velocidade diferente conforme a tensão da bateria e a carga, então um comando “ande para frente por 2 segundos” cobre uma distância diferente a cada vez. Se você precisa de distância exata, coloca um encoder na roda.

Como funciona um servo motor?

Um servo motor é, na verdade, um sistema completo dentro de uma caixinha: um motor CC, um trem de engrenagens que reduz a velocidade e aumenta o torque, um potenciômetro preso ao eixo de saída e uma placa de controle. O Arduino não envia ao servo um ângulo diretamente, e sim um pulso a 50 Hz (uma vez a cada 20 ms); a largura do pulso descreve a posição desejada. A placa de controle compara esse alvo com a posição real lida no potenciômetro e aciona o motor nesse sentido até a diferença zerar. Isso se chama controle em malha fechada, e é por isso que o servo resiste quando você tenta girá-lo com a mão.

A faixa RC padrão é de 1–2 ms, mas a maioria dos servos baratos, como o SG90, precisa de aproximadamente 0,5–2,4 ms para os 180° completos, e a biblioteca Servo do Arduino usa 544–2400 µs por padrão. A zona morta do SG90, a menor variação à qual ele reage, é de cerca de 10 µs, o que corresponde a aproximadamente 1°; por isso a precisão prática de um servo fica em torno de um grau. Um servo de rotação contínua (FS90R) é um servo com a realimentação desativada: você controla velocidade e sentido em vez do ângulo, e a informação de posição se perde. Se você precisa de mais força, o MG996R com engrenagens metálicas é a escolha padrão; para o básico, veja O que é um servo motor?

Como funciona um motor de passo?

O motor de passo não tem escovas. As bobinas da carcaça são energizadas em uma ordem definida, e o rotor magnético dá um único passo em direção à próxima bobina a cada vez. Os motores de passo híbridos mais comuns têm 200 passos por volta, ou 1,8° por passo. Envie um certo número de pulsos e ele dá esse mesmo número de passos; envie mais rápido e ele gira mais rápido. Enquanto as bobinas estiverem energizadas, o motor fica travado no lugar; isso se chama torque de retenção. A diferença principal: o motor de passo trabalha em malha aberta. Se a carga passar do torque dele, ele perde passos, e o Arduino nunca percebe. É por isso que as impressoras 3D levam cada eixo até uma chave de fim de curso ao ligar (homing).

Você vai encontrar dois tipos de motor de passo. Os motores unipolares (28BYJ-48, 5 fios) têm um fio comum compartilhado pelas bobinas e são acionados por um simples arranjo de transistores, como o ULN2003. Os motores bipolares (NEMA 17, 4 fios) precisam que a corrente da bobina seja invertida, o que é feito por drivers com limitação de corrente, como o A4988, o DRV8825 ou o TMC2209. Esses drivers também fazem micropasso: o A4988 divide cada passo completo em 16, elevando o número de passos por volta para 3200 e deixando o movimento bem mais silencioso e suave. Para os detalhes, veja 28BYJ-48 e ULN2003 e driver de motor de passo A4988.

Velocidade, torque e precisão de posição: os números

O torque costuma ser dado em kg·cm: um motor de 1 kg·cm consegue segurar uma carga de 1 kg a 1 cm do eixo, mas só 0,5 kg a 2 cm (1 kg·cm ≈ 0,098 N·m). Por exemplo, um MG996R em 6 V entrega 11 kg·cm; na ponta de um braço de 15 cm, ele segura em teoria 11 / 15 ≈ 0,73 kg. Mas esse é o torque de pico no momento em que o motor trava, e o peso do próprio braço se soma à carga. Uma boa regra para o motor durar bastante é ficar abaixo da metade desse valor; na prática, você consegue levar algumas centenas de gramas na ponta desse braço.

Em velocidade, a ordem se inverte. O motor CC é de longe o mais rápido. Um servo SG90 completa um movimento de 180° em cerca de 0,3 segundo e não consegue ir mais rápido. O torque do motor de passo cai conforme a velocidade sobe, porque a corrente da bobina não tem tempo de subir por completo a cada passo; um 28BYJ-48 começa a perder passos acima de uns 15 RPM. Alimentar um NEMA 17 com A4988 a partir de 24 V em vez de 12 V dá mais torque em alta velocidade, porque o driver limita a corrente de qualquer forma. Em precisão, porém, o motor de passo vence: um NEMA 17 dá 1,8° em passo completo e, no papel, 0,1125° com micropasso de 1/16. Uma observação: a relação de redução interna do 28BYJ-48 não é exatamente 1:64, e sim cerca de 1:63,68, então uma volta real tem cerca de 2038 passos, e não 2048; em projetos que giram sem parar, como relógios, essa diferença se acumula.

Qual driver cada motor precisa?

Um pino do Arduino fornece no máximo 40 mA, e o limite seguro fica em torno de 20 mA; até um pequeno motor TT consome cerca de 7 vezes isso em vazio e mais de 70 vezes quando travado. Além disso, a bobina de um motor gera um pico de tensão reversa alto no instante em que a corrente é cortada, o que pode destruir um pino sem proteção. Por isso há sempre um driver entre o motor e a placa: a placa só envia pequenos sinais de controle, enquanto a corrente do motor flui direto da fonte de alimentação através do driver. Os drivers têm transistores e diodos que absorvem a tensão reversa. Para uma ventoinha ou bomba que gira só para um lado, um único MOSFET basta.

Consumo de energia: quanta corrente cada motor consome?

Os três motores se comportam de forma muito diferente em relação à corrente, e você precisa escolher a fonte de alimentação de acordo. O motor CC consome mais corrente à medida que a carga aumenta; na partida e quando uma roda emperra, ele se aproxima da corrente de travamento. Dimensione a fonte para esse pico, não para a corrente em vazio. O servo consome muito pouco enquanto espera, mas produz picos de corrente curtos e bruscos a cada movimento: até um único SG90 pode passar de 0,5 A por um instante, e um MG996R chega a 2,5 A quando forçado. Esses picos derrubam a tensão e resetam o Arduino, ou causam um erro de brownout no ESP32. Já o motor de passo tem corrente passando pelas bobinas mesmo quando não se mexe nada: um 28BYJ-48 consome 150–200 mA parado e esquenta. Em projetos a bateria, se você não precisa de torque de retenção, desligar as bobinas (colocando o pino EN do A4988 em HIGH) aumenta bastante a autonomia da bateria.

• Use uma alimentação separada: não alimente motores pelo pino 5V do Arduino. Uma porta USB fornece cerca de 500 mA, e a placa já usa parte disso; tirando um único servo pequeno, todo motor precisa da sua própria fonte.
• Ligue os GNDs: o terminal negativo da fonte do motor precisa estar ligado ao GND da placa; caso contrário, o sinal de controle fica sem referência (veja GND comum).
• Adicione capacitores: coloque um eletrolítico de 470–1000 µF na linha de alimentação dos servos, pelo menos 47 µF na entrada VMOT do A4988 e um capacitor cerâmico de 100 nF entre os terminais de um motor CC com escovas. O primeiro reduz as quedas de tensão; o último, o ruído das escovas.
• Dimensione a fonte pelo pico de corrente: por exemplo, um braço robótico com 4 servos precisa de uma fonte de 5–6 V capaz de fornecer pelo menos 3 A, e um carrinho com dois motores TT precisa de um pack de baterias que aguente 2 × 1,5 A. Você pode calcular quanto tempo a bateria vai durar com a calculadora de autonomia da bateria.
• Abaixe a tensão do jeito certo: se você precisa de 5–6 V para os servos a partir de um pack de 7,4 V, use um regulador chaveado como o LM2596; reguladores lineares como o 7805 esquentam muito com correntes na casa dos ampères.

Acionando os três motores com um só Arduino: passo a passo

O melhor jeito de ver a diferença é rodar os três lado a lado. No circuito abaixo, um motor TT é acionado por um L298N, um SG90 direto por um pino e um 28BYJ-48 por uma placa ULN2003. A tabela de pinos vale para os três exemplos de código: Arduino Uno, ESP32 e Raspberry Pi Pico.

1. Retire o jumper do ENA no L298N; ligue ENA, IN1 e IN2 aos pinos da tabela e o motor CC aos bornes OUT1 e OUT2. Conecte a alimentação do motor (por exemplo, duas células 18650 em série, 7,4 V) ao borne de 12V.
2. Ligue o fio marrom do servo ao GND, o vermelho a uma fonte separada de 5–6 V e o fio laranja de sinal ao D9.
3. Encaixe o conector branco do 28BYJ-48 na placa ULN2003, ligue IN1–IN4 a D10–D13 e alimente o terminal + da placa com uma fonte de 5 V.
4. Ligue entre si os terminais negativos de todas as fontes e o GND do Arduino.
5. Carregue o código pela Arduino IDE; as bibliotecas Servo e Stepper já vêm com a IDE, então você não precisa instalá-las.
6. Ligue as fontes dos motores e observe como os três motores se comportam, um depois do outro.

1#include <Servo.h>
2#include <Stepper.h>
3
4// DC motor (L298N): ENA=5, IN1=7, IN2=8
5const int ENA = 5;                 // PWM; Servo kütüphanesi 9 ve 10'un PWM'ini kapatır / Servo library disables PWM on 9 and 10
6const int IN1 = 7;
7const int IN2 = 8;
8
9const int SERVO_PIN = 9;           // servo sinyali / servo signal
10Servo servo;
11
12const int STEPS_PER_REV = 2048;    // 28BYJ-48 tam tur / full revolution
13Stepper stepper(STEPS_PER_REV, 10, 12, 11, 13);   // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
14
15void releaseStepper() {            // bobinleri bırak, boşta akım çekmesin / release coils, no idle current
16  for (int pin = 10; pin <= 13; pin++) {
17    digitalWrite(pin, LOW);
18  }
19}
20
21void setup() {
22  pinMode(ENA, OUTPUT);
23  pinMode(IN1, OUTPUT);
24  pinMode(IN2, OUTPUT);
25  servo.attach(SERVO_PIN);
26  stepper.setSpeed(10);            // devir/dakika, 28BYJ-48 için en fazla ~15 / RPM, max ~15 for 28BYJ-48
27}
28
29void loop() {
30  // 1) DC motor: hız ve yön, konum yok / speed and direction, no position
31  digitalWrite(IN1, HIGH);
32  digitalWrite(IN2, LOW);
33  analogWrite(ENA, 180);           // yaklaşık %70 güç / about 70% power
34  delay(2000);
35  analogWrite(ENA, 0);             // motoru serbest bırak / let the motor coast
36  delay(500);
37
38  // 2) Servo: açı ver, gidip orada kalsın / give an angle, it goes there and holds
39  servo.write(0);
40  delay(600);
41  servo.write(180);
42  delay(600);
43  servo.write(90);
44  delay(600);
45
46  // 3) Step motor: tam çeyrek tur ileri ve geri / exactly a quarter turn forward and back
47  stepper.step(STEPS_PER_REV / 4);   // 512 adım = 90° / 512 steps = 90°
48  delay(500);
49  stepper.step(-STEPS_PER_REV / 4);
50  releaseStepper();
51  delay(1000);
52}

Quando você roda o código, a diferença fica evidente: o motor CC gira por dois segundos, mas o eixo para em um ponto diferente a cada vez. O servo vai rápido para 0°, 180° e 90°, e resiste se você tentar girá-lo com a mão. O motor de passo avança devagar exatamente um quarto de volta e volta ao mesmo ponto; depois que releaseStepper() é chamado, você consegue girar o eixo dele livremente com a mão. A função step() da biblioteca Stepper trava o código até o movimento terminar; se você quer acionar vários motores ao mesmo tempo com aceleração suave, passe para a biblioteca AccelStepper.

Motor CC, servo e motor de passo com o ESP32

Os pinos do ESP32 trabalham com 3,3 V; as entradas do L298N e do ULN2003 leem esse nível como HIGH, e os servos também funcionam com um sinal de 3,3 V. Os motores continuam precisando da própria alimentação. A diferença está no servo: a biblioteca Servo padrão do Arduino não é compatível com o ESP32. Você pode instalar a biblioteca ESP32Servo ou, como abaixo, gerar o sinal de 50 Hz por conta própria com a unidade de PWM por hardware do ESP32, o LEDC. Como usamos duas frequências diferentes, 1 kHz para o motor CC e 50 Hz para o servo, atribuímos os canais a timers separados (canais 0 e 2) com ledcAttachChannel; em algumas versões do core, canais vizinhos compartilham o mesmo timer. O código é para o core Arduino do ESP32 3.x; nas versões 2.x, você usa ledcSetup e ledcAttachPin no lugar. A biblioteca Stepper funciona sem alterações no ESP32; se você está começando com a placa, dê uma olhada em O que é o ESP32?

1#include <Stepper.h>
2
3// ESP32 Arduino çekirdeği 3.x / ESP32 Arduino core 3.x
4const int ENA = 25;                // L298N hız (PWM) / L298N speed (PWM)
5const int IN1 = 26;
6const int IN2 = 27;
7const int SERVO_PIN = 18;          // servo sinyali / servo signal
8
9const int STEPS_PER_REV = 2048;
10Stepper stepper(STEPS_PER_REV, 19, 22, 21, 23);   // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
11
12void motor(int speed) {            // -255 … 255
13  digitalWrite(IN1, speed > 0);
14  digitalWrite(IN2, speed < 0);
15  ledcWrite(ENA, abs(speed));
16}
17
18void servoWrite(int angle) {       // 0 … 180
19  int us = map(angle, 0, 180, 500, 2400);              // açı → darbe (µs) / angle → pulse (µs)
20  ledcWrite(SERVO_PIN, (uint32_t)us * 65535 / 20000);  // 20 ms içindeki pay / share of the 20 ms period
21}
22
23void setup() {
24  pinMode(IN1, OUTPUT);
25  pinMode(IN2, OUTPUT);
26  ledcAttachChannel(ENA, 1000, 8, 0);        // kanal 0: 1 kHz, 8 bit (0–255) / channel 0: 1 kHz, 8-bit
27  ledcAttachChannel(SERVO_PIN, 50, 16, 2);   // kanal 2, ayrı zamanlayıcı: 50 Hz, 16 bit / channel 2, separate timer: 50 Hz, 16-bit
28  stepper.setSpeed(10);                      // devir/dakika / RPM
29}
30
31void loop() {
32  motor(200);         delay(2000);   // DC: ileri / forward
33  motor(0);           delay(500);    // DC: dur / stop
34  servoWrite(0);      delay(600);    // servo: 0°
35  servoWrite(180);    delay(600);    // servo: 180°
36  servoWrite(90);     delay(600);    // servo: 90°
37  stepper.step(512);  delay(500);    // step: çeyrek tur / quarter turn
38  stepper.step(-512); delay(1000);
39}

Código MicroPython para o Raspberry Pi Pico

No Pico, todo pino GP pode gerar PWM. No MicroPython, você ajusta a velocidade do motor CC de 0 a 65535 com duty_u16() e a largura do pulso do servo em nanossegundos com duty_ns(). O motor de passo gira escrevendo a sequência de meio passo nos quatro pinos, um após o outro; no modo de meio passo, uma volta do 28BYJ-48 tem 4096 passos. Se você está começando com o Pico, comece por O que é o Raspberry Pi Pico?

1from machine import Pin, PWM
2import time
3
4# DC motor (L298N): ENA=GP15, IN1=GP14, IN2=GP13
5ena = PWM(Pin(15))
6ena.freq(1000)
7in1 = Pin(14, Pin.OUT)
8in2 = Pin(13, Pin.OUT)
9
10# Servo: GP16, 50 Hz
11servo = PWM(Pin(16))
12servo.freq(50)
13
14# Step motor (ULN2003): IN1–IN4 = GP2–GP5
15coils = [Pin(n, Pin.OUT) for n in (2, 3, 4, 5)]
16SEQ = [(1,0,0,0), (1,1,0,0), (0,1,0,0), (0,1,1,0),
17       (0,0,1,0), (0,0,1,1), (0,0,0,1), (1,0,0,1)]   # yarım adım dizisi / half-step sequence
18
19def motor(speed):                    # -100 … 100
20    in1.value(speed > 0)
21    in2.value(speed < 0)
22    ena.duty_u16(int(abs(speed) * 655.35))
23
24def servo_angle(angle):              # 0 … 180
25    us = 500 + angle * 1900 // 180   # 500–2400 µs
26    servo.duty_ns(us * 1000)
27
28phase = 0                            # dizideki konum, çağrılar arasında korunur / position in the sequence, kept between calls
29
30def step(steps, delay_ms=2):         # yarım adımda 4096 adım = 1 tur / 4096 half-steps = 1 turn
31    global phase
32    d = 1 if steps > 0 else -1
33    for _ in range(abs(steps)):
34        phase = (phase + d) % 8
35        for pin, v in zip(coils, SEQ[phase]):
36            pin.value(v)
37        time.sleep_ms(delay_ms)
38    for pin in coils:
39        pin.value(0)                 # bobinleri bırak / release coils
40
41while True:
42    motor(70)                        # DC: %70 ileri / 70% forward
43    time.sleep(2)
44    motor(0)                         # DC: dur / stop
45    time.sleep(0.5)
46    for a in (0, 180, 90):           # servo: üç açı / three angles
47        servo_angle(a)
48        time.sleep(0.6)
49    step(1024)                       # step: çeyrek tur / quarter turn
50    time.sleep(0.5)
51    step(-1024)
52    time.sleep(1)

Qual motor para cada projeto?

Em alguns projetos qualquer um dos motores serve, e a escolha depende dos detalhes. Em um carrinho robô, motores CC dão conta das rodas, mas se você quer que o carrinho ande exatamente 50 cm, ou adiciona encoders ou aciona as rodas com motores de passo. Em um braço robótico, os servos são o caminho mais fácil; braços pesados e precisos usam motores de passo com redução nas articulações. Em uma impressora 3D é fácil calcular quantos passos um eixo precisa por milímetro: com um motor de 200 passos, micropasso de 1/16 e uma polia GT2 de 20 dentes (passo de dente de 2 mm), você obtém 200 × 16 / (20 × 2) = 80 passos/mm; com um fuso trapezoidal T8 de avanço de 8 mm, fica 200 × 16 / 8 = 400 passos/mm. Para projetos que fazem varredura de 0–180°, como um radar ou um seguidor solar, o servo é ao mesmo tempo a solução mais barata e a mais simples.

Uma breve introdução aos motores sem escovas (BLDC) e aos ESCs

O motor CC sem escovas (BLDC) é construído ao contrário: os ímãs ficam na parte que gira e as bobinas ficam na carcaça fixa. Sem escovas nem comutador, não há atrito, faíscas nem desgaste; o motor é mais eficiente, mais silencioso e dura muito mais. O preço é que o sentido da corrente agora precisa ser comutado por um circuito eletrônico, e não pelas escovas. É por isso que os motores BLDC têm 3 fios e não giram se você os ligar direto a uma bateria. Em motores de modelismo, a velocidade é dada pelo valor KV, as RPM sem carga por volt. Um motor de 1000 KV (ex.: o A2212) com uma bateria LiPo de 3 células (11,1 V) gira a cerca de 11.100 RPM sem carga. Drones, aeromodelos RC, skates e patinetes elétricos, ventoinhas de computador e discos rígidos usam motores sem escovas.

Para ligar um motor BLDC a um Arduino você precisa de um ESC (electronic speed controller, controlador eletrônico de velocidade). O ESC transforma a tensão CC da bateria em pulsos trifásicos para o motor; ESCs sem sensor estimam a posição do rotor a partir da força contraeletromotriz na bobina que não está energizada. A parte boa é que a entrada de controle do ESC é igual à de um servo: em pulsos de 50 Hz, 1000 µs significa parado e 2000 µs aceleração máxima. A corrente nominal do ESC (ex.: 30 A) precisa ser maior que a corrente máxima que o motor pode consumir, e a maioria dos ESCs tem uma saída BEC que fornece 5 V. Por segurança, ao ser ligado, o ESC quer ver primeiro a aceleração mínima; isso se chama arming (armar), e ele não gira o motor até receber esse sinal. No código abaixo, o fio de sinal do ESC vai ao D9 e o cursor do potenciômetro da aceleração vai ao A0.

1#include <Servo.h>
2
3Servo esc;                         // ESC bir servo gibi sürülür / an ESC is driven like a servo
4const int POT_PIN = A0;            // gaz potansiyometresi / throttle potentiometer
5
6void setup() {
7  esc.attach(9, 1000, 2000);       // 1000–2000 µs aralığı / 1000–2000 µs range
8  esc.writeMicroseconds(1000);     // en düşük gaz: ESC'yi kur (arming) / minimum throttle: arm the ESC
9  delay(3000);                     // bip seslerini bekle / wait for the beeps
10}
11
12void loop() {
13  int throttle = map(analogRead(POT_PIN), 0, 1023, 1000, 2000);   // pot → gaz / pot → throttle
14  esc.writeMicroseconds(throttle);
15  delay(20);                       // bir servo periyodu / one servo period
16}

Erros comuns e como corrigi-los

• O Arduino reinicia quando o motor funciona: o motor ou o servo está sendo alimentado pelo pino 5V da placa. Use uma fonte separada, ligue os GNDs e adicione um capacitor grande na alimentação.
• O servo treme ou dá saltos: a fonte é fraca, os fios são finos e longos ou o GND não é comum. Ligue o servo a uma fonte de 5–6 V capaz de fornecer pelo menos 1 A.
• A velocidade do motor CC não muda quando um servo é usado: no Uno, o ENA está ligado ao pino 9 ou 10, e a biblioteca Servo desativa o PWM nesses pinos. Passe o ENA para o 3, 5, 6 ou 11.
• O motor CC não gira com valores baixos de PWM, só zumbe: não há potência suficiente para vencer o atrito estático. Dê a partida no motor com um valor alto por um instante e depois baixe a velocidade, ou mantenha o valor mínimo em torno de 80–100. Considere também a queda de tensão de cerca de 2 V do L298N.
• O motor de passo vibra, mas não gira: a ordem das bobinas está errada ou a velocidade está alta demais. Para o 28BYJ-48, use a ordem Stepper(2048, IN1, IN3, IN2, IN4) e mantenha a velocidade abaixo de 15 RPM.
• O motor de passo perde passos: a carga é pesada demais, a aceleração é brusca demais ou o limite de corrente do A4988 está baixo demais. Ajuste o Vref com a fórmula I = Vref / (8 × Rcs), em que Rcs é o resistor de detecção de corrente da placa, e use uma aceleração suave com a AccelStepper.
• O A4988 queimou: o cabo do motor foi ligado ou desligado com o driver energizado, o Vref estava alto demais ou não havia capacitor no VMOT. Sempre conecte o motor com a alimentação desligada.
• O ESC não gira o motor e fica apitando: ele não recebeu um sinal de aceleração mínima ao ligar. Confira se o setup() envia writeMicroseconds(1000) e espera alguns segundos; se necessário, calibre o ESC como descrito no manual dele.

Resumindo: motor CC é velocidade, servo é ângulo e motor de passo é posição; combine o motor certo com o driver certo e metade do seu projeto está resolvida. Começar com um SG90 e um motor TT e depois passar para um motor de passo é o jeito mais fácil de aprender os três. No app BlueGrays você encontra, passo a passo e com esquemas do circuito e código, os projetos “Uso do servo motor”, “Controle de servo com potenciômetro”, “Uso do motor de passo”, “Servo de 360 graus com motor de passo”, “Carrinho controlado por Bluetooth com L298N” e “Robô que desvia de obstáculos”.