Como controlar um Motor de Passo com Arduino Motor Shield Rev3

Neste tutorial, vais aprender a controlar um motor de passo com o Arduino Motor Shield Rev3. Incluí um diagrama de ligações e vários exemplos de código.

Primeiro, vamos ver um exemplo que usa a biblioteca Arduino Stepper. Esta biblioteca é ótima para controlo básico de motores de passo, mas não tem muitas funcionalidades extra.

Recomendo vivamente que também vejas os exemplos da biblioteca AccelStepper no final deste tutorial. Esta biblioteca é bastante fácil de usar e pode melhorar muito o desempenho do teu hardware.

Materiais necessários

Componentes de hardware

	Arduino Motor Shield Rev3	× 1	Amazon
	NEMA 17 stepper motor *	× 1	Amazon
	Arduino Uno Rev3	× 1	Amazon
	Power supply (5-12 V)	× 1	Amazon
	USB cable type A/B	× 1	Amazon

Neste tutorial usei um motor de passo bipolar com 4 fios. Tenta encontrar um motor de passo que funcione entre 5-12 V e que não ultrapasse o limite de corrente de 2 A. Este  Stepper motor  da Adafruit funciona muito bem a 12 V e não consome muita corrente (350 mA).

Software

Arduino IDE

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 Arduino Motor Shield Rev3

O  Arduino Motor Shield Rev3  é construído em torno do driver L298 dual full-bridge, fabricado pela STMicroelectronics. Com este shield, podes controlar motores DC, um motor de passo, relés e solenóides. Tem dois canais separados, chamados A e B, que podes usar para controlar 2 motores DC ou 1 motor de passo quando combinados.

Algo muito importante a lembrar é que o L298 é um driver de tensão constante. Isto significa que o consumo de corrente depende da relação entre a indutância e resistência (L/R) do motor que ligares.

Isto significa que tens de ter cuidado ao escolher o motor de passo e a fonte de alimentação para usar com este shield.  Nem todos os motores de passo funcionam!  A tensão de operação do shield é entre 5 e 12 volts. Como o shield pode fornecer um máximo de 2 amperes por canal, precisas de encontrar um motor de passo que funcione nesta faixa de tensão e que não ultrapasse a corrente máxima. O motor que usei neste tutorial consome cerca de 1A a 5V.

Se o motor que queres controlar não funcionar com este shield, recomendo usar um driver chopper. Escrevi um tutorial para o  A4988  e o  DRV8825  driver que funcionam muito bem com muitos motores de passo.

Especificações do Arduino Motor Shield Rev3

Tensão de operação	5 V a 12 V
Controlador do motor	L298P, controla 2 motores DC ou 1 motor de passo
Corrente máxima	2A por canal ou 4A máximo (com fonte de alimentação externa)
Deteção de corrente	1.65V/A
Funções	Funcionamento livre, paragem e travão
Custo	Check price

Para mais informações podes consultar os datasheets aqui.

Entradas e Saídas

Função	Pinos Canal A	Pinos Canal B
Direção	D12	D13
PWM	D3	D11
Travão	D9	D8
Deteção de corrente	A0	A1

Ligação – Como ligar um motor de passo ao Arduino Motor Shield Rev3

O diagrama de ligações/esquema abaixo mostra como ligar um motor de passo e a fonte de alimentação ao Arduino motor shield.

As ligações também estão indicadas na tabela abaixo.

Ligações do Arduino Motor Shield Rev3

Arduino Motor Shield Rev3	Ligação
Vin	5 – 12 V
GND	Terra da fonte de alimentação
A-	Bobina 1 do motor de passo
A+	Bobina 1 do motor de passo
B-	Bobina 2 do motor de passo
B+	Bobina 2 do motor de passo

Aviso

É possível alimentar diretamente o shield a partir do Arduino, mas não é recomendado. Quando o motor de passo consome muita corrente, podes danificar tanto o shield como o Arduino. Por isso, recomendo usar uma fonte de alimentação externa para os motores.

Para isso, tens de cortar o jumper Vin Connect na parte de trás do shield. Depois disso, podes alimentar o Arduino separadamente com um cabo USB ou através da ficha DC de 5,5 mm.

Como determinar a ligação dos fios do motor de passo?

Se não conseguires encontrar o datasheet do teu motor de passo, pode ser difícil perceber qual fio vai para onde. Eu uso o seguinte truque para identificar como ligar motores de passo bipolares de 4 fios:

O único que precisas 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 A- e A+ e os da outra a B- e B+, a polaridade não importa.

Para encontrar os dois fios de uma bobina, faz o seguinte com o motor desligado:

