Driver de motor de passo A4988 com NEMA 17: Vref, micropasso e código

Acionar um NEMA 17 com o A4988 é o jeito mais barato de levar para o seu projeto o movimento preciso usado em impressoras 3D, máquinas CNC e gravadoras a laser. O A4988 é um driver de motor de passo bipolar fabricado pela Allegro e vendido em um módulo do tamanho da ponta de um dedo: cada pulso de STEP vindo do Arduino move o motor um passo, o pino DIR escolhe o sentido e o driver mantém a corrente nas bobinas do motor no valor que você definiu. Ou seja, para girar o motor você só precisa de dois pinos e de uma fonte entre 8 e 35 V.

Neste guia você vai aprender como o A4988 funciona, como achar as bobinas de um NEMA 17 com um multímetro, como fazer as ligações e por que você precisa de um capacitor de 100 µF na alimentação. Depois passamos ao passo mais crítico, o ajuste da corrente com o Vref, trabalhando a fórmula e a medição com multímetro passo a passo. Micropasso com os pinos MS1–MS3, um primeiro sketch sem biblioteca, aceleração suave com o AccelStepper, a CNC Shield, código para ESP32 e Raspberry Pi Pico, calor e dissipadores, uma comparação com o DRV8825 e o TMC2208 e as soluções para o clássico problema do “motor vibra mas não gira” também estão aqui.

O que é o A4988 e como ele funciona?

Dentro do A4988 há duas pontes H completas (uma por bobina), um tradutor e um circuito de controle de corrente. O tradutor transforma cada transição de LOW→HIGH no pino STEP na sequência certa de corrente para as bobinas, então você não precisa calcular a ordem das bobinas no código. O controle de corrente usa um chopper: o driver monitora o tempo todo a corrente de cada bobina por um pequeno resistor sensor (Rs) e desliga a saída por um instante sempre que a corrente chega ao limite definido. É por isso que a corrente na bobina continua em um valor seguro mesmo que você alimente o motor bem acima da tensão nominal dele, por exemplo com 12 ou 24 V. O chip também tem proteção contra superaquecimento, subtensão, carga em curto e curto com o terra.

Motor de passo NEMA 17: especificações e como achar as bobinas

NEMA 17 não é um modelo de motor, e sim um padrão de tamanho para motores com flange de 42 × 42 mm; o que há dentro depende do comprimento do corpo e do fabricante. O 17HS4401, o modelo mais comum em projetos hobby, faz 200 passos por volta (1,8°), tem corrente nominal de 1,7 A por fase, resistência de bobina de cerca de 1,5 Ω e uns 40 N·cm de torque de retenção. A tensão da etiqueta é só 1,7 A × 1,5 Ω ≈ 2,6 V, mas não se deixe enganar: como o A4988 limita a corrente sozinho, o motor é alimentado com 12–24 V. Uma tensão maior deixa a corrente na bobina subir mais rápido a cada passo, então o motor perde menos torque em alta velocidade. Se tem curiosidade sobre a diferença para motores unipolares pequenos como o 28BYJ-48, veja 28BYJ-48 e ULN2003.

Os 4 fios do motor pertencem a duas bobinas independentes e, antes de ligá-lo ao A4988, você precisa saber quais dois fios formam a mesma bobina. Em muitos modelos, preto-verde é uma bobina e vermelho-azul a outra, mas as cores variam entre fabricantes, então o jeito mais confiável é medir:

1. Ponha o multímetro em resistência (Ω); se não tiver certeza de como fazer, dê uma olhada no guia do multímetro.
2. Segure um fio e meça contra cada um dos outros três. O fio que marcar 1–4 Ω é a outra ponta da mesma bobina; os outros dois mostram circuito aberto (OL).
3. Os dois fios restantes são a segunda bobina e devem mostrar a mesma resistência. Com a resistência medida e a corrente nominal, você pode conferir a tensão da etiqueta do motor usando a calculadora da lei de Ohm.
4. Sem multímetro? Encoste as pontas de dois fios uma na outra e gire o eixo com a mão: se ficar visivelmente mais difícil de girar, esses dois fios são da mesma bobina.
5. Ligue uma bobina aos pinos 1A–1B do A4988 e a outra aos 2A–2B. Se o motor girar no sentido contrário ao que você quer, basta inverter os dois fios de uma das bobinas.

