Como controlar um motor de passo com driver DRV8825 e Arduino

Tempo de leitura: 16 minutes

Este artigo inclui tudo o que você precisa saber sobre como controlar um motor de passo com o driver do motor de passo DRV8825 e o Arduino. Incluí um diagrama de fiação, um tutorial sobre como definir o limite de corrente e muitos códigos de exemplo.

Embora você possa usar este driver sem uma biblioteca Arduino, eu 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, descrevo e explico como o código funciona, então você não deve ter problemas para modificá-lo para atender às suas necessidades.

Suprimentos

Componentes de hardware

Driver de motor de passo DRV8825 × 1
Motor de passo NEMA 17 × 1
Arduino Uno Rev3 × 1
Fonte de alimentação (8,2-45 V) × 1
ProtoBoard × 1
Capacitor (100 µF) × 1
Jumper wires ~ 10
Cabo USB tipo A/B × 1

Eu gosto de usar este driver em combinação com um shield CNC ou placa de expansão. Essa blindagem já inclui capacitores e oferece uma maneira fácil de selecionar a resolução do 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 uma placa de ensaio.

 

Sobre o DRIVER

No coração do driver DRV8825, você encontrará um chip fabricado pela Texas Instruments: o DRV8825 Stepper Motor Controller IC. 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 45 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.

O chip de driver DRV8825 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ção DRV8825

Tensão mínima de operação 8.2 V
Tensão máxima de operação 45 V
Corrente contínua por fase 1.5 A
Corrente máxima por fase 2.2 A
Tensão lógica mínima 2.5 V
Tensão lógica máxima 5.25 V
Resolução de micropassos full, 1/2, 1/4, 1/8, 1/16 and 1/32
Proteção contra tensão reversa? No
Dimensões 15.5 × 20.5 mm (0.6″ × 0.8″)

Para mais informações pode consultar a ficha técnica DRV8825-Datasheet.

Diferenças entre DRV8825 e A4988

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

  • O DRV8825 oferece 1/32 microstepping, enquanto o A4988 desce apenas para 1/16-step. Microstepping mais alto resulta em operação mais suave e silenciosa, mas nem sempre é necessário.
  • O potenciômetro de limite de corrente está em um local diferente
  • A relação entre a tensão de referência e o limite de corrente é diferente.
  • O DRV8825 requer uma duração mínima de pulso STEP de 1,9 µs, o A4988 requer um mínimo de 1 µs.
  • O DRV8825 pode ser usado com uma fonte de alimentação do motor de alta 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 de corrente do que o A4988 sem nenhum resfriamento adicional.

Observe que a pinagem do DRV8825 é exatamente a mesma do A4988, então ele pode ser usado como substituto imediato!

Configurações de micropassos

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

Por exemplo, acionar um motor no modo de quarto de passo dará ao motor de 200 passos por revolução 800 micropassos por revolução usando quatro níveis de corrente diferentes.

Os pinos seletores de resolução (tamanho do passo) (M0, M1 e M2) permitem que você selecione uma das seis resoluções do passo de acordo com a tabela abaixo.

M0 M1 M2 Resolução de micropassos
Baixo Baixo Baixo Etapa completa
Alto Baixo Baixo 1/2 passo
Baixo Alto Baixo 1/4 passo
Alto Alto Baixo 1/8 passo
Baixo Baixo Alto 1/16 passo
Alto Baixo Alto 1/32 passo
Baixo Alto Alto 1/32 passo
Alto Alto Alto 1/32 passo

Todas as três entradas possuem resistores pull-down internos de 100 kΩ, portanto, deixar os três pinos de seleção de micropasso desconectados resulta no modo de passo completo.

Costumo usar um shield CNC ou placa de expansão em combinação com esses drivers. A placa de expansão possui 3 dip switches para definir M0 – M2 alto ou baixo e na blindagem do CNC você pode instalar jumpers. Se você estiver usando o driver com uma placa de ensaio, você pode simplesmente usar fios de jumper para conectar os pinos seletores a 5 V (ou seja, torná-los ALTO).

 

Ligação – Conectando DRV8825 ao Arduino e motor de passo

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

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

DRV8825 Connections

