Como controlar um motor de stepper com driver A4988 e Arduino

Este artigo inclui tudo o que você precisa saber sobre o controle de um motor stepper com o motor A4988 stepper e Arduino. Incluí um diagrama de ligação, um tutorial sobre como definir o limite atual e muitos códigos de exemplo.

Embora você possa usar este driver sem uma biblioteca Arduino, recomendo que você também dê uma olhada no código de exemplo para a biblioteca AccelStepper no final deste tutorial. Esta biblioteca é bastante fácil de usar e pode melhorar muito o desempenho do seu hardware.

Depois de cada exemplo, eu desvirtuo e explico como o código funciona, então você não deve ter problemas em modificá-lo para atender às suas necessidades.

Suprimentos

Componentes de hardware

Gosto de usar este driver em combinação com um shield CNC ou placa de expansão. Tal shield já inclui capacitores e oferece uma maneira fácil de selecionar a resolução de microstepping. Torna a ligação muito mais fácil e é uma ótima opção se você precisar de uma solução mais permanente do que um ProtoBoard.

Ferramentas

Software

Arduino IDE (Versão mais recente)

Sobre o DRIVER

No coração do driver A4988, você encontrará um chip fabricado pela Allegro MicroSystems: o driver A4988 DMOS Microstepping com tradutor e proteção contra sobrecorrente. Este driver de motor integrado torna a interface com um microcontrolador super fácil, pois você só precisa de dois pinos para controlar a velocidade e a direção do motor de passo.

O driver tem uma capacidade máxima de saída de 35 V e ± 2 A, o que é ótimo para acionar motores de passo de pequeno a médio porte, como um motor de passo bipolar NEMA 17.

Se você precisar controlar motores de passo maiores como o NEMA 23, dê uma olhada no driver do motor de passo TB6600. Este driver pode ser usado com o mesmo código do A4988 e possui corrente nominal de 3,5 A.

O chip de driver A4988 possui várias funções de segurança integradas, como sobrecorrente, curto-circuito, bloqueio de subtensão e proteção contra temperatura excessiva. Você pode encontrar mais especificações na tabela abaixo.

Especificações A4988

Para mais informações você pode conferir o datashild aqui.

Diferenças entre o A4988 e o DRV8825

O DRV8825 é bastante semelhante ao A4988, mas existem algumas diferenças importantes:

• O DRV8825 oferece 1/32 de microstepping, enquanto o A4988 só desce para 1/16 passos. Microempresas mais altas resultam em uma operação mais suave e silenciosa, mas nem sempre é necessária.
• O potencialiômetro de limite atual está em um local diferente
• A relação entre a tensão de referência e o limite atual é diferente.
• O DRV8825 requer uma duração mínima de pulso STEP de 1,9μs; o A4988 requer 1μs mínimos.
• O DRV8825 pode ser usado com uma fonte de alimentação motora de maior tensão (45 V vs 35 V). Isso significa que é menos suscetível a danos causados por picos de tensão LC.
• O DRV8825 pode fornecer um pouco mais atual do que o A4988 sem qualquer resfriamento adicional.

Observe que o pinout do DRV8825 é exatamente o mesmo do A4988, por isso pode ser usado como uma substituição drop-in!

Eu costumo usar um shield CNC ou placa de expansão em combinação com esses drivers. A placa de expansão tem 3 interruptores de mergulho para definir MS1 – MS3 alto ou baixo e no escudo CNC você pode instalar jumpers. Se você estiver usando o driver com uma prancha, você pode apenas usar fios de jumper para conectar os pinos seletor a 5 V (ou seja, torná-los HIGH).

Ligação – Conectando A4988 a Arduino e motor stepper

O diagrama/esquema de ligação acima mostra como conectar o driver A4899 a um motor steeper e ao Arduino.

As conexões também são dadas na tabela a seguir:

Conexões A4988

No resto deste tutorial eu deixei MS1, MS2 e MS3 desconectados, para que o motorista opere no modo de passo completo. Isso torna a explicação do código um pouco mais fácil. Normalmente eu usaria 1/8 ou 1/16 microstepping e conectaria os pinos apropriados a 5V (veja a tabela na introdução).

Aviso

A placa portadora A4988 usa capacitores cerâmicos de baixa ESR, o que o torna suscetível a picos destrutivos de tensão LC, especialmente quando se usa cabos de energia por mais de alguns centímetros.

Para proteger o driver, você pode conectar um capacitor eletrolítico entre VMOT e GND. Pololu sugere um capacitor de 47 μF ou mais (usei um capacitor de 100 μF). Eu gosto dessas caixas variadas da Amazon, assim eu sempre tenho alguns capacitores do tamanho certo na mão.