Pinagem do A4988 e esquema de ligação

Por que um capacitor de 100 µF é obrigatório?

As placas do A4988 só trazem capacitores cerâmicos pequenos. Junto com a indutância dos fios de alimentação, esses capacitores de baixa ESR causam picos de tensão quando você liga a fonte ou quando o motor puxa uma corrente repentina. Esses picos podem passar do limite de 35 V do chip mesmo com uma fonte de 12 V e danificar o driver para sempre. A solução é simples: ponha um capacitor eletrolítico de pelo menos 47 µF, de preferência 100 µF, entre o VMOT e o GND, o mais perto possível da placa. A tensão nominal dele deve ficar bem acima da tensão da fonte: escolha 25 V para uma fonte de 12 V, e 35 V ou 50 V para 24 V. Os capacitores eletrolíticos têm polaridade; a perna longa (+) vai ao VMOT e a perna curta (–), marcada pela faixa no corpo, vai ao GND. Para os tipos de capacitor, veja O que é um capacitor?, e para escolher o adaptador certo, veja como alimentar o Arduino.

Ajustando a corrente com o Vref: a fórmula

O pequeno potenciômetro do A4988 ajusta o Vref (tensão de referência), que determina a corrente máxima do motor. O driver compara essa tensão com a tensão sobre os dois resistores sensores (Rs) da placa, e a corrente de pico na bobina é dada por: I = Vref / (8 × Rs). Para achar o Vref de que você precisa, reorganize: Vref = I × 8 × Rs. Para achar o Rs, leia a marcação dos dois pequenos resistores SMD ao lado do chip: R100 significa 0,1 Ω, R068 significa 0,068 Ω e R050 significa 0,05 Ω. Se tiver dificuldade com os códigos, use a calculadora de código de resistores SMD ou o artigo sobre códigos de resistores SMD.

Qual corrente escolher? A corrente da etiqueta do motor (1,7 A no 17HS4401) é um teto que você nunca deve ultrapassar. Sem dissipador, o A4988 aguenta com folga cerca de 1 A, então 0,8–1 A é um bom ponto de partida. Nas placas comuns com resistores R100, isso significa um Vref de 0,64–0,80 V. Se o motor perder passos com carga, suba a corrente em incrementos de 0,1 A; se passar de 1,2 A, ponha um dissipador e uma ventoinha no chip. Corrente além do necessário esquenta o driver e o motor muito mais do que deixa o motor visivelmente mais forte.

Medindo o Vref com um multímetro: passo a passo

1. Com toda a alimentação desligada, desconecte o motor do driver. Você não precisa do motor para medir o Vref.
2. Alimente os pinos VDD e GND do A4988 com a alimentação da lógica (os 5V do Arduino bastam). O Vref é derivado dessa tensão, então não dá para medi-lo sem o VDD; manter o VMOT ligado não faz mal.
3. Ponha o multímetro em tensão contínua (escala de 2 V ou 20 V). Encoste a ponta preta no GND e a vermelha no topo metálico do potenciômetro; algumas placas têm, no lugar, um pequeno ponto de teste marcado VREF.
4. Gire bem pouco o potenciômetro com uma chave de fenda pequena de plástico ou cerâmica e acompanhe a leitura. Na maioria das placas, o sentido horário aumenta o Vref, mas isso pode variar; alguns potenciômetros dão a volta depois de um giro completo, então avance aos pouquinhos.
5. Quando chegar ao valor calculado, desligue a alimentação, ligue o motor e só então energize de novo.
6. Rode o motor por alguns minutos e confira a temperatura do chip. Se não der para manter o dedo nele nem por alguns segundos, baixe um pouco o Vref ou ponha um dissipador.

Micropasso com MS1, MS2 e MS3

Micropasso significa que o driver muda a corrente nas duas bobinas aos poucos, dividindo cada passo completo em partes menores. O A4988 escolhe um de cinco modos conforme os níveis lógicos nos pinos MS1–MS3. Esses pinos têm resistores de pull-down internos, então, se você deixar os três desligados, o motor funciona no modo de passo completo.