DRV8825 Conexão
VMOT 8.2-45 V
GND Terra do motor
SLP 5 V
RST 5 V
GND Aterramento lógico
STP Pino 3
DIR Pino 2
A1, A2, B1, B2 Motor de passo
  • A fonte de alimentação do motor é conectada ao GND e VMOT (canto superior direito).
  • As duas bobinas do motor de passo são conectadas a A1, A2 e B1, B2 (veja abaixo).
  • O pino GND (inferior direito) é conectado ao pino terra do microcontrolador e o VDD é conectado a 5V.
  • O pino STP (passo) e DIR (direção) são conectados aos pinos digitais 3 e 2, respectivamente. Você pode escolher um pino digital diferente, se quiser, mas esses são os que usei para este tutorial e o código de exemplo.
  • Você precisa conectar RST (reset) e SLP (sleep) a 5 V, caso contrário, o driver não liga.
  • O pino EN (ativar) pode ser deixado desconectado, ele é puxado para baixo por padrão. Quando este pino é definido como alto, o driver é desabilitado.
  • O DRV8825 também possui uma saída FAULT que reduz a velocidade sempre que os FETs da ponte H são desabilitados como resultado da proteção contra sobrecorrente ou desligamento térmico. Este pino é deixado desconectado para este tutorial.

No restante deste tutorial deixei M0, M1 e M3 desconectados, então o driver opera no modo full-step. Isso torna a explicação do código um pouco mais fácil. Normalmente eu usaria 1/16 ou 1/32 microstepping e conectaria os pinos apropriados a 5 V (veja a tabela na introdução).

 

Aviso

A placa portadora DRV8825 usa capacitores cerâmicos de baixo ESR, o que a torna suscetível a picos destrutivos de tensão LC, especialmente ao usar cabos de alimentação com 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).

 

Como determinar a fiação correta do motor de passo?

Se você não conseguir encontrar a folha de dados do seu motor de passo, pode ser difícil descobrir como conectar seu motor corretamente. Eu uso o seguinte truque para determinar como conectar motores de passo 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 são conectados a A1 e A2 e a outra a B1 e B2, a polaridade não importa.

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

  • Tente girar o eixo do motor de passo com a mão e observe como é difícil girar.
  • Agora pegue um par aleatório de fios do motor e toque as extremidades desencapadas.
  • Em seguida, tente girar o eixo do motor de passo novamente.

Se você sentir 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 de ligação acima.

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

 

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 esquece: definir o limite de corrente!

Esta etapa não é muito complicada, mas absolutamente necessária para proteger seu motor de passo e o driver. Se você não definir um limite de corrente apropriado, seu motor pode consumir mais corrente do que ele ou seu driver pode suportar, isso provavelmente danificará um ou ambos.

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

Para medir a tensão de referência, o driver precisa ser alimentado. O DRV8825 só precisa de energia via VMOT (8,2-45 V) e você precisa aplicar 5 V ao RST e SLP, caso contrário, o driver não liga. É melhor desconectar o motor de passo enquanto você faz isso.

Se você já conectou o driver como mostrei antes, você pode deixar o Arduino conectado para alimentar os pinos RST e SLP.

DRV8825 Conexão
VMOT 8.2-45 V
GND Motor Terra
SLP 5V
RST 5V
GND Logic Terra

 

Fórmula de limite atual

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

Limite de corrente = Vref × 2

Portanto, isso significa que para um limite de corrente de 1 A o Vref deve ser de 0,5 V.

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 de corrente de 1A. Você sempre pode aumentá-lo mais tarde se o seu motor/driver estiver faltando etapas.

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

Se o seu motor estiver fazendo muito barulho, tente diminuir o limite de corrente. É melhor definir o limite de corrente alto o suficiente para que o motor não perca 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 que você calculou.

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

Preciso girar o relógio do potenciômetro ou no sentido anti-horário para aumentar o Vref?
Isso depende do fabricante do driver. Se você tiver uma placa de fuga Polulu genuína do DRV8825 ou A4988, gire o potenciômetro no sentido horário para aumentar o Vref e no sentido anti-horário para abaixá-lo.

Resfriando o Driver

O driver IC DRV8825 tem uma corrente máxima de 2,5 A por bobina, mas sem um dissipador de calor, ele só pode fornecer cerca de 1,5 A por bobina antes de começar a superaquecer.

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

 

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

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

Este sketch controla a velocidade, o número de revoluções e a direção de rotação 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/DRV8825 e Arduino sem biblioteca. */

// Define stepper motor connections and steps per revolution:
#define dirPin 2
#define stepPin 3
#define stepsPerRevolution 200

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

void loop() {
  // Set the spinning direction clockwise:
  digitalWrite(dirPin, HIGH);

  // Spin the stepper motor 1 revolution slowly:
  for (int i = 0; i < stepsPerRevolution; i++) {
    // These four lines result in 1 step:
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(2000);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(2000);
  }

  delay(1000);

  // Set the spinning direction counterclockwise:
  digitalWrite(dirPin, LOW);

  // Spin the stepper motor 1 revolution quickly:
  for (int i = 0; i < stepsPerRevolution; i++) {
    // These four lines result in 1 step:
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(1000);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(1000);
  }

  delay(1000);

  // Set the spinning direction clockwise:
  digitalWrite(dirPin, HIGH);

  // Spin the stepper motor 5 revolutions fast:
  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);

  // Set the spinning direction counterclockwise:
  digitalWrite(dirPin, LOW);

  //Spin the stepper motor 5 revolutions fast:
  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.