Como determinar a ligação correta do motor stepper?

Se você não consegue encontrar o datasheld do seu motor stepper, pode ser difícil descobrir como ligar seu motor corretamente. Uso o seguinte truque para determinar como conectar motores de estepe bipolares de 4 fios:

A única coisa que você precisa identificar são os dois pares de fios que estão conectados às duas bobinas do motor. Os fios de uma bobina ficam conectados a 1A e 1B e o outro a 2A e 2B, a polaridade não importa.

Para encontrar os dois fios de uma bobina, faça o seguinte com o motor desconectado:

1. Tente girar o eixo do motor stepper à mão e observe como é difícil girar.
2. Agora escolha um par aleatório de fios do motor e toque as pontas nuas juntos.
3. Em seguida, tente girar o eixo do motor stepper novamente.

Se você sente muita resistência, você encontrou um par de fios da mesma bobina. Se você puder girar o eixo livremente, tente outro par de fios. Agora conecte as duas bobinas aos pinos mostrados no diagrama da fiação acima.

(Se ainda não estiver claro, por favor deixe um comentário abaixo, mais informações também podem ser encontradas na RepRap.org wiki)

Como definir o limite atual?

Antes de começar a programar seu Arduino e começar a usar o driver há uma coisa muito importante que você precisa fazer que muita gente esqueça: defina o limite atual!

Para definir o limite atual, você precisa medir uma tensão de referência e ajustar o potenciômetro a bordo de acordo. Você precisará de uma pequena chave de fenda, um multímetro para medir a tensão de referência e os cabos de teste de jacaré (opcional, mas muito útil).

Para medir a tensão de referência, o driver precisa ser alimentado. O A4988 precisa apenas de energia via VDD (5V) e você precisa conectar RST e SLP juntos, caso contrário, o driver não será ligado. É melhor desconectar o motor de passo enquanto você faz isso.

Fórmula de limite atual

O próximo passo é calcular o limite atual com a seguinte fórmula :

Limite de corrente = Vref ÷ (8 × Rcs)

Portanto, isso significa que, para um limite atual de 1A para uma placa com resistores de sentido de corrente de 0,068 Ω, o Vref deve ser de 540 mV

Para selecionar o limite de corrente correto, dê uma olhada na folha de dados do seu motor de passo. Se você não encontrar a classificação atual do seu motor, recomendo começar com um limite atual de 1A. Você sempre pode aumentá-lo mais tarde se o seu motor / motorista estiver faltando etapas.

Observe que você precisa recalibrar o limite de corrente se alterar a tensão da fonte de alimentação do motor. Se o seu motor estiver fazendo muito barulho, tente diminuir o limite atual. É melhor definir o limite atual apenas alto o suficiente para que o motor não perca as etapas.

Medindo Vref

Agora você precisará medir a tensão de referência (Vref) entre os dois pontos marcados na figura abaixo (GND e o potenciômetro) e ajustá-la ao valor calculado.

Eu recomendo usar cabos de teste do jacaré preso à chave de fenda para definir o limite atual. Isso permite ajustar o potenciômetro e medir a tensão de referência ao mesmo tempo.

Nota: Existe outra maneira de medir o limite atual e medir diretamente o consumo atual do motor de passo. Pessoalmente, acho o método acima muito mais fácil.

Pololu menciona o seguinte em seu site:

Nota: A corrente da bobina pode ser muito diferente da corrente da fonte de alimentação, portanto, você não deve usar a corrente medida na fonte de alimentação para definir o limite atual. O local apropriado para colocar seu medidor atual é em série com uma de suas bobinas de motor de passo.

Pololu

Perguntas frequentes sobre o limite atual

Preciso ter o motor de passo conectado ou não?
Não, você não precisa conectar o motor do passe ao motor ao definir o limite anual. Para o lado do trabalho seguro, desconecte o motor, os veios interferem na mídia da tensão Vref.

Preciso ligar o motor executando o sketch do motor Arduino?
Não, veja a pergunta acima.

Preciso girar o potenciômetro no sentido horário ou anti-horário para aumentar o Vref?
Isso depende do fabricante do driver. Se você tiver uma placa de interrupção Polulu genérica do DRV8825 ou A4988, consulte o potenciômetro no sentido histórico para o comentário do Vref e o novo sentido anti-horário para abaixá-lo.

Resfriando o Driver

O IC do driver A4988 tem uma classificação atual máxima de 2A por bobina, mas sem um dissipador de calor, ele só pode fornecer cerca de 1A por bobina antes de começar a superaquecer.