O benefício real do micropasso é a rotação suave e silenciosa: no passo completo, o motor dá um tranco a cada passo e entra em ressonância e vibra em certas velocidades, enquanto em 1/16 o movimento é quase contínuo. Mas não espere que a precisão melhore de verdade 16 vezes. O torque que avança um único micropasso é só sen(90° / 16) ≈ 10% do torque de retenção; se o atrito ou a carga vencerem essa pequena força, o motor fica alguns micropassos para trás. Para calcular a velocidade, use: passos/s = RPM × 200 × micropassos / 60. Por exemplo, 60 RPM em 1/16 exigem 3200 pulsos de STEP por segundo. Se quiser mudar o modo pelo software, você também pode ligar os pinos MS ao Arduino; na maioria dos projetos, porém, escolher um modo fixo com fios basta.

Primeiro sketch: girando o motor com STEP e DIR, sem biblioteca

O sketch abaixo gira o motor uma volta para a frente e uma para trás sem nenhuma biblioteca, só mandando pulsos para o pino STEP. Partimos do princípio de que você ligou MS1–MS3 ao 5V, então o motor funciona em 1/16 e uma volta tem 3200 passos.

1// A4988 + NEMA 17, kütüphanesiz / without a library
2const int STEP_PIN = 2;            // CNC Shield X ekseniyle aynı / same as CNC Shield X axis
3const int DIR_PIN  = 5;
4const int EN_PIN   = 8;            // aktif LOW / active LOW
5
6const long STEPS_PER_REV = 200L * 16;   // 1,8° motor, 1/16 mikro adım = 3200 / 1.8° motor, 1/16 microstep
7
8void setup() {
9  pinMode(STEP_PIN, OUTPUT);
10  pinMode(DIR_PIN, OUTPUT);
11  pinMode(EN_PIN, OUTPUT);
12  digitalWrite(EN_PIN, LOW);       // sürücüyü aç / enable the driver
13}
14
15void rotate(long steps, unsigned int pauseUs) {
16  digitalWrite(DIR_PIN, steps > 0 ? HIGH : LOW);   // yön / direction
17  delayMicroseconds(5);                           // DIR, STEP'ten önce otursun / let DIR settle before STEP
18  for (long i = 0; i < labs(steps); i++) {
19    digitalWrite(STEP_PIN, HIGH);
20    delayMicroseconds(5);                         // darbe en az 1 µs / pulse at least 1 µs
21    digitalWrite(STEP_PIN, LOW);
22    delayMicroseconds(pauseUs);                   // küçüldükçe hız artar / smaller = faster
23  }
24}
25
26void loop() {
27  rotate(STEPS_PER_REV, 500);      // 1 tur ileri, ~1,6 sn / one turn forward, ~1.6 s
28  delay(1000);
29  rotate(-STEPS_PER_REV, 500);     // 1 tur geri / one turn back
30  delay(1000);
31}

Há três tempos a observar neste código. O A4988 precisa que as partes em HIGH e em LOW do pulso de STEP durem pelo menos 1 µs; 5 µs é um valor seguro. Depois que o DIR muda, é preciso esperar pelo menos 200 ns antes do primeiro pulso de STEP; o código espera 5 µs para isso. A velocidade é definida pela pausa entre os pulsos: com uma pausa de 500 µs, um passo leva cerca de 0,51 ms, então uma volta (3200 passos) leva cerca de 1,6 segundo, uns 36 RPM. Este código tem dois pontos fracos: o motor parte de repente em velocidade máxima, e o Arduino não consegue fazer mais nada enquanto o laço roda. Se você baixar a pausa direto para 100 µs, o motor provavelmente não vai partir e só vai zumbir.

Aceleração e desaceleração com o AccelStepper

