Neste artigo, vais aprender como controlar um motor passo a passo com o L298N driver de motor. Esta placa de driver é normalmente usada para controlar motores DC, mas também é uma alternativa económica para controlar motores passo a passo! Pode controlar tanto a velocidade como a direção de rotação da maioria dos motores passo a passo, como um NEMA 17.
Incluí um diagrama de ligação e vários exemplos de código. No primeiro exemplo, vamos analisar a Stepper.h biblioteca Arduino. Recomendo vivamente que também dês uma vista de olhos nos exemplos da biblioteca AccelStepper no final deste tutorial. Esta biblioteca é bastante fácil de usar e pode melhorar muito o desempenho do teu hardware.
Após cada exemplo, explico detalhadamente como o código funciona, para que não tenhas problemas em modificá-lo conforme as tuas necessidades.
Materiais necessários
Componentes de hardware
 | L298N motor driver board | × 1 | Amazon |
 | NEMA 17 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| 12V power supply | × 1 | Amazon | |
| Jumper wires | × 10 | Amazon | |
| USB cable type A/B | × 1 | Amazon |
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.
Informações sobre o L298N Motor Driver
A L298N placa driver de motor é baseada no driver full-bridge duplo L298, fabricado pela STMicroelectronics. Com este driver podes controlar motores DC, motores passo a passo, relés e solenóides. Vem com dois canais separados, chamados A e B, que podes usar para controlar 2 motores DC ou 1 motor passo a passo quando combinados.
O L298N é normalmente montado numa placa breakout (vermelha), que facilita muito as ligações. A placa breakout inclui também um regulador de tensão 78M05 de 5 V.
Porque é que o meu motor passo a passo está a ficar QUENTE?
Uma coisa muito importante a lembrar é que o L298 não tem uma forma fácil de definir um limite de corrente ao contrário de outros drivers de motor passo a passo como o A4988. Isto significa que o consumo de corrente depende da relação entre a indutância e resistência (L/R) do motor passo a passo que ligares. Quando o motor consome demasiada corrente, podes danificar o driver e o motor aquece!
Isto significa que tens de ter cuidado ao escolher o motor passo a passo e a fonte de alimentação para usar com este driver de motor. Nem todos os motores passo a passo funcionam! A tensão de operação do L298N está entre 4,8 e 46 volts (máx. 35 V quando montado na placa breakout). Como o driver pode fornecer um máximo de 2 amperes por canal, precisas de encontrar um motor passo a passo que possa ser usado nesta faixa de tensão e que não ultrapasse a corrente máxima permitida.
Consulta a folha de dados do teu motor passo a passo e verifica a tensão/corrente que o motor consome. Se não conseguires encontrar a folha de dados, podes medir a resistência de uma das bobinas e usar a seguinte fórmula para estimar o consumo de corrente:
I = U ÷ R ou Corrente (A) = Tensão de alimentação (V) ÷ Resistência da bobina (Ω)
Eu tentaria encontrar um motor que consuma menos de 2 A à tensão que pretendes usar.
O motor que usei para este tutorial consome cerca de 1 A a 5 V. Também encontrei este motor passo a passo de Adafruit que funciona muito bem a 12 V e consome apenas 350 mA.
Se o motor que queres controlar não funcionar com o driver L298N, é melhor usar um driver chopper. Escrevi tutoriais para os A4988 e DRV8825 drivers que funcionam muito bem com muitos motores passo a passo.
Especificações do L298N Motor Driver
| Tensão de operação | 5 – 35 V |
| Tensão lógica | 4,5 – 7 V |
| Corrente máxima | 2 A por canal ou 4 A no total |
| Controlador de motor | L298N, controla 2 motores DC ou 1 motor passo a passo |
| Regulador de tensão | 78M05 |
| Dimensões do módulo | 43 x 43 x 28 mm |
| Dimensões dos furos | 3,2 mm, espaçamento de 37 mm |
| Custo | Check price |
Para mais informações, podes consultar a folha de dados abaixo:
Pinout do L298N
O L298 vem em vários pacotes diferentes, o pinout para o L298N (Multiwatt15) é o seguinte:
| Número do pino | Nome | Função |
|---|---|---|
| 1, 15 | Sense A, Sense B | O resistor de deteção deve ser ligado entre este pino e o GND (não usado na placa breakout). |
| 2, 3 | Out 1, Out 2 | Saídas da Ponte A; a corrente que passa pela carga ligada entre estes dois pinos é monitorizada no pino 1. |
| 4 | Vs | Tensão de alimentação para os estágios de saída de potência |
| 5, 7 | Input 1, Input 2 | Entradas compatíveis TTL da Ponte A |
| 6, 11 | Enable A, Enable B | Entrada de ativação compatível TTL: o estado BAIXO desativa a ponte A (enable A) e/ou a ponte B (enable B). |
| 8 | GND | Terra |
| 9 | VSS | Tensão de alimentação para os blocos lógicos. |
| 10, 12 | Input 3, Input 4 | Entradas compatíveis TTL da Ponte B. |
| 13, 14 | Out 3, Out 4 | Saídas da Ponte B; a corrente que passa pela carga ligada entre estes dois pinos é monitorizada no pino 15. |
Ligação – Conectar L298N ao motor passo a passo e Arduino
O diagrama de ligação/esquemático abaixo mostra como ligar um motor passo a passo, fonte de alimentação e Arduino à placa breakout L298N.
As ligações também estão indicadas na tabela abaixo:
Ligações do L298N
| L298N | Ligação |
|---|---|
| +12V | Fonte de alimentação de 5 – 35 V |
| GND | Terra da fonte de alimentação e do Arduino |
| Jumper 12 V | Remover se a alimentação do motor for > 12 V! |
| 5V+ (opcional) | 5 V do Arduino se o jumper de 12 V for removido |
| IN1 | Pino 8 do Arduino |
| IN2 | Pino 9 do Arduino |
| IN3 | Pino 10 do Arduino |
| IN4 | Pino 11 do Arduino |
| Jumpers ENA e ENB | Deixar instalados |
| OUT1 + OUT2 | Bobina A do motor passo a passo |
| OUT3 + OUT4 | Bobina B do motor passo a passo |
Nota importante: remove o jumper +12V se estiveres a usar uma fonte de alimentação superior a 12 V.
Quando o jumper +12V está colocado, o regulador de tensão onboard é ativado e cria a tensão lógica de 5 V. Ao removeres o jumper, precisas de fornecer 5 V à placa a partir do Arduino.
Também precisas de manter os jumpers ENA e ENB no lugar para que o motor esteja sempre ativado.
Como determinar a ligação do motor passo a passo?
Se não conseguires encontrar a folha de dados do teu motor passo a passo, pode ser difícil perceber como ligar o motor corretamente. Eu uso o seguinte truque para identificar como ligar motores bipolares de 4 fios:
O único que precisas identificar são os dois pares de fios ligados a cada uma das duas bobinas. Uma bobina liga-se a OUT1 e OUT2 e a outra a OUT3 e OUT4, a polaridade não importa.
Para encontrar os dois fios de uma bobina, faz o seguinte com o motor desligado:
- Tenta rodar o eixo do motor passo a passo à mão e nota a dificuldade em girar.
- Agora escolhe um par de fios aleatório do motor e toca as extremidades descascadas uma na outra.
- Depois, tenta rodar o eixo do motor passo a passo novamente.
- Se sentires muita resistência, encontraste um par de fios da mesma bobina. Se conseguires rodar o eixo livremente, tenta outro par de fios.
Agora liga as duas bobinas aos pinos indicados no diagrama de ligação acima.
Exemplo de código da biblioteca Stepper.h para driver L298N com motor passo a passo e Arduino
Podes carregar o seguinte exemplo de código no teu Arduino usando a Arduino IDE.
Este exemplo usa a Stepper.h biblioteca, que deve vir pré-instalada com o Arduino IDE. Podes encontrá-la em Sketch > Include Library > Stepper.
Este sketch faz o motor passo a passo dar 1 revolução numa direção, pausa, e depois dá 1 revolução na direção oposta.
/* Example sketch to control a stepper motor with
L298N motor driver, Arduino UNO and Stepper.h library.
More info: https://www.makerguides.com */
// Include the Stepper library:
#include "Stepper.h"
// Define number of steps per revolution:
const int stepsPerRevolution = 200;
// Initialize the stepper library on pins 8 through 11:
Stepper myStepper = Stepper(stepsPerRevolution, 8, 9, 10, 11);
void setup() {
// Set the motor speed (RPMs):
myStepper.setSpeed(100);
}
void loop() {
// Step one revolution in one direction:
myStepper.step(200);
delay(2000);
// Step on revolution in the other direction:
myStepper.step(-200);
delay(2000);
}
Como o código funciona:
O sketch começa por incluir a biblioteca Stepper.h do Arduino. Mais informações sobre esta biblioteca podem ser encontradas em Arduino website.
// Include the Stepper library: #include "Stepper.h"
De seguida, precisamos definir quantos passos o motor dá para completar 1 revolução. Neste exemplo, vamos usar o motor em modo full-step. Isto significa que são necessários 200 passos para rodar 360 graus. Podes alterar este valor se estiveres a usar outro tipo de motor passo a passo ou configuração.
// Define number of steps per revolution: const int stepsPerRevolution = 200;
Depois, precisas criar uma nova instância da classe Stepper, que representa um motor passo a passo específico ligado ao Arduino. Para isso usamos a função Stepper(steps, pin1, pin2, pin3, pin4) onde steps é o número de passos por revolução e pin1 a pin4 são os pinos usados para controlar o motor passo a passo. No nosso caso, são os pinos 8, 9, 10 e 11.
// Initialize the stepper library on pins 8 through 11: Stepper myStepper = Stepper(stepsPerRevolution, 8, 9, 10, 11);
Neste caso, chamei o motor passo a passo de ‘myStepper’, mas podes usar outros nomes, como ‘z_motor’ ou ‘liftmotor’, etc. Stepper liftmotor = Stepper(stepsPerRevolution, 8, 9, 10, 11);. O nome ‘myStepper’ será usado para definir a velocidade e o número de passos para este motor em particular. Nota que podes criar múltiplos objetos stepper com nomes diferentes se quiseres controlar mais do que um motor.
No setup() definimos a velocidade do motor. Podes definir a velocidade do motor em RPM com a função setSpeed(rpm). Defini 100, por isso devemos ver cerca de 1,6 revoluções por segundo.
// Set the motor speed (RPMs): myStepper.setSpeed(100);
Na secção loop do código, simplesmente chamamos a função step(steps) que roda o motor um número específico de passos a uma velocidade determinada pela função setSpeed(rpm) . Passar um número negativo para esta função inverte a direção de rotação do motor.
void loop() {
// Step one revolution in one direction:
myStepper.step(200);
delay(2000);
// Step on revolution in the other direction:
myStepper.step(-200);
delay(2000);
}
Nota que a função step(steps) é bloqueante, isto significa que espera até o motor terminar o movimento para passar o controlo para a linha seguinte do teu sketch.
Instalar a biblioteca AccelStepper
Nos três exemplos seguintes, vou mostrar como controlar a velocidade, direção e número de passos que o motor passo a passo deve dar. Neste exemplo, vou usar a biblioteca AccelStepper .
A biblioteca AccelStepper, escrita por Mike McCauley, é uma excelente biblioteca para usar no teu projeto. Uma das vantagens é que suporta aceleração e desaceleração, além de ter muitas outras funções úteis.
Podes instalar a biblioteca indo a Tools > Manage Libraries… ou pressionar Ctrl + Shift + I no Windows. O Library Manager abrirá e atualizará a lista de bibliotecas instaladas.
Podes procurar por ‘accelstepper‘ e procurar a biblioteca do Mike McCauley. Seleciona a versão mais recente e clica em Install.
1. Exemplo de código AccelStepper para rotação contínua
O seguinte sketch pode ser usado para fazer um ou mais motores passo a passo rodarem continuamente a uma velocidade constante. (Não é usada aceleração nem desaceleração).
/* Example sketch to control a stepper motor with L298N motor driver, Arduino UNO and AccelStepper.h library.
Contiuous rotation.
https://www.makerguides.com */
// Include the AccelStepper library:
#include "AccelStepper.h"
// Define the AccelStepper interface type:
#define MotorInterfaceType 4
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, 8, 9, 10, 11);
void setup() {
// Set the maximum speed in steps per second:
stepper.setMaxSpeed(1000);
}
void loop() {
// Set the speed of the motor in steps per second:
stepper.setSpeed(500);
// Step the motor with 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 próximo passo é definir o tipo de interface do motor. O tipo de interface deve ser definido como 4 quando se usa um motor passo a passo de 4 fios em modo full-step (200 passos/revolução). Podes 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, sempre que mencionares motorInterfaceType, o compilador substituirá pelo valor 4 quando o programa for compilado.
// Define the AccelStepper interface type: #define MotorInterfaceType 4
De seguida, precisas criar uma nova instância da classe AccelStepper com o tipo de interface do motor e as ligações apropriadas.
Neste caso, chamei o motor passo a passo de ‘stepper’, mas podes usar outros nomes, como ‘z_motor’ ou ‘liftmotor’, etc. AccelStepper liftmotor = AccelStepper(motorInterfaceType, 8, 9, 10, 11);. Como viste no exemplo anterior, o nome que dás ao motor passo a passo será usado mais tarde para definir a velocidade, posição e aceleração desse motor em particular. Podes criar múltiplas instâncias da classe AccelStepper com nomes e pinos diferentes. Isto permite controlar facilmente 2 ou mais motores passo a passo ao mesmo tempo.
// Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(MotorInterfaceType, 8, 9, 10, 11);
Na setup() 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. Nota que especifico o nome do motor passo a passo (‘stepper’), para o qual quero definir a velocidade máxima. Se tiveres vários motores passo a passo ligados, podes definir uma velocidade diferente para cada motor:
void setup() {
// Set the maximum speed in steps per second:
stepper.setMaxSpeed(1000);
stepper2.setMaxSpeed(300);
}
Na loop() definimos primeiro a velocidade a que queremos que o motor funcione. Para isso, usamos a função setSpeed(). (podes também colocar isto na secção setup do código).
stepper.runSpeed() faz a leitura do motor e, quando é altura de dar um passo, executa 1 passo. Isto depende da velocidade definida e do tempo desde o último passo. Se quiseres mudar a direção do motor, podes definir uma velocidade negativa: stepper.setSpeed(-400); faz o motor rodar na direção oposta.
void loop() {
// Set the speed of the motor in steps per second:
stepper.setSpeed(500);
// Step the motor with constant speed as set by setSpeed():
stepper.runSpeed();
}
2. Exemplo de código para controlar o número de passos ou revoluções
Com o seguinte sketch podes controlar a velocidade, direção e número de passos/revoluções.
Neste caso, o motor passo a passo roda 2 revoluções no sentido horário a 200 passos/segundo, depois roda 1 revolução no sentido anti-horário a 600 passos/segundo, e por fim roda 3 revoluções no sentido horário a 400 passos/segundo.
/* Example sketch to control a stepper motor with
L298N motor driver, Arduino UNO and AccelStepper.h library.
More info: https://www.makerguides.com */
// Include the AccelStepper library:
#include "AccelStepper.h"
// Define the AccelStepper interface type:
#define MotorInterfaceType 4
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, 8, 9, 10, 11);
void setup() {
// Set the maximum 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 while loop em combinação com a função currentPosition() . Primeiro, defino a posição atual do motor passo a 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. Neste caso, verifico se a posição atual do motor passo a passo não é igual a 200 passos (!= significa: não é igual a). Enquanto isto for verdade, fazemos o motor 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 velocidades e posições alvo diferentes.
3. Exemplo de código com aceleração e desaceleração
Neste exemplo vamos ver uma das principais razões para usar a biblioteca AccelStepper.
Com o seguinte sketch podes adicionar aceleração e desaceleração aos movimentos do motor passo a passo sem código complicado. A primeira parte deste sketch é igual ao exemplo 1, mas o setup e o loop são diferentes.
O motor fará cinco revoluções para a frente e para trás com uma velocidade de 200 passos por segundo e uma aceleração de 50 passos/segundo2.
/* Example sketch to control a stepper motor with
L298N motor driver, Arduino UNO and AccelStepper.h library.
Acceleration and deceleration.
More info: https://www.makerguides.com */
// Include the AccelStepper library:
#include "AccelStepper.h"
// Define the AccelStepper interface type:
#define MotorInterfaceType 4
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, 8, 9, 10, 11);
void setup() {
// Set the maximum steps per second:
stepper.setMaxSpeed(200);
// Set the maximum acceleration in steps per second^2:
stepper.setAcceleration(50);
}
void loop() {
// Set target position:
stepper.moveTo(1000);
// Run to position with set speed and acceleration:
stepper.runToPosition();
delay(1000);
// Move back to original position:
stepper.moveTo(0);
// Run to position with set speed and acceleration:
stepper.runToPosition();
delay(1000);
}
Como o código funciona:
Na setup(), além da velocidade máxima, precisamos definir a aceleração/desaceleração. Para isso, usamos a função setAcceleration().
// Set the maximum steps per second: stepper.setMaxSpeed(200); // Set the maximum acceleration in steps per second^2: stepper.setAcceleration(50);
Na secção loop do código, usei uma forma diferente de fazer o motor rodar um número pré-definido de passos. Primeiro defino a posição alvo com a função moveTo(). Depois, simplesmente uso a função runToPosition() para fazer o motor ir até à posição alvo com a velocidade e aceleração definidas. O motor desacelera antes de chegar à posição alvo.
// Set target position: stepper.moveTo(1000); // Run to position with set speed and acceleration: stepper.runToPosition();
Finalmente, definimos a nova posição alvo para 0, para voltar à origem.
Conclusão
Neste artigo mostrei como controlar um motor passo a passo com um driver L298N. Vimos 4 exemplos, usando as bibliotecas Stepper e AccelStepper.
Se quiseres aprender mais sobre outros drivers para motores passo a passo, os artigos abaixo podem ser úteis:
- How to control a stepper motor with A4988 driver and Arduino
- 28BYJ-48 Stepper Motor with ULN2003 Driver and Arduino Tutorial
- How to control a Stepper Motor with Arduino Motor Shield Rev3
Nota que o Arduino Motor Shield Rev3 também usa um driver L298.
Se tiveres alguma dúvida, sugestão, ou achares que falta algo neste tutorial, por favor deixa um comentário abaixo.