O motorista geralmente vem com um pequeno dissipador de calor com adesivo, que eu recomendo que você instale imediatamente.

Código básico de exemplo do Arduino para controlar um motor de passo

Agora que você conectou o driver e definiu o limite atual, é hora de conectar o Arduino ao computador e fazer upload de algum código. Você pode fazer o upload do seguinte código de exemplo para o seu Arduino usando o IDE do Arduino Para este exemplo específico, você não precisa instalar nenhuma biblioteca.

/*Sketch de exemplo para controlar um motor de passo com driver de motor de passo A4988 e Arduino sem biblioteca. */

// Defina as conexões do motor de passo e os passos por revolução:
#define dirPin 2
#define stepPin 3
#define stepsPerRevolution 200

void setup() {
  // Declare pins as output:
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}

void loop() {
  // Ajuste o sentido de rotação no sentido horário:
  digitalWrite(dirPin, HIGH);

  // Gire o motor de passo 1 volta lentamente:
  for (int i = 0; i < stepsPerRevolution; i++) {
    // Essas quatro linhas resultam em 1 passo:
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(2000);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(2000);
  }

  delay(1000);

  // Defina o sentido de rotação no sentido anti-horário:
  digitalWrite(dirPin, LOW);

  // Gire o motor de passo 1 volta rapidamente:
  for (int i = 0; i < stepsPerRevolution; i++) {
    // Essas quatro linhas resultam em 1 passo:
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(1000);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(1000);
  }

  delay(1000);

  // Ajuste o sentido de rotação no sentido horário:
  digitalWrite(dirPin, HIGH);

  // Gire o motor de passo 5 rotações rapidamente:
  for (int i = 0; i < 5 * stepsPerRevolution; i++) {
    // Essas quatro linhas resultam em 1 passo:
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }

  delay(1000);

  // Defina o sentido de rotação no sentido anti-horário:
  digitalWrite(dirPin, LOW);

  //Gire o motor de passo 5 rotações rapidamente:
  for (int i = 0; i < 5 * stepsPerRevolution; i++) {
    // These four lines result in 1 step:
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }

  delay(1000);
}

#define

dirPin

stepsPerRevolution

// Defina as conexões do motor de passo e os passos por revolução:
#define dirPin 2
#define stepPin 3
#define stepsPerRevolution 200

setup()

pinMode()

void setup() {
  // Declare os pinos como saída:
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}

loop()

// Ajuste o sentido de rotação no sentido horário:
  digitalWrite(dirPin, HIGH);

  // Gire o motor de passo 1 volta lentamente:
  for(int i = 0; i < stepsPerRevolution; i++)
  {
    // Essas quatro linhas resultam em 1 passo:
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(2000);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(2000);
  }

Controle de direção de ligação:

Para controlar a direção de rotação do motor de passo, configuramos o pino DIR (direção) como HIGH ou LOW. Para isso usamos a função

digitalWrite()

Dependendo de como você conectou o motor de passo, definir o pino DIR alto permitirá que o motor gire no sentido horário ou anti-horário.

Controlar o número de passos ou revoluções:

Neste Sketch de exemplo, os loops for controlam o número de etapas que o motor de passo dará. O código dentro do loop for resulta em 1 etapa do motor de passo. Como o código no loop é executado 200 vezes (stepsPerRevolution), isso resulta em 1 revolução. Nos dois últimos loops, o código dentro do loop for é executado 1000 vezes, o que resulta em 1000 passos ou 5 revoluções.

Observe que você pode alterar o segundo termo no loop for para qualquer número de etapas que desejar.

for(int i = 0; i < 100; i++)

resultaria em 100 passos, ou meia revolução.

Velocidade de controle:

A velocidade do motor de passo é determinada pela frequência dos pulsos que enviamos ao pino STEP. Quanto maior a frequência, mais rápido o motor funciona. Você pode controlar a frequência dos pulsos alterando

delayMicroseconds()

no código. Quanto menor o atraso, quanto maior a frequência, mais rápido o motor funciona.

Tutorial da biblioteca AccelStepper

A biblioteca AccelStepper escrita por Mike McCauley é uma biblioteca incrível para usar em seu projeto. Uma das vantagens é que ele suporta aceleração e desaceleração, mas também possui muitas outras funções interessantes.

Você pode baixar a versão mais recente desta biblioteca aqui ou clicar no botão abaixo.

1. Código de exemplo de rotação contínua

O sketch a seguir pode ser usado para operar um ou mais motores de passo continuamente a uma velocidade constante. (Nenhuma aceleração ou desaceleração é usada).

/*Sketch de exemplo para controlar um motor de passo com driver de motor de passo A4988, biblioteca AccelStepper e Arduino: rotação contínua.*/

