Este artigo inclui tudo o que precisa de saber sobre como controlar um motor de passo com o A4988 driver de motor de passo e Arduino. Incluí um diagrama de ligação, um tutorial sobre como definir o limite de corrente e vários exemplos de código.
Embora possa usar este driver sem uma biblioteca Arduino, recomendo vivamente que também veja o 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.
Após cada exemplo, explico detalhadamente como o código funciona, para que não tenha problemas em modificá-lo conforme as suas necessidades.
Peças necessárias
Componentes de hardware
 | A4988 stepper motor driver | × 1 | Amazon |
 | NEMA 17 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Power supply (8-35 V) | × 1 | Amazon | |
| Breadboard | × 1 | Amazon | |
 | Capacitor (100 µF) | × 1 | Amazon |
| Jumper wires | ~ 10 | Amazon | |
| USB cable type A/B | × 1 | Amazon |
Gosto de usar este driver em combinação com um CNC-shield ou expansion board. Um shield destes já inclui condensadores e oferece uma forma fácil de selecionar a resolução do microstepping. Facilita muito as ligações e é uma ótima opção se precisar de uma solução mais permanente do que uma breadboard.
Ferramentas
Software
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Sobre o driver
No coração do driver A4988 encontra-se um chip fabricado pela Allegro MicroSystems: o A4988 DMOS Microstepping Driver com Translator e Proteção contra Sobrecorrente. Este driver integrado torna a interface com um microcontrolador muito simples, pois só precisa de dois pinos para controlar tanto a velocidade como 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 motores de passo pequenos a médios, como um NEMA 17 motor de passo bipolar.
Se precisar de controlar motores de passo maiores, como o NEMA 23, veja o driver TB6600. Este driver pode ser usado com o mesmo código do A4988 e tem uma classificação de corrente de 3,5 A.
O chip do driver A4988 tem várias funções de segurança integradas, como proteção contra sobrecorrente, curto-circuito, bloqueio por subtensão e proteção contra sobretemperatura. Pode encontrar mais especificações na tabela abaixo.
Especificações do A4988
| Tensão mínima de operação | 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 | 3 V |
| Tensão lógica máxima | 5,5 V |
| Resolução de microstep | passo completo, 1/2, 1/4, 1/8 e 1/16 |
| Proteção contra tensão inversa? | Não |
| Dimensões | 15,5 × 20,5 mm (0,6″ × 0,8″) |
| Custo | Check price |
Para mais informações, pode consultar o datasheet aqui.
Diferenças entre o A4988 e o DRV8825
O DRV8825 é bastante semelhante ao A4988, mas existem algumas diferenças importantes:
- O DRV8825 oferece microstepping de 1/32, enquanto o A4988 vai apenas até 1/16. Um microstepping mais elevado resulta num funcionamento mais suave e silencioso, mas nem sempre é necessário.
- O potenciômetro do limite de corrente está numa localização 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 do pulso STEP de 1,9µs; o A4988 requer no mínimo 1µs.
- O DRV8825 pode ser usado com uma fonte de alimentação de motor de tensão mais alta (45 V vs 35 V). Isto 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 necessidade de refrigeração adicional.
Note que o pinout do DRV8825 é exatamente o mesmo do A4988, por isso pode ser usado como substituto direto!
Configurações de microstep
Os motores de passo normalmente têm um passo de 1,8° ou 200 passos por revolução, referindo-se a passos completos. Um driver de microstepping como o A4988 permite resoluções mais altas ao permitir posições intermédias de passo. Isto é conseguido ao energizar as bobinas com níveis intermédios de corrente.
Por exemplo, conduzir um motor em modo de quarto de passo dará ao motor de 200 passos por revolução 800 microsteps por revolução, usando quatro níveis diferentes de corrente.
Os pinos seletor de resolução (MS1, MS2 e MS3) permitem selecionar uma das cinco resoluções de passo conforme a tabela abaixo.
| MS1 | MS2 | MS3 | Resolução de microstep |
|---|---|---|---|
| Baixo | Baixo | Baixo | Passo completo |
| Alto | Baixo | Baixo | 1/2 passo |
| Baixo | Alto | Baixo | 1/4 passo |
| Alto | Alto | Baixo | 1/8 passo |
| Alto | Alto | Alto | 1/16 passo |
Os três pinos têm resistores internos de pull-down de 100 kΩ, por isso deixar os três pinos de seleção de microstep desconectados resulta no modo de passo completo.
Costumo usar um CNC-shield ou placa de expansão em combinação com estes drivers. A placa de expansão tem 3 interruptores DIP para definir MS1 – MS3 como alto ou baixo e no CNC-shield pode instalar jumpers. Se estiver a usar o driver com uma breadboard, pode simplesmente usar fios jumper para ligar os pinos de seleção a 5 V (ou seja, torná-los HIGH).
Ligação – Conectar A4988 ao Arduino e motor de passo
O diagrama/esquemático acima mostra como ligar o driver A4899 a um motor de passo e ao Arduino. As ligações também são apresentadas na tabela seguinte:
Ligações do A4988
| A4988 | Ligação |
|---|---|
| VMOT | 8-35V |
| GND | Terra do motor |
| SLP | RESET |
| RST | SLP |
| VDD | 5V |
| GND | Terra lógico |
| STP | Pino 3 |
| DIR | Pino 2 |
| 1A, 1B, 2A, 2B | Motor de passo |
- A fonte de alimentação do motor está ligada a GND e VMOT (canto superior direito).
- As duas bobinas do motor de passo estão ligadas a 1A, 1B e 2A, 2B (ver abaixo).
- O pino GND (canto inferior direito) está ligado ao pino terra do microcontrolador e o VDD está ligado a 5V.
- Os pinos STP (step) e DIR (direção) estão ligados aos pinos digitais 3 e 2, respetivamente. Pode escolher outros pinos digitais se quiser, mas estes são os que usei para este tutorial e código de exemplo.
- O pino SLP é uma entrada ativa em nível baixo. Ou seja, puxar este pino para baixo coloca o driver em modo de suspensão, minimizando o consumo de energia. O RST também é uma entrada ativa em nível baixo. Quando puxado para baixo, todas as entradas STEP são ignoradas até que o puxe para cima. Se não estiver a usar este pino, pode ligá-lo ao pino SLP/SLEEP adjacente para o colocar em nível alto e ativar o driver.
- O pino EN (enable) pode ficar desconectado, pois é puxado para baixo por defeito. Quando este pino é colocado em nível alto, o driver é desativado.
No resto deste tutorial deixei MS1, MS2 e MS3 desconectados, por isso o driver opera em modo de passo completo. Isto facilita a explicação do código. Normalmente usaria microstepping de 1/8 ou 1/16 e ligaria os pinos apropriados a 5V (veja a tabela na introdução).
Aviso
A placa do A4988 usa condensadores cerâmicos de baixo ESR, o que a torna suscetível a picos destrutivos de tensão LC, especialmente quando usa cabos de alimentação com mais de alguns centímetros.
Para proteger o driver, pode ligar um condensador eletrolítico entre VMOT e GND. A Pololu sugere um condensador de 47 µF ou mais (eu usei um de 100 µF).
Como determinar a ligação correta do motor de passo?
Se não conseguir encontrar o datasheet do seu motor de passo, pode ser difícil descobrir como ligar o motor corretamente. Eu uso o seguinte truque para determinar como ligar motores de passo bipolares de 4 fios:
A única coisa que precisa identificar são os dois pares de fios que estão ligados às duas bobinas do motor. Os fios de uma bobina ligam-se a 1A e 1B e os da outra a 2A e 2B, a polaridade não importa.
Para encontrar os dois fios de uma bobina, faça o seguinte com o motor desligado:
- Tente rodar o eixo do motor de passo manualmente e note a dificuldade em girar.
- Agora escolha um par aleatório de fios do motor e toque as extremidades nuas uma na outra.
- Em seguida, tente rodar o eixo do motor de passo novamente.
Se sentir muita resistência, encontrou um par de fios da mesma bobina. Se conseguir rodar o eixo livremente, experimente outro par de fios. Agora ligue as duas bobinas aos pinos indicados no diagrama de ligação acima.
Como definir o limite de corrente?
Antes de começar a programar o seu Arduino e usar o driver, há uma coisa muito importante que precisa fazer e que muita gente esquece: definir o limite de corrente!
Este passo não é complicado, mas é absolutamente necessário para proteger o seu motor de passo e o driver. Se não definir um limite de corrente adequado, o motor pode puxar mais corrente do que ele ou o driver suportam, o que provavelmente danificará um ou ambos.
Para definir o limite de corrente, precisa medir uma tensão de referência e ajustar o potenciômetro a bordo em conformidade. Vai precisar de uma pequena chave de fendas, um multímetro para medir a tensão de referência e cabos de teste com garras jacaré (opcional, mas muito útil).
Para medir a tensão de referência, o driver precisa estar alimentado. O A4988 só precisa de energia via VDD (5V) e deve ligar RST e SLP juntos, caso contrário o driver não liga. É melhor desligar o motor de passo enquanto faz isto.
Se já tiver ligado o driver, pode deixar tudo ligado exceto o motor de passo. Pode alimentar o Arduino pela porta USB.
| A4988 | Ligação |
|---|---|
| VDD | 5V |
| RST | SLP |
| SLP | RESET |
| GND | Terra |
Fórmula do limite de corrente
O próximo passo é calcular o limite de corrente com a seguinte fórmula:
Limite de Corrente = Vref ÷ (8 × Rcs)
O Rcs é a resistência de deteção de corrente. Se comprou um driver A4988 da Pololu antes de janeiro de 2017, o Rcs será 0,050 Ω. Drivers vendidos depois disso têm 0,068 Ω resistores de deteção de corrente.
Isto significa que para um limite de corrente de 1A numa placa com resistores de 0,068 Ω, o Vref deve ser 540 mV.
Para selecionar o limite de corrente correto, consulte o datasheet do seu motor de passo. Se não encontrar a classificação de corrente do seu motor, recomendo começar com um limite de corrente de 1A. Pode sempre aumentar mais tarde se o motor/driver perder passos.
Quando usa o driver em modo de passo completo, a corrente em cada bobina é limitada a aproximadamente 70% do limite de corrente definido. Isto significa que deve definir o limite de corrente 40% mais alto, ou seja, 1,4 A em modo de passo completo. Quando usa microstepping, aplica-se a fórmula acima.
Note que precisa de recalibrar o limite de corrente se alterar a tensão da fonte de alimentação do motor. Se o seu motor estiver a fazer muito ruído, tente baixar o limite de corrente. É melhor definir o limite de corrente apenas alto o suficiente para que o motor não perca passos.
Medir Vref
Agora precisa medir a tensão de referência (Vref) entre os dois pontos marcados na imagem abaixo (GND e o potenciômetro) e ajustá-la para o valor que calculou.
Recomendo usar cabos de teste com garras jacaré presos à chave de fendas para definir o limite de corrente. Isto permite ajustar o potenciômetro e medir a tensão de referência ao mesmo tempo.
Nota: Existe outra forma de medir o limite de corrente, que é medir diretamente a corrente consumida pelo motor de passo. Pessoalmente, acho o método acima muito mais fácil.
Pololu menciona o seguinte no seu site:
Nota: A corrente na bobina pode ser muito diferente da corrente da fonte de alimentação, por isso não deve usar a corrente medida na fonte para definir o limite de corrente. O local apropriado para colocar o seu amperímetro é em série com uma das bobinas do motor de passo.
FAQ sobre limite de corrente
Preciso de ter o motor de passo ligado ou não?
Não, não precisa de ligar o motor de passo ao driver ao definir o limite de corrente. Para maior segurança, desligue o motor, pois por vezes interfere na medição da tensão Vref.
Preciso de fazer o motor girar executando o sketch do motor no Arduino?
Não, veja a resposta acima.
Preciso rodar o potenciômetro no sentido horário ou anti-horário para aumentar o Vref?
Isto depende do fabricante do driver. Se tiver uma placa original Pololu do DRV8825 ou A4988, rode o potenciômetro no sentido horário para aumentar o Vref e no sentido anti-horário para diminuir.
Refrigeração do driver
O chip do driver A4988 tem uma classificação máxima de corrente de 2 A por bobina, mas sem dissipador de calor só pode fornecer cerca de 1 A por bobina antes de começar a sobreaquecer.
O driver normalmente vem com um pequeno dissipador de calor autocolante, que recomendo instalar imediatamente. Também pode comprar vários pequenos heat sinks na Amazon por um preço muito baixo.
Código de exemplo básico Arduino para controlar um motor de passo
Agora que ligou o driver e definiu o limite de corrente, é hora de ligar o Arduino ao computador e carregar algum código. Pode carregar o seguinte código de exemplo no seu Arduino usando o Arduino IDE. Para este exemplo específico, não precisa de 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.
// Example sketch to control a stepper motor with A4988 stepper motor driver
// and Arduino without a library.
// https://www.makerguides.com
// 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 por definir os pinos de step e direção. Eu liguei-os aos pinos 3 e 2 do Arduino.
A instrução #define é usada para dar um nome a um valor constante. O compilador substituirá todas as referências a esta constante pelo valor definido quando o programa for compilado. Assim, em todo o lado onde mencionar dirPin, o compilador substituirá pelo valor 2 quando o programa for compilado.
Também defini uma constante stepsPerRevolution . Como defini o driver em modo de passo completo, defini 200 passos por revolução. Altere este valor se o seu setup for diferente.
// Define stepper motor connections and steps per revolution #define dirPin 2 #define stepPin 3 #define stepsPerRevolution 200
setup
Na secção setup() do código, todos os pinos de controlo do motor são declarados como OUTPUT digitais com a função pinMode().
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
loop
Na secção loop() do código, deixamos o motor girar uma revolução lentamente no sentido horário (CW) e uma revolução rapidamente no sentido anti-horário (CCW). Depois, deixamos o motor girar 5 revoluções em cada direção a alta velocidade. Então, como controlar a velocidade, direção de rotação e 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);
}
Controlar a direção de rotação:
Para controlar a direção de rotação do motor de passo, definimos o pino DIR (direção) como HIGH ou LOW. Para isso usamos a função digitalWrite(). Dependendo de como ligou o motor de passo, definir o pino DIR como alto fará o motor girar no sentido horário ou anti-horário.
Controlar o número de passos ou revoluções:
Neste sketch de exemplo, os ciclos for controlam o número de passos que o motor de passo dará. O código dentro do ciclo for resulta num passo do motor. Como o código no ciclo é executado 200 vezes (stepsPerRevolution), isso resulta numa revolução. Nos dois últimos ciclos, o código dentro do for é executado 1000 vezes, o que resulta em 1000 passos ou 5 revoluções.
Note que pode alterar o segundo termo no ciclo for para o número de passos que quiser. for(int i = 0; i < 100; i++) resultaria em 100 passos, ou meia revolução.
Controlar a velocidade:
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 roda. Pode controlar a frequência dos pulsos alterando delayMicroseconds() no código. Quanto menor o delay, maior a frequência, mais rápido o motor roda.
Tutorial da biblioteca AccelStepper
A biblioteca AccelStepper, escrita por Mike McCauley, é uma biblioteca fantástica para usar no seu projeto. Uma das vantagens é que suporta aceleração e desaceleração, mas tem muitas outras funções úteis.
Pode descarregar a versão mais recente desta biblioteca clicando no botão abaixo.
Pode instalar a biblioteca indo a Sketch > Include Library > Add .ZIP Library… no IDE do Arduino.
Outra opção é navegar para Tools > Manage Libraries… ou pressionar Ctrl + Shift + I no Windows. O Gestor de Bibliotecas abrirá e atualizará a lista de bibliotecas instaladas.
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 para rotação contínua
O seguinte sketch pode ser usado para fazer um ou mais motores de passo rodarem continuamente a uma velocidade constante. (Não é usada aceleração nem desaceleração).
/* Example sketch to control a stepper motor with A4988 stepper motor driver, AccelStepper library and Arduino: continuous rotation.Homepage*/ // 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.runSpeed(); }
Como o código funciona:
O primeiro passo é incluir a biblioteca com #include "AccelStepper.h".
// Include the AccelStepper library: #include "AccelStepper.h"
O passo seguinte é definir as ligações do A4988 ao Arduino e o tipo de interface do motor. O tipo de interface do motor deve ser definido como 1 quando se usa um driver de step e direction. Pode encontrar os outros tipos de interface here.
A instrução #define é usada para dar um nome a um valor constante. O compilador substituirá todas as referências a esta constante pelo valor definido quando o programa for compilado. Assim, em todo o lado onde mencionar dirPin, o compilador 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
De seguida, precisa criar uma nova instância da classe AccelStepper com o tipo de interface do motor e ligações apropriadas.
Neste caso, chamei o motor de passo ‘stepper’, mas pode usar outros nomes, como ‘z_motor’ ou ‘liftmotor’, etc. AccelStepper liftmotor = AccelStepper(motorInterfaceType, stepPin, dirPin);. O nome que der ao motor de passo será usado mais tarde para definir a velocidade, posição e aceleração desse motor em particular. Pode criar múltiplas instâncias da classe AccelStepper com nomes e pinos diferentes. Isto permite controlar facilmente 2 ou mais motores de passo ao mesmo tempo.
// Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);
Na secção setup() do código definimos a velocidade máxima em passos/segundo. Velocidades superiores a 1000 passos por segundo podem ser pouco fiáveis, por isso defini este valor como máximo. Note que especifico o nome do motor de passo (‘stepper’) para o qual quero definir a velocidade máxima. Se tiver vários motores de passo ligados, pode especificar uma velocidade diferente para cada motor:
void setup() {
// Set the maximum speed in steps per second:
stepper.setMaxSpeed(1000);
stepper2.setMaxSpeed(500);
}
Na loop() definimos primeiro a velocidade a que queremos que o motor funcione. Para isso usamos a função setSpeed(). (também pode colocar isto na secção setup do código).
stepper.runSpeed() faz a sondagem do motor e, quando é devido um passo, executa 1 passo. Isto depende da velocidade definida e do tempo desde o último passo. Se quiser mudar a direção do motor, pode definir uma velocidade negativa: stepper.setSpeed(-400); faz o motor girar no sentido oposto.
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();
}
2. Código de exemplo para controlar o número de passos ou revoluções
Para fazer o motor rodar um número específico de passos, prefiro usar um ciclo while em combinação com stepper.currentPosition(). Pode usar o seguinte código de exemplo para fazer o motor rodar para a frente e para trás.
/* Example sketch to control a stepper motor with A4988 stepper motor driver, AccelStepper library and Arduino: number of steps or revolutions.Homepage*/ // 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é à secção loop() é exatamente igual ao exemplo anterior.
No loop uso um ciclo while em combinação com a função currentPosition() . Primeiro, defino a posição atual do motor de passo para zero com stepper.setCurrentPosition(0).
// Set the current position to 0: stepper.setCurrentPosition(0);
De seguida usamos o ciclo while. Um ciclo while repete-se continuamente, e infinitamente, até que a expressão dentro dos parênteses () se torne falsa. Assim, neste caso, verifico se a posição atual do motor de passo não é igual a 400 passos (!= significa: não é igual a). Enquanto isto for verdade, fazemos o motor de passo rodar a uma velocidade constante definida 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, só que com uma velocidade e posição alvo diferentes.
3. Código de exemplo para aceleração e desaceleração
Com o seguinte sketch, pode adicionar aceleração e desaceleração aos movimentos do motor de passo, sem qualquer codificação complicada. No exemplo seguinte, o motor roda para a frente e para trás a uma velocidade de 200 passos por segundo e uma aceleração de 30 passos por segundo ao quadrado.
/* Example sketch to control a stepper motor with A4988 stepper motor driver, AccelStepper library and Arduino: acceleration and deceleration.Homepage*/ // 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 secção loop do código, usei uma forma diferente de fazer o motor rodar um número pré-definido de passos. A função stepper.moveTo() é usada para definir a posição alvo. A função stepper.runToPostion() move o motor (com aceleração/desaceleração) para a posição alvo e bloqueia até lá chegar. Como esta função é bloqueante, não deve usá-la se precisar de 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 A4988 e Arduino. Espero que tenha sido útil e informativo. Eu próprio usei muito este driver em várias impressoras 3D e outros projetos relacionados com CNC.
Se quiser aprender mais sobre outros drivers de motor de passo, os artigos abaixo podem ser úteis:
- How to control a stepper motor with DRV8825 driver and Arduino
- 28BYJ-48 Stepper Motor with ULN2003 Driver and Arduino Tutorial
- How to control a Stepper Motor with Arduino Motor Shield Rev3
- TB6600 Stepper Motor Driver with Arduino Tutorial
Também tenho um artigo sobre How To Drive a Stepper Motor using the A4988 driver and ESP32 se quiser trabalhar com um microcontrolador ESP32 em vez disso.
Se tiver alguma dúvida ou achar que falta alguma coisa, por favor deixe um comentário abaixo.
