Como controlar um motor de stepper com driver A4988 e Arduino

Tempo de leitura: 17 minutes

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

A4988 driver motor stepper × 1
Motor de passo NEMA 17 × 1
Arduino Uno Rev3 × 1
Fonte de alimentação (8-35 V) × 1
ProtoBoard × 1
Capacitor (100 μF) × 1
Fios de jumper ~ 10
Cabo USB tipo A/B

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

Chave de fenda pequena
Multímetro
Ponteira de Teste com Ponta de  jacaré (opcional)

 

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

Tensão de operação mínima 8 V
Tensão máxima de operação 35 V
Corrente contínua por fase 1 A
Corrente máxima por fase 2 A
Tensão lógica mínima 2 W
Máxima tensão lógica 5,5 V
Resolução de micropresas completo, 1/2, 1/4, 1/8 e 1/16
Proteção de tensão reversa? Não
Dimensões 15,5 × 20,5 mm (0,6″ × 0,8″)
Custar 16R$ a 37R$

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!

Configurações de micropresas

Os motores stepper normalmente têm um tamanho de passo de 1,8° ou 200 passos por revolução, isso se refere a etapas completas. Um driver de micropresagem como o A4988 permite resoluções mais altas, permitindo locais de passo intermediários. Isso é conseguido energizando as bobinas com níveis de corrente intermediários.

Por exemplo, dirigir um motor no modo de quarto passo dará ao motor 800 passos por revolução de 200 passos por revolução usando quatro níveis atuais diferentes.
Os pinos seletor de resolução (tamanho de etapa) (MS1, MS2 e MS3) permitem selecionar uma das resoluções de cinco etapas de acordo com a tabela abaixo.
LSP LSS MS3 Resolução de micropresas
Oot Oot Oot Passo completo
Alto Oot Oot passo 1/2
Oot Alto Oot passo 1/4
Alto Alto Oot passo 1/8
Alto Alto Alto passo 1/16

Todas as três entradas têm resistores internos de 100 kΩ pull-down, deixando os três pinos de seleção de micropredo desconectados resultam em modo de passo completo.

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

Diagrama/esquema de fiação para motor A4988 com motor Arduino e motor stepper.
Diagrama/esquema de fiação para motor A4988 com motor 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

A4988 Conexão
VMOT 8-35V
GND Aterramento do motor
SLP REPOR
RST SLP
VDD 5V
GND Terreno lógico
STP Pino 3
DIR Pino 2
1A, 1B, 2A, 2B Motor stepper
  • A fonte de alimentação do motor está conectada ao GND e VMOT (canto superior direito).
  • As duas bobinas do motor do estepe estão conectadas a 1A, 1B e 2A, 2B (veja abaixo).
  • O pino GND (inferior direito) está conectado ao pino de terra do microcontrolador e o VDD está conectado a 5V.
  • O pino STP (passo) e DIR (direção) estão conectados aos pinos digitais 3 e 2, respectivamente. Você pode escolher um pino digital diferente se quiser, mas estes são os que usei para este tutorial e o código de exemplo.
  • O pino SLP é uma entrada ativa baixa. Ou seja, puxar este pino baixo coloca o motorista em modo de sono, minimizando o consumo de energia. O RST também é uma entrada baixa ativa. Quando puxado para baixo, todas as entradas STEP são ignoradas até que você puxá-lo alto. Se você não estiver usando o pino, você pode conectá-lo ao pino SLP/SLEEP adjacente para trazê-lo alto e habilitar o driver.
  • O pino EN (habilitar) pode ser deixado desconectado, é puxado para baixo por padrão. Quando este pino está configurado alto, o motorista é desativado.

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!

Este passo não é muito complicado, mas absolutamente necessário para proteger o motor do estepe e o motorista. Se você não definir um limite de corrente apropriado, o motor pode desenhar mais corrente do que ele ou seu motorista pode manusear, isso provavelmente danificará um ou ambos.

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

Diagrama de ligação/esquema para driver de motor de passo A4988 com Arduino e motor de passo.
Diagrama de ligação/esquema para driver de motor de passo A4988 com Arduino e motor de passo.

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.

Se você já ligou o motorista, pode deixar tudo, menos o motor de passo conectado. Você pode aplicar energia através da porta USB do Arduino.
A4988 Conexão
VDD 5V
RST SLP
SLP RESET
GND Terra
Conexões necessárias para definir o limite atual

Fórmula de limite atual

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

Limite de corrente = Vref ÷ (8 × Rcs)

Os Rcs são a resistência atual dos sentidos. Se você comprou um driver A4988 da Pololu antes de janeiro de 2017, os Rcs serão 0,050 Ω. Drivers vendidos depois disso. 0,068 Ω resistores de sentido atuais.

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

Locais de resistor de sentido atual. Foto: www.pololu.com
Locais de resistor de sentido atual. Foto: www.pololu.com

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.

Informações sobre bônus: ao usar o driver no modo de etapa completa, a corrente através de cada bobina é limitada a aproximadamente 70% do limite de corrente definido. Isso significa que você precisaria definir o limite atual 40% maior ou 1,4 A no modo de etapa completa. Ao usar o microstepping, a fórmula acima se aplica.

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.

Pontos da sonda Vref (GND e potenciômetro).
Pontos da sonda Vref (GND e potenciômetro).

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.

Esse sketch controla a velocidade, o número de rotações e a direção giratória do motor de passo.
Você pode copiar o código clicando no botão no canto superior direito do campo de código.
/*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);
}

Como o código funciona:

O sketch começa com a definição dos pinos de passo e direção. Eu os conectei aos pinos 3 e 2 do Arduino.

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.

Eu também defini um

stepsPerRevolution

constante. Como configurei o driver para o modo de passo completo, configurei-o para 200 passos por revolução. Altere este valor se sua configuração for diferente.

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

No

setup()

seção do código, todos os pinos de controle do motor são declarados como SAÍDA digital com a função

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

No

loop()

seção do código, deixamos o motor girar uma revolução lentamente na direção CW e uma revolução rapidamente na direção CCW. Em seguida, deixamos o motor girar 5 rotações em cada direção com alta velocidade. Então, como você controla a velocidade, a direção de rotação e o número de revoluções?

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

Você pode instalar a biblioteca indo em Sketch > Include Library > Add .ZIP Library… no Arduino IDE.

Outra opção é navegar até Ferramentas > Gerenciar Bibliotecas… ou digitar Ctrl + Shift + I no Windows. O Library Manager abrirá e atualizará a lista de bibliotecas instaladas.

Você pode procurar por ‘accelstepper’ e procurar a biblioteca de Mike McCauley. Selecione a versão mais recente e clique em Instalar.

 

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.

Visits: 3 Visits: 1126433