Não dá para levar um motor de passo do repouso a alta velocidade em um instante; o rotor e a carga não acompanham uma mudança tão brusca, o motor perde o sincronismo e pula passos. A solução é subir a velocidade aos poucos e baixá-la ao se aproximar do alvo. O AccelStepper, que você pode instalar pelo Gerenciador de Bibliotecas, faz isso sem bloquear: você chama run() o tempo todo dentro do loop() e a biblioteca dá um passo sempre que é hora. Assim você consegue ler botões, atualizar um display ou fazer leituras de sensores enquanto o motor gira; essa abordagem está em detalhes em millis() ou delay(). Em um Uno, o AccelStepper chega com segurança a alguns milhares de passos por segundo (a documentação fala em cerca de 4000 passos/s a 16 MHz), então o exemplo usa 2000 passos/s, cerca de 37 RPM em 1/16.

1#include <AccelStepper.h>
2
3const int STEP_PIN = 2;
4const int DIR_PIN  = 5;
5const int EN_PIN   = 8;
6const long STEPS_PER_REV = 200L * 16;            // 1/16 mikro adımda 1 tur / one turn at 1/16 microstep
7
8AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);
9
10void setup() {
11  stepper.setEnablePin(EN_PIN);
12  stepper.setPinsInverted(false, false, true);   // EN aktif LOW / EN is active LOW
13  stepper.enableOutputs();
14  stepper.setMaxSpeed(2000);                     // adım/sn, Uno için güvenli / steps per second, safe on Uno
15  stepper.setAcceleration(1500);                 // adım/sn² / steps per second²
16  stepper.moveTo(STEPS_PER_REV * 3);             // 3 tur ileri / three turns forward
17}
18
19void loop() {
20  if (stepper.distanceToGo() == 0) {             // hedefe varıldı / target reached
21    delay(500);
22    stepper.moveTo(stepper.currentPosition() == 0 ? STEPS_PER_REV * 3 : 0);   // git-gel / back and forth
23  }
24  stepper.run();                                 // her döngüde çağır, bekletmez / call every loop, non-blocking
25}

Vários motores com a CNC Shield V3

Se você aciona mais de um NEMA 17, o jeito mais fácil de evitar um emaranhado de fios é a Arduino CNC Shield V3. Essa placa encaixa no Uno e tem quatro soquetes para A4988 (X, Y, Z e A), jumpers de micropasso embaixo de cada driver, conectores para os motores, entradas para chaves de fim de curso e um borne de alimentação; com os três jumpers colocados, o A4988 funciona em 1/16. Na tabela de ligações, escolhemos de propósito D2, D5 e D8 para STEP, DIR e EN: são os pinos do eixo X da shield, então os sketches acima funcionam na shield sem mudanças. Se você gravar o GRBL no Uno, a shield vira um controlador de CNC ou de laser que recebe G-code do computador. No GRBL, você informa quantos passos cada eixo precisa por milímetro nas configurações $100, $101 e $102: com uma polia GT2 de 20 dentes e micropasso de 1/16, isso dá 200 × 16 / (20 × 2) = 80 passos/mm e, em um fuso trapezoidal T8 com avanço de 8 mm, 200 × 16 / 8 = 400 passos/mm.

Usando o A4988 com o ESP32

Os pinos do ESP32 fornecem 3,3 V. O A4988 só lê uma entrada como HIGH com segurança quando ela passa de 70% do VDD; com o VDD em 5 V, esse limite é 3,5 V, então um sinal de 3,3 V não chega lá. Por isso ligue o pino VDD do A4988 ao 3V3 quando trabalhar com o ESP32 ou o Pico: o driver funciona bem com 3–5,5 V e você não vai precisar de um conversor de nível lógico. Como o VDD mudou, lembre-se de medir o Vref de novo. O sketch abaixo leva o motor, com aceleração, até o ângulo que você digitar no Monitor Serial (por exemplo 90 ou -45). Como o ESP32 é muito mais rápido, o AccelStepper chega com facilidade a 6000 passos por segundo aqui; para velocidades maiores, veja a biblioteca FastAccelStepper, que usa timers de hardware. Se você é novo no ESP32, comece por O que é o ESP32?.

1#include <AccelStepper.h>
2
3// ESP32: STEP=25, DIR=26, EN=27, A4988 VDD → 3V3
4const int STEP_PIN = 25;
5const int DIR_PIN  = 26;
6const int EN_PIN   = 27;
7const float STEPS_PER_DEG = 200.0 * 16 / 360.0;  // 1/16'da derece başına 8,89 adım / 8.89 steps per degree at 1/16
8
9AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);
10
11void setup() {
12  Serial.begin(115200);
13  stepper.setEnablePin(EN_PIN);
14  stepper.setPinsInverted(false, false, true);   // EN aktif LOW / EN is active LOW
15  stepper.enableOutputs();
16  stepper.setMaxSpeed(6000);                     // adım/sn / steps per second
17  stepper.setAcceleration(4000);                 // adım/sn² / steps per second²
18  Serial.println("Aci yaz, ornek 90 / type an angle, e.g. 90");
19}
20
21void loop() {
22  if (Serial.available()) {
23    float angle = Serial.parseFloat();           // Seri Monitör'den açı / angle from the Serial Monitor
24    while (Serial.available()) Serial.read();    // satır sonunu at / drop the line ending
25    stepper.moveTo(lround(angle * STEPS_PER_DEG));
26    Serial.printf("Hedef / target: %.1f\n", angle);
27  }
28  stepper.run();                                 // bekletmeden adım at / step without blocking
29}

A4988 com Raspberry Pi Pico e MicroPython

No Pico, você também liga o pino VDD do A4988 ao pino 3V3 (OUT). Em vez de uma biblioteca de aceleração, no MicroPython você pode escrever uma rampa linear simples como a de baixo: a função move() muda aos poucos a pausa entre os pulsos de 2000 µs para 400 µs nos primeiros e nos últimos 600 passos e roda em velocidade máxima no meio. O laço do MicroPython acrescenta algumas dezenas de microssegundos a cada passo, então a velocidade real fica um pouco abaixo da calculada. Se você precisa de dezenas de milhares de passos por segundo ou de vários motores ao mesmo tempo, os blocos PIO do Pico podem gerar os pulsos sem ocupar a CPU. Para instalar o MicroPython no Pico, veja O que é o Raspberry Pi Pico?.

1from machine import Pin
2import time
3
4step = Pin(2, Pin.OUT)              # STEP → GP2
5direction = Pin(3, Pin.OUT)         # DIR → GP3
6enable = Pin(4, Pin.OUT, value=0)   # EN → GP4, 0 = sürücü açık / 0 = driver enabled
7
8STEPS_PER_REV = 200 * 16            # 1/16 mikro adım / 1/16 microstep
9
10def move(steps, max_sps=2500, ramp_steps=600):
11    direction.value(1 if steps > 0 else 0)    # yön / direction
12    time.sleep_us(5)
13    n = abs(steps)
14    ramp = min(ramp_steps, n // 2)            # hızlanma ve yavaşlama adımı / accel and decel steps
15    fast = 1000000 // max_sps                 # en kısa bekleme, µs / shortest pause, µs
16    slow = 2000                               # 500 adım/sn ile başla / start at 500 steps/s
17    for i in range(n):
18        k = min(i, n - 1 - i)                 # başa ya da sona uzaklık / distance to start or end
19        pause = slow - (slow - fast) * k // ramp if k < ramp else fast
20        step.value(1)
21        time.sleep_us(3)                      # STEP darbesi / STEP pulse
22        step.value(0)
23        time.sleep_us(pause)
24
25while True:
26    move(STEPS_PER_REV)             # 1 tur ileri / one turn forward
27    time.sleep(1)
28    move(-STEPS_PER_REV // 2)       # yarım tur geri / half a turn back
29    time.sleep(1)

Calor, dissipadores e proteção térmica

É normal o A4988 esquentar, porque a corrente da bobina passa pelos MOSFETs dentro do chip. O caminho de corrente de cada bobina tem tipicamente uma resistência total de 0,64 Ω, e a potência dissipada cresce com o quadrado da corrente: aproximadamente P ≈ I² × 0,64 Ω. Com um ajuste de 1 A, isso dá uns 0,65 W e, com 1,5 A, uns 1,45 W; à medida que o chip esquenta, a resistência também sobe, então o valor real é ainda maior. É muito calor para uma placa do tamanho da ponta de um dedo. Quando o chip chega a 165 °C, a proteção térmica desliga as saídas e as religa depois que ele esfria uns 15 °C. Um motor que funciona alguns segundos, para e depois continua sozinho é o sinal clássico dessa proteção.

• Ponha um dissipador: cole um pequeno dissipador de alumínio no chip com fita térmica; cuide para que ele não encoste nos pinos nem no potenciômetro.
• Garanta circulação de ar: acima de 1,2 A, ou dentro de uma caixa fechada, uma pequena ventoinha multiplica o efeito do dissipador.
• Ajuste a corrente ao necessário: se o motor não perde passos com carga, baixe um pouco o Vref; reduzir a corrente em 20% corta o calor em cerca de 36%.
• Desligue as bobinas em repouso: se você não precisa do torque de retenção, ponha o pino EN em HIGH ou chame disableOutputs() quando o movimento terminar; o driver e o motor esfriam.
• Confira também a temperatura do motor: motores de passo consomem corrente mesmo parados, então ficam mornos ou até quentes. Se o corpo passar de 60 °C, baixe a corrente; nessa temperatura, as peças de PLA de uma impressora 3D começam a amolecer.
• Passe para um driver mais forte: se o seu motor precisa de mais de 1,5 A, um driver como o DRV8825 ou o TMC2209 serve melhor.

A4988, DRV8825 ou TMC2208

Os três drivers usam a mesma pegada “StepStick” de 16 pinos e muitas vezes podem ser trocados na CNC Shield, mas há diferenças a observar. O potenciômetro do DRV8825 fica em outro lugar e a fórmula dele é diferente; o pino que é o VDD no A4988 é a saída FAULT no DRV8825. Com o mesmo código, o TMC2208 gira o motor no sentido contrário ao do A4988, então você precisa inverter o DIR no software ou girar o conector do motor em 180°. As configurações avançadas dele são feitas por UART e, se você quer homing sem sensor (StallGuard), veja o TMC2209. Em resumo, o A4988 continua sendo o ponto de partida mais sensato para aprender e para projetos de baixo custo; escolha o TMC2208 se o ruído importar e o DRV8825 se precisar de mais corrente. Para uma comparação geral dos tipos de motor, leia motor CC, servo ou de passo.

Motor vibra mas não gira: erros comuns e soluções

Ideias de projetos com o A4988 e o NEMA 17

• Slider de câmera: mova uma câmera por um trilho milímetro a milímetro com correia e polia GT2 para gravar vídeos em time-lapse.
• Plotter de caneta: mova uma caneta em dois eixos com uma CNC Shield e o GRBL para passar desenhos do computador para o papel; um servo motor basta para levantar e baixar a caneta.
• Mesa giratória: gire um objeto em ângulos iguais para fotos de produto ou escaneamento 3D; como uma volta tem 3200 passos em 1/16, você dá cerca de 89 passos entre cada uma de 36 fotos.
• Seguidor solar: monte um sistema que vire um painel para o sol ao longo do dia; a ideia completa está no artigo do seguidor solar.
• Base de braço robótico: gire a base de um braço pesado com um NEMA 17 e engrenagens no lugar de um servo; para as outras articulações, veja o artigo do braço robótico.
• Posicionamento manual: mova o motor rápido com um joystick e com precisão, passo a passo, com um encoder rotativo.
• Cortina automática ou tampa deslizante: na partida, ache o ponto zero com uma chave de fim de curso, guarde-o com setCurrentPosition(0) e leve a cortina à posição que você quiser.

Acionar um NEMA 17 com o A4988, em resumo: faça o par de bobinas certo, ponha 100 µF na alimentação, calcule o Vref com a fórmula e ajuste-o com um multímetro, escolha o micropasso e rode o motor com aceleração. Depois de aprender essa base, o funcionamento de máquinas como impressoras 3D e CNCs também fica claro. No app BlueGrays você encontra projetos de movimento como o uso de um motor de passo e transformar um motor de passo em um servo de 360 graus, passo a passo, com esquemas de circuito e código.