// Inclua a biblioteca AccelStepper:
#include <AccelStepper.h>

// Defina as conexões do motor de passo e o tipo de interface do motor. O tipo de interface do motor deve ser definido como 1 ao usar um driver:
#define dirPin 2
#define stepPin 3
#define motorInterfaceType 1

// Crie uma nova instância da classe AccelStepper:
AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);

void setup() {
  // Defina a velocidade máxima em passos por segundo:
  stepper.setMaxSpeed(1000);
}

void loop() {
  // Defina a velocidade em passos por segundo:
  stepper.setSpeed(400);
  // Pise o motor com uma velocidade constante conforme definido por setSpeed():
  stepper.runSpeed();
}

Como o código funciona:

O primeiro passo é incluir a biblioteca com

#include <AccelStepper.h>

O próximo passo é definir as conexões do A4988 para o Arduino e o tipo de interface do motor. O tipo de interface do motor deve ser definido como 1 ao usar um driver de passo e direção. Você pode encontrar os outros tipos de interface aqui.

A declaração

#define

é usado para dar um nome a um valor constante. O compilador substituirá quaisquer referências a esta constante pelo valor definido quando o programa for compilado. Então em todos os lugares que você menciona

dirPin

o compilador o substituirá pelo valor 2 quando o programa for compilado.

// Defina as conexões do motor de passo e os passos por revolução: 
#define dirPin 2
#define stepPin 3
#define motorInterfaceType 1

Em seguida, você precisa criar uma nova instância da classe AccelStepper com o tipo de interface do motor e conexões apropriados.

Neste caso, chamei o motor de passo de ‘stepper’, mas você também pode usar outros nomes, como ‘z_motor’ ou ‘liftmotor’ etc.

AccelStepper liftmotor = AccelStepper(motorInterfaceType, stepPin, dirPin);

O nome que você der ao motor de passo será usado posteriormente para definir a velocidade, a posição e a aceleração desse motor específico. Você pode criar várias instâncias da classe AccelStepper com nomes e pinos diferentes. Isso permite que você controle facilmente 2 ou mais motores de passo ao mesmo tempo.

// Crie uma nova instância da classe AccelStepper:
AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);

No

setup()

seção do código definimos a velocidade máxima em passos/segundo. Velocidades de mais de 1.000 passos por segundo podem não ser confiáveis, então defino isso como o máximo. Observe que eu especifico o nome do motor de passo (“stepper”), para o qual quero definir a velocidade máxima. Se você tiver vários motores de passo conectados, poderá especificar uma velocidade diferente para cada motor:

void setup() {
  // Defina a velocidade máxima em passos por segundo:
  stepper.setMaxSpeed(1000);
  stepper2.setMaxSpeed(500);
}

No

loop()

primeiro definimos a velocidade em que queremos que o motor funcione. Para isso, usamos a função

setSpeed()

. (você também pode colocar isso na seção de configuração do código).

stepper.runSpeed()

sonda o motor e quando uma etapa está vencida, executa 1 etapa. Isso depende da velocidade definida e do tempo desde a última etapa. Se você quiser mudar a direção do motor, você pode definir uma velocidade negativa:

stepper.setSpeed(-400);

gira o motor para o outro lado.

void loop() {
  // Define a velocidade em passos por segundo:
  stepper.setSpeed(400);
  // Avança o motor com uma velocidade constante conforme definido por setSpeed():
  stepper.runSpeed();
}

2. Código de exemplo para controlar o número de passos ou revoluções

Para deixar o motor girar um número específico de etapas, prefiro usar um loop while em combinação com

stepper.currentPosition()

Você pode usar o código de exemplo a seguir, para deixar o motor funcionar para frente e para trás.

/*Sketch de exemplo para controlar um motor de passo com driver de motor de passo A4988, biblioteca AccelStepper e Arduino: número de passos ou revoluções.*/

// Inclui a biblioteca AccelStepper:
#include <AccelStepper.h>

// Define as conexões do motor de passo e o tipo de interface do motor. O tipo de interface do motor deve ser definido como 1 ao usar um driver:
#define dirPin 2
#define stepPin 3
#define motorInterfaceType 1

// Cria uma nova instância da classe AccelStepper:
AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);

void setup() {
  // Define a velocidade máxima em passos por segundo:
  stepper.setMaxSpeed(1000);
}

void loop() { 
  // Define a posição atual para 0:
  stepper.setCurrentPosition(0);

  // Roda o motor para frente a 200 passos/segundo até que o motor atinja 400 passos (2 rotações):
  while(stepper.currentPosition() != 400)
  {
    stepper.setSpeed(200);
    stepper.runSpeed();
  }

  delay(1000);

  // Redefinir a posição para 0:
  stepper.setCurrentPosition(0);

  // Gira o motor para trás a 600 passos/segundo até que o motor atinja -200 passos (1 revolução):
  while(stepper.currentPosition() != -200) 
  {
    stepper.setSpeed(-600);
    stepper.runSpeed();
  }

  delay(1000);

  // Redefinir a posição para 0:
  stepper.setCurrentPosition(0);

  // Roda o motor para frente a 400 passos/segundo até que o motor atinja 600 passos (3 rotações):
  while(stepper.currentPosition() != 600)
  {
    stepper.setSpeed(400);
    stepper.runSpeed();
  }

  delay(3000);
}

Explicação do código:

A primeira parte do código até a seção loop() é exatamente a mesma do exemplo anterior.

No loop eu uso um loop while em combinação com o

currentPosition()

função. Primeiro, defino a posição atual do motor de passo para zero com

stepper.setCurrentPosition(0)

// Defina a posição atual para 0:
stepper.setCurrentPosition(0);

Em seguida, fazemos uso do loop while. Um loop while fará um loop contínuo e infinito, até que a expressão entre parênteses, () se torne falsa. Então, neste caso, verifico se a posição atual do motor de passo não é igual a 400 passos (!= significa: não é igual a). Embora este não seja o caso, operamos o motor de passo a uma velocidade constante, conforme definido por

setSpeed()

// Faça o motor avançar a 200 passos/segundo até que o motor atinja 400 passos (2 rotações):
while(stepper.currentPosition() != 400)
{
  stepper.setSpeed(200);
  stepper.runSpeed();
}

No resto do loop, fazemos exatamente o mesmo, apenas com uma velocidade e posição alvo diferentes.

3. Código de exemplo de aceleração e desaceleração

Com o sketch a seguir, você pode adicionar aceleração e desaceleração aos movimentos do motor de passo, sem nenhuma codificação complicada. No exemplo a seguir, o motor funcionará para frente e para trás com uma velocidade de 200 passos por segundo e uma aceleração de 30 passos por segundo por segundo.

/*Sketch de exemplo para controlar um motor de passo com driver de motor de passo A4988, biblioteca AccelStepper e Arduino: aceleração e desaceleração.*/

// Inclua a biblioteca AccelStepper:
#include <AccelStepper.h>

// Defina as conexões do motor de passo e o tipo de interface do motor. O tipo de interface do motor deve ser definido como 1 ao usar um driver:
#define dirPin 2
#define stepPin 3
#define motorInterfaceType 1

// Crie uma nova instância da classe AccelStepper:
AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);

void setup() {
  // Defina a velocidade e aceleração máximas:
  stepper.setMaxSpeed(200);
  stepper.setAcceleration(30);
}

void loop() {
  // Defina a posição alvo:
  stepper.moveTo(600);
  // Corra para a posição alvo com velocidade e aceleração/desaceleração definidas:
  stepper.runToPosition();

  delay(1000);

  // Voltar para zero:
  stepper.moveTo(0);
  stepper.runToPosition();

  delay(1000);
}

Explicação do código:

No setup(), além da velocidade máxima, precisamos definir a aceleração/desaceleração. Para isso usamos a função

setAcceleration()

void setup() {
  // Defina a velocidade e aceleração máximas:
  stepper.setMaxSpeed(200);
  stepper.setAcceleration(30);
}

Na seção de loop do código, usei uma maneira diferente de deixar o motor girar um número predefinido de etapas. A função

stepper.moveTo()

é usado para definir a posição de destino. A função

stepper.runToPostion()

move o motor (com aceleração/desaceleração) para a posição alvo e bloqueia até que esteja na posição alvo. Como essa função está bloqueando, você não deve usá-la quando precisar controlar outras coisas ao mesmo tempo.

// Defina a posição alvo:
stepper.moveTo(600);
// Corra para a posição alvo com velocidade e aceleração/desaceleração definidas:
stepper.runToPosition();

Conclusão

Neste artigo, mostrei como controlar um motor de passo com o driver do motor de passo A4988 e o Arduino. Espero que tenha achado útil e informativo. Se você gostou, compartilhe com um amigo que também gosta de eletrônicos e de fazer coisas!

Eu pessoalmente usei muito esse driver para várias impressoras 3D e outros projetos relacionados ao CNC, mas adoraria saber quais projetos você planeja construir (ou já construiu) com esse driver. Se você tiver alguma dúvida, sugestão ou se achar que algo está faltando neste tutorial, deixe um comentário abaixo.