1. Tenta rodar o eixo do motor de passo à mão e nota a dificuldade para girar.
2. Agora escolhe um par de fios aleatório do motor e toca as pontas descarnadas uma na outra.
3. De seguida, enquanto manténs as pontas juntas, tenta rodar o eixo do motor de passo outra vez.

Se sentires muita resistência, encontraste um par de fios da mesma bobina.  Se ainda conseguires rodar o eixo livremente, tenta outro par de fios. Agora liga as duas bobinas aos pinos indicados no diagrama de ligações acima.

Exemplo básico de código Arduino para motor de passo e Arduino Motor Shield com a biblioteca Stepper.h

Podes carregar o seguinte exemplo de código para o teu Arduino usando o  Arduino IDE.

Este exemplo usa a biblioteca Stepper.h, que deve vir pré-instalada com o Arduino IDE. Este sketch faz o motor de 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 
   Arduino Motor Shield Rev3, Arduino UNO and Stepper.h library. 
   https://www.makerguides.com */

#include "Stepper.h"

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

// Initialize the stepper library on the motor shield:
Stepper myStepper = Stepper(stepsPerRevolution, dirA, dirB);

void setup() {
  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

  // Set the motor speed (RPMs):
  myStepper.setSpeed(60);
}


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);
}

Explicação do código:

O sketch começa por incluir a biblioteca Arduino Stepper.h. Mais informações sobre esta biblioteca podem ser encontradas no  Arduino website.

#include "Stepper.h"

De seguida, defini quantos passos o motor dá para fazer 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 de passo ou configuração.

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

Depois definimos as ligações do motor (ver especificações e diagrama de ligações acima).

A instrução  #define  é usada para dar um nome a um valor constante. O compilador vai substituir todas as referências a esta constante pelo valor definido quando o programa for compilado. Assim, em todo o lado onde menciones  pwmA, o compilador vai substituir pelo valor 3 quando o programa for compilado.

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

De seguida, precisas criar uma nova instância da classe Stepper, que representa um motor de passo específico ligado ao Arduino. Para isso usamos a função  Stepper(steps, pin1, pin2)  onde steps é o número de passos por revolução e pin1 e pin2 são os pinos usados para controlar o motor de passo. No nosso caso são dirA e dirB.

// Initialize the stepper library on the motor shield:
Stepper myStepper = Stepper(stepsPerRevolution, dirA, dirB);

Neste caso chamei o motor de passo ‘myStepper’, mas podes usar outros nomes, como ‘z_motor’ ou ‘liftmotor’, etc.  Stepper liftmotor = Stepper(stepsPerRevolution, dirA, dirB);.

No setup, começamos por definir os pinos de travão e PWM como saída com a função  pinMode(). Os pinos PWM têm de ser definidos como HIGH e os pinos de travão como LOW com a função  digitalWrite().

  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

Podes definir a velocidade do motor em rpm com a função  setSpeed(rpm). Defini para 60, por isso devemos ver 1 revolução por segundo.

  // Set the motor speed (RPMs):
  myStepper.setSpeed(60);

Loop

Na secção loop do código, simplesmente chamamos a função  step(steps)  que faz o motor girar 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);
}

Note que a função step(steps) é bloqueante, isto significa que vai esperar até o motor terminar o movimento para passar o controlo para a linha seguinte do teu sketch.

Exemplos de código para Arduino Motor Shield e biblioteca AccelStepper

Nos três exemplos seguintes vou mostrar como controlar a velocidade, direção e número de passos que o motor de passo deve dar. Nestes exemplos vou usar a biblioteca AccelStepper.

A biblioteca AccelStepper, escrita por Mike McCauley, é uma biblioteca fantástica para usar no teu projeto. Uma das vantagens é que suporta aceleração e desaceleração, mas tem muitas outras funções úteis.

Podes descarregar a versão mais recente desta biblioteca aqui:

Podes instalar a biblioteca indo a Sketch > Include Library > Add .ZIP Library… no Arduino IDE.

Outra opção é ir a Tools > Manage Libraries… ou pressionar Ctrl + Shift + I no Windows. O Library Manager vai 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 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).

Podes copiar o código clicando no botão no canto superior direito do campo de código.

/* Example sketch to control a stepper motor with
   Arduino Motor Shield Rev3, Arduino UNO and AccelStepper.h library: 
   continuous rotation. More info: https://www.makerguides.com */

// Include the AccelStepper library:
#include "AccelStepper.h"

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

// Define the AccelStepper interface type:
#define MotorInterfaceType 2

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, dirA, dirB);

void setup() {
  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

  // Set the maximum steps per second:
  stepper.setMaxSpeed(600);
}

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:

Mais uma vez, o primeiro passo é incluir a biblioteca com  #include <AccelStepper.h>.

#include "AccelStepper.h"

Depois de especificar as ligações como antes, precisamos definir o tipo de interface do motor para a biblioteca AccelStepper. Neste caso vamos controlar o motor de passo em modo full step, com dois fios, por isso definimos o modo para 2. Podes encontrar os outros tipos de interface aqui (link).

// Define the AccelStepper interface type:
#define MotorInterfaceType 2

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 de passo ‘stepper’, mas podes usar outros nomes, como ‘z_motor’ ou ‘liftmotor’, etc.  AccelStepper liftmotor = AccelStepper(MotorInterfaceType, dirA, dirB);.

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, dirA, dirB);

A secção setup do código é quase igual ao exemplo anterior, mas também defini a velocidade máxima em passos/segundo. Velocidades acima de 1000 passos por segundo podem ser instáveis, por isso defini para 600 (terás de experimentar para ver qual a velocidade máxima para a tua configuração). Nota que especifico o nome do motor de passo (‘stepper’) para o qual quero definir a velocidade máxima.

  // Set the maximum steps per second:
  stepper.setMaxSpeed(600);

Loop

Na secção loop, primeiro definimos a velocidade a que queremos que o motor rode com a função  setSpeed(). (podes também colocar isto na secção setup do código).

A função  stepper.runSpeed()  faz a leitura do motor e, quando é hora 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. Sketch para controlar o número de passos ou revoluções

Com o seguinte sketch, podes controlar a velocidade, direção e o número de passos/revoluções. Não é usada aceleração nem desaceleração.

Neste caso, o motor de passo dá 1 revolução no sentido horário a 400 passos/segundo, depois 1 revolução no sentido anti-horário a 200 passos/segundo, e por fim 3 revoluções no sentido horário a 600 passos/segundo.

/* Example sketch to control a stepper motor with 
  Arduino Motor Shield Rev3, Arduino UNO and 
  AccelStepper.h library: number of steps or revolutions. 
  More info: https://www.makerguides.com */

#include "AccelStepper.h"

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

// Define the AccelStepper interface type:
#define MotorInterfaceType 2

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, dirA, dirB);

void setup() {
  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

  // Set the maximum steps per second:
  stepper.setMaxSpeed(600);
}

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

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

  delay(1000);

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

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

  delay(1000);

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

  // Run the motor forward at 600 steps/second until the motor reaches 600 steps (3 revolutions):
  while (stepper.currentPosition() != 600) {
    stepper.setSpeed(600);
    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 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é a expressão dentro dos parênteses, () se tornar falsa. Neste caso verifico se a posição atual do motor de passo é diferente de 200 passos (!= significa: é diferente de). Enquanto isto for verdade, fazemos o motor rodar a uma velocidade constante definida por  setSpeed().

  // Run the motor forward at 400 steps/second until the motor reaches 200 steps (1 revolution):
  while (stepper.currentPosition() != 200) {
    stepper.setSpeed(400);
    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 funcionalidades da biblioteca AccelStepper: adicionar aceleração e desaceleração.

Com o seguinte sketch podes adicionar aceleração e desaceleração aos movimentos do motor de 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 vai fazer 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/segundo ² .

/* Example sketch to control a stepper motor with 
  Arduino Motor Shield Rev3, Arduino UNO and 
  AccelStepper.h library: acceleration and deceleration 
  More info: https://www.makerguides.com */

#include <AccelStepper.h>

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

// Define the AccelStepper interface type:
#define MotorInterfaceType 2

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, dirA, dirB);

void setup() {
  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

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

No 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 usamos a função  runToPosition()  para fazer o motor ir até à posição alvo com a velocidade e aceleração definidas. O motor vai desacelerar antes de chegar à posição alvo.

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

Por fim, definimos a nova posição alvo para 0, para voltar à origem.

Conclusão

Neste artigo mostrei como controlar um motor de passo com o Arduino Motor Shield Rev3. Vimos 4 exemplos, usando tanto a biblioteca Stepper como a AccelStepper.

Espero que tenhas achado útil e informativo. Se quiseres aprender mais sobre outros drivers (microstepping) como o  A4988, vê os artigos abaixo.

Outros tutoriais de motores de passo:

• Control a stepper motor with L298N motor driver and Arduino
• 28BYJ-48 Stepper Motor with ULN2003 Driver and Arduino Tutorial
• How to control a stepper motor with A4988 driver and Arduino
• How to control a stepper motor with DRV8825 driver and Arduino

Se tiveres mais perguntas, deixa um comentário abaixo.