Controle de Motor de Passo com Arduino e Driver A4988 – Guia Passo a Passo

Neste tutorial Arduino, aprenderemos como controlar um Motor de Passo usando o Driver A4988. Você pode assistir ao vídeo a seguir ou ler o tutorial escrito abaixo.

Visão Geral

O A4988 é um driver de microstep para controlar motores de passo bipolares que possui tradutor embutido para fácil operação. Isso significa que podemos controlar o motor de passo com apenas 2 pinos do nosso controlador: um para controlar a direção de rotação e outro para controlar os passos.

O driver fornece cinco resoluções de passo diferentes: passo completo, meio passo, quarto de passo, oitavo de passo e décimo sexto de passo. Também possui um potenciômetro para ajustar a corrente de saída, proteção térmica de desligamento por superaquecimento e proteção contra corrente de crossover.

Sua tensão lógica varia de 3 a 5,5V e a corrente máxima por fase é 2A se houver bom resfriamento adicional, ou 1A contínuo por fase sem dissipador.

Pinout do Driver A4988

Vamos examinar o pinout do driver e conectá-lo ao motor de passo e ao controlador. Começamos com os 2 pinos no canto inferior direito para alimentar o driver: VDD e GND, que precisam ser conectados a uma fonte de 3 a 5,5V – no nosso caso, o Arduino fornecerá 5V. Os 4 pinos seguintes são para conectar o motor: 1A e 1B para uma bobina e 2A e 2B para a outra. Para alimentar o motor, usamos os próximos 2 pinos: GND e VMOT, que precisam de uma fonte de 8 a 35V e também um capacitor de desacoplamento de pelo menos 47µF para proteger o driver de picos de tensão.

Os próximos 2 pinos, Step e Direction, são os que usamos para controlar os movimentos do motor. O pino Direction controla a direção de rotação e deve ser conectado a um pino digital do microcontrolador (pino 4 do Arduino). Com o pino Step, controlamos os microsteps: cada pulso enviado move o motor um passo. Não precisamos de programação complexa, tabelas de sequência de fases, linhas de controle de frequência, pois o tradutor embutido do A4988 cuida de tudo. Note que esses 2 pinos não são puxados internamente para nenhuma tensão, então não devemos deixá-los flutuando no programa.

O pino SLEEP: nível lógico baixo coloca a placa em modo sleep para minimizar consumo quando o motor não está em uso.

O pino RESET define o tradutor para um estado Home predefinido. Esse estado Home pode ser visto nas figuras do datasheet do A4988 – são as posições iniciais de onde o motor começa, diferentes dependendo da resolução de microstep. Se a entrada for lógica baixa, todas as entradas STEP serão ignoradas. O pino RESET é flutuante; se não pretendemos controlá-lo no programa, devemos conectá-lo ao pino SLEEP para trazê-lo a HIGH e habilitar a placa.

Os próximos 3 pinos (MS1, MS2, MS3) selecionam uma das cinco resoluções de passo conforme a tabela verdade. Esses pinos têm resistores pull-down internos; se deixados desconectados, a placa opera em modo passo completo.

O último pino, ENABLE, liga/desliga as saídas FET. Nível lógico alto mantém as saídas desabilitadas.

Componentes Necessários para este Tutorial Arduino

Você pode obter os componentes em qualquer um dos sites abaixo:

• Motor de Passo (NEMA17)
• Driver A4988
• Adaptador 12V 2A
• Jack de Alimentação
• Placa Arduino
• Protoboard e Fios Jumpers

Esquema do Circuito

Aqui está o esquema completo. Usarei o driver em Modo Passo Completo, deixando os 3 pinos MS desconectados e conectando apenas os pinos Direction e Step aos pinos 3 e 4 do Arduino, além de GND e 5V para alimentar a placa. Usarei um capacitor de 100µF para desacoplamento e adaptador 12V 1.5A para alimentar o motor. Usarei um motor NEMA 17 bipolar: fios A e C nos pinos 1A e 1B; fios B e D nos pinos 2A e 2B.

Limitação de Corrente do A4988

Antes de conectar o motor, devemos ajustar a limitação de corrente do driver para garantir que a corrente esteja dentro dos limites do motor. Fazemos isso ajustando a tensão de referência usando o potenciômetro na placa e considerando esta equação:

No entanto, essa equação nem sempre é correta, pois há diferentes fabricantes da placa A4988. Aqui está uma demonstração do meu caso: ajustei o potenciômetro e medi 0.6V de tensão de referência. A limitação de corrente deveria ser 0.6 * 2 = 1.2A.

Como estou usando o driver em Modo Passo Completo e, segundo o datasheet, nesse modo a corrente de enrolamento pode atingir apenas 70% do limite, 1.2A * 0.7 = 0.84A. Para verificar, carreguei um código simples que envia HIGH contínuo ao pino Step e conectei o multímetro em série com um enrolamento do motor. Obtive 0.5A, o que significa que a equação não foi correta para meu caso.

Código Arduino e A4988

Aqui está um código de exemplo. Primeiro, definimos os pinos Step e Direction (pinos 3 e 4 do Arduino, chamados stepPin e dirPin). No setup, definimos como saídas.

/* Exemplo Simples de Controle de Motor de Passo 
 * by Dejan Nedelkovski, www.HowToMechatronics.com 
 */
// Define números dos pinos
const int stepPin = 3;
const int dirPin = 4;

void setup() {
  // Define os dois pinos como saídas
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}

void loop() {
  digitalWrite(dirPin, HIGH); // Habilita motor a mover em uma direção
  // 200 pulsos para uma rotação completa
  for (int x = 0; x < 200; x++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }
  delay(1000); // Atraso de 1 segundo
  digitalWrite(dirPin, LOW); // Muda direção de rotação
  // 400 pulsos para duas rotações completas
  for (int x = 0; x < 400; x++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }
  delay(1000);
}

No loop, primeiro definimos o pino Direction como HIGH para mover em uma direção. Usando o loop for, fazemos o motor dar uma volta completa. Como o driver está em Passo Completo e nosso motor tem ângulo de passo de 1.8° (200 passos), precisamos enviar 200 pulsos ao pino Step. O loop for tem 200 iterações, cada uma definindo Step HIGH e LOW para criar os pulsos. O atraso entre cada digitalWrite determina a velocidade.

Após uma volta, esperamos 1 segundo, mudamos a direção para LOW e fazemos 2 voltas completas com loop de 400 iterações. No final, mais 1 segundo de atraso.

Fiz mais um exemplo controlando a velocidade com um potenciômetro. Aqui está o código:

/* Exemplo Simples de Controle de Motor de Passo 
 * by Dejan Nedelkovski, www.HowToMechatronics.com 
 */
// Define números dos pinos
const int stepPin = 3;
const int dirPin = 4;
int customDelay, customDelayMapped; // Variáveis

void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  digitalWrite(dirPin, HIGH); // Habilita direção
}

void loop() {
  customDelayMapped = speedUp(); // Obtém valores de atraso da função speedUp
  // Gera pulsos com atraso personalizado, dependendo do potenciômetro
  digitalWrite(stepPin, HIGH);
  delayMicroseconds(customDelayMapped);
  digitalWrite(stepPin, LOW);
  delayMicroseconds(customDelayMapped);
}

// Função para ler o potenciômetro
int speedUp() {
  int customDelay = analogRead(A0); // Lê potenciômetro
  int newCustom = map(customDelay, 0, 1023, 300, 4000); // Converte 0-1023 para atraso 300-4000
  return newCustom;
}