// Define stepper motor connections and steps per revolution:
#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 OUTPUT digital com a função

pinMode()
void setup() {
  // Declare pins as output:
  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?

// Set the spinning direction clockwise:
 digitalWrite(dirPin, HIGH);

 // Spin the stepper motor 1 revolution slowly:
 for(int i = 0; i < stepsPerRevolution; i++)
 {
   // These four lines result in 1 step:
   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.

 

Instalando a 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.

<AccelStepper-1.59>

Você pode instalar a biblioteca indo em Sketch > Incluir Bliblioteca > Adicionar biblioteca .Zip… 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.

Ou

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 DRV8825, biblioteca AccelStepper e Arduino: rotação contínua. */

// Include the AccelStepper library:
#include <AccelStepper.h>

// Define stepper motor connections and motor interface type. Motor interface type must be set to 1 when using a driver:
#define dirPin 2
#define stepPin 3
#define motorInterfaceType 1

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);

void setup() {
  // Set the maximum speed in steps per second:
  stepper.setMaxSpeed(1000);
}

void loop() {
  // Set the speed in steps per second:
  stepper.setSpeed(400);
  // Step the motor with a constant speed as set by setSpeed():
  stepper.runS
}

Como o código funciona:

O primeiro passo é incluir a biblioteca com

#include <AccelStepper.h>

O próximo passo é definir as conexões do DRV8825 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.

// Define stepper motor connections and motor interface type. Motor interface type must be set to 1 when using a driver:
#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.

// Create a new instance of the AccelStepper class:
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() {
  // Set the maximum speed in steps per second:
  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() {
  // Set the speed in steps per second:
  stepper.setSpeed(400);
  // Step the motor with a constant speed as set by setSpeed():
  stepper.runSpeed();
}

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 DRV8825, biblioteca AccelStepper e Arduino: número de passos ou revoluções. */

// Include the AccelStepper library:
#include <AccelStepper.h>

// Define stepper motor connections and motor interface type. Motor interface type must be set to 1 when using a driver:
#define dirPin 2
#define stepPin 3
#define motorInterfaceType 1

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);

void setup() {
  // Set the maximum speed in steps per second:
  stepper.setMaxSpeed(1000);
}

void loop() { 
  // Set the current position to 0:
  stepper.setCurrentPosition(0);

  // Run the motor forward at 200 steps/second until the motor reaches 400 steps (2 revolutions):
  while(stepper.currentPosition() != 400)
  {
    stepper.setSpeed(200);
    stepper.runSpeed();
  }

  delay(1000);

  // Reset the position to 0:
  stepper.setCurrentPosition(0);

  // Run the motor backwards at 600 steps/second until the motor reaches -200 steps (1 revolution):
  while(stepper.currentPosition() != -200) 
  {
    stepper.setSpeed(-600);
    stepper.runSpeed();
  }

  delay(1000);

  // Reset the position to 0:
  stepper.setCurrentPosition(0);

  // Run the motor forward at 400 steps/second until the motor reaches 600 steps (3 revolutions):
  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)

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()
// Run the motor forward at 200 steps/second until the motor reaches 400 steps (2 revolutions):
  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.

 

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 DRV8825, biblioteca AccelStepper e Arduino: aceleração e desaceleração.*/

// Include the AccelStepper library:
#include <AccelStepper.h>

// Define stepper motor connections and motor interface type. Motor interface type must be set to 1 when using a driver:
#define dirPin 2
#define stepPin 3
#define motorInterfaceType 1

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);

void setup() {
  // Set the maximum speed and acceleration:
  stepper.setMaxSpeed(200);
  stepper.setAcceleration(30);
}

void loop() {
  // Set the target position:
  stepper.moveTo(600);
  // Run to target position with set speed and acceleration/deceleration:
  stepper.runToPosition();

  delay(1000);

  // Move back to 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() {
  // Set the maximum speed and acceleration:
  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.

// Set the target position:
 stepper.moveTo(600);
 // Run to target position with set speed and acceleration/deceleration:
 stepper.runToPosition();

 

Conclusão

Neste artigo, mostrei como controlar um motor de passo com o driver do motor de passo DRV8825 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 a 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: 1125689