Come controllare un motore passo-passo con Arduino Motor Shield Rev3

In questo tutorial imparerai come controllare un motore passo-passo con il Arduino Motor Shield Rev3. Ho incluso uno schema di collegamento e molti codici di esempio.

Per prima cosa diamo un’occhiata a un esempio che utilizza la libreria Arduino Stepper. Questa libreria è ottima per il controllo base dei motori passo-passo ma non offre molte funzionalità extra.

Consiglio vivamente di dare un’occhiata anche ai codici di esempio per la libreria AccelStepper alla fine di questo tutorial. Questa libreria è abbastanza facile da usare e può migliorare notevolmente le prestazioni del tuo hardware.

Materiale necessario

Componenti 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

In questo tutorial ho usato un motore passo-passo bipolare a 4 fili. Cerca un motore passo-passo che possa funzionare a 5-12 V e che non superi il limite di corrente di 2 A. Questo  Stepper motor  di Adafruit funziona bene a 12 V e non assorbe troppa 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.

Informazioni sull’Arduino Motor Shield Rev3

Il  Arduino Motor Shield Rev3  è basato sul driver L298 dual full-bridge, prodotto da STMicroelectronics. Con lo shield puoi pilotare motori DC, un motore passo-passo, relè e solenoidi. Dispone di due canali separati, chiamati A e B, che puoi usare per pilotare 2 motori DC o 1 motore passo-passo combinando i canali.

Una cosa molto importante da ricordare è che l’L298 è un driver a tensione costante. Questo significa che l’assorbimento di corrente dipende dal rapporto tra induttanza e resistenza (L/R) del motore collegato.

Questo significa che devi fare attenzione nella scelta del motore passo-passo e dell’alimentazione da usare con questo shield.  Non tutti i motori passo-passo funzioneranno!  La tensione operativa dello shield è tra 5 e 12 volt. Poiché lo shield può fornire un massimo di 2 ampere per canale, devi trovare un motore passo-passo che possa essere usato in questo intervallo di tensione e che non superi la corrente massima. Il motore che ho usato in questo tutorial assorbe circa 1A a 5V.

Se il motore che vuoi pilotare non funziona con questo shield, ti consiglio di usare un driver chopper. Ho scritto un tutorial per il  A4988  e il  DRV8825  driver che funzionano bene con molti motori passo-passo.

Specifiche Arduino Motor Shield Rev3

Tensione operativa	5 V a 12 V
Controller motore	L298P, pilota 2 motori DC o 1 motore passo-passo
Corrente massima	2A per canale o 4A max (con alimentazione esterna)
Rilevamento corrente	1.65V/A
Funzioni	Rotazione libera, stop e freno
Costo	Check price

Per maggiori informazioni puoi consultare i datasheet qui.

Ingressi e Uscite

Funzione	Pin Canale A	Pin Canale B
Direzione	D12	D13
PWM	D3	D11
Freno	D9	D8
Rilevamento corrente	A0	A1

Collegamenti – Collegare un motore passo-passo all’Arduino Motor Shield Rev3

Lo schema elettrico qui sotto mostra come collegare un motore passo-passo e l’alimentazione allo shield Arduino.

I collegamenti sono anche riportati nella tabella sottostante.

Collegamenti Arduino Motor Shield Rev3

Arduino Motor Shield Rev3	Collegamento
Vin	5 – 12 V
GND	Massa alimentazione
A-	Bobina 1 del motore passo-passo
A+	Bobina 1 del motore passo-passo
B-	Bobina 2 del motore passo-passo
B+	Bobina 2 del motore passo-passo

Avvertenza

È possibile alimentare direttamente lo shield dall’Arduino, ma non è consigliato. Se il motore passo-passo assorbe troppa corrente, potresti danneggiare sia lo shield che l’Arduino. Perciò consiglio di usare un’alimentazione esterna per i motori.

Per fare questo devi tagliare il jumper Vin Connect sul retro dello shield. Dopo averlo fatto puoi alimentare l’Arduino separatamente con un cavo USB o tramite il connettore DC da 5,5 mm.

Come determinare il cablaggio del motore passo-passo?

Se non riesci a trovare il datasheet del tuo motore passo-passo, può essere difficile capire quale filo va dove. Io uso questo trucco per identificare come collegare motori passo-passo bipolari a 4 fili:

L’unica cosa che devi identificare sono le due coppie di fili collegati alle due bobine del motore. I fili di una bobina si collegano a A- e A+, quelli dell’altra a B- e B+, la polarità non importa.

Per trovare i due fili di una bobina, fai così con il motore scollegato:

1. Prova a far girare l’albero del motore passo-passo a mano e nota quanto è difficile ruotarlo.
2. Ora prendi una coppia casuale di fili del motore e tocca insieme le estremità scoperte.
3. Poi, tenendo insieme le estremità, prova di nuovo a far girare l’albero del motore passo-passo.

Se senti molta resistenza, hai trovato una coppia di fili della stessa bobina.  Se l’albero gira ancora liberamente, prova un’altra coppia di fili. Ora collega le due bobine ai pin indicati nello schema di collegamento sopra.

Codice esempio base Arduino per motore passo-passo e Arduino Motor Shield con libreria Stepper.h

Puoi caricare il seguente codice esempio sul tuo Arduino usando il  Arduino IDE.

Questo esempio usa la libreria Stepper.h, che dovrebbe essere preinstallata nell’IDE Arduino. Questo sketch fa ruotare il motore passo-passo di 1 giro in una direzione, si ferma, poi ruota di 1 giro nell’altra direzione.

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

Spiegazione del codice:

Lo sketch inizia includendo la libreria Arduino Stepper.h. Maggiori informazioni su questa libreria si trovano su  Arduino website.

#include "Stepper.h"

Poi definisco quanti passi il motore compie per ruotare di 1 giro. In questo esempio useremo il motore in modalità full-step. Questo significa che servono 200 passi per ruotare di 360 gradi. Puoi cambiare questo valore se usi un tipo diverso di motore passo-passo o configurazione.

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

Dopo, definiamo i collegamenti del motore (vedi specifiche e schema sopra).

L’istruzione  #define  serve per dare un nome a un valore costante. Il compilatore sostituirà ogni riferimento a questa costante con il valore definito quando il programma viene compilato. Quindi ovunque menzioni  pwmA, il compilatore lo sostituirà con il valore 3 durante la compilazione.

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

Poi devi creare una nuova istanza della classe Stepper, che rappresenta un motore passo-passo collegato all’Arduino. Per questo usiamo la funzione  Stepper(steps, pin1, pin2)  dove steps è il numero di passi per rivoluzione e pin1 e pin2 sono i pin usati per pilotare il motore passo-passo. Nel nostro caso sono dirA e dirB.

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

In questo caso ho chiamato il motore passo-passo ‘myStepper’ ma puoi usare altri nomi, come ‘z_motor’ o ‘liftmotor’ ecc.  Stepper liftmotor = Stepper(stepsPerRevolution, dirA, dirB);.

Nel setup, iniziamo impostando i pin di freno e PWM come output con la funzione  pinMode(). I pin PWM devono essere impostati HIGH e i pin freno LOW con la funzione  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);

Puoi impostare la velocità del motore in rpm con la funzione  setSpeed(rpm). L’ho impostata a 60, quindi dovremmo vedere 1 giro al secondo.

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

Loop

Nella sezione loop del codice, chiamiamo semplicemente la funzione  step(steps)  che fa ruotare il motore di un numero specifico di passi a una velocità determinata dalla funzione  setSpeed(rpm)  . Passare un numero negativo a questa funzione inverte la direzione di rotazione del motore.

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 che la funzione step(steps) è bloccante, cioè aspetta che il motore finisca di muoversi prima di passare alla riga successiva dello sketch.

Codici di esempio per Arduino Motor Shield e libreria AccelStepper

Nei seguenti tre esempi ti mostrerò come controllare velocità, direzione e numero di passi che il motore passo-passo deve compiere. In questi esempi userò la libreria AccelStepper.

La libreria AccelStepper scritta da Mike McCauley è una libreria fantastica per il tuo progetto. Uno dei vantaggi è che supporta accelerazione e decelerazione, ma ha anche molte altre funzioni utili.

Puoi scaricare l’ultima versione di questa libreria qui:

Puoi installare la libreria andando su Sketch > Include Library > Add .ZIP Library… nell’IDE Arduino.

Un’altra opzione è andare su Tools > Manage Libraries… o premere Ctrl + Shift + I su Windows. Si aprirà il Library Manager che aggiornerà la lista delle librerie installate.

Puoi cercare ‘accelstepper‘ e trovare la libreria di Mike McCauley. Seleziona l’ultima versione e clicca su Install.

1. Codice esempio per rotazione continua

Il seguente sketch può essere usato per far girare uno o più motori passo-passo continuamente a velocità costante. (Non si usa accelerazione o decelerazione).

Puoi copiare il codice cliccando sul pulsante in alto a destra nel campo del codice.

/* 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();
}

Come funziona il codice:

Ancora una volta il primo passo è includere la libreria con  #include <AccelStepper.h>.

#include "AccelStepper.h"

Dopo aver specificato i collegamenti come prima, dobbiamo definire il tipo di interfaccia motore per la libreria AccelStepper. In questo caso piloteremo il motore passo-passo in modalità full step, con due fili, quindi impostiamo la modalità a 2. Puoi trovare gli altri tipi di interfaccia qui (link).

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

Poi devi creare una nuova istanza della classe AccelStepper con il tipo di interfaccia motore e i collegamenti appropriati.

In questo caso ho chiamato il motore passo-passo ‘stepper’ ma puoi usare altri nomi, come ‘z_motor’ o ‘liftmotor’ ecc.  AccelStepper liftmotor = AccelStepper(MotorInterfaceType, dirA, dirB);.

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

La sezione setup del codice è quasi uguale all’esempio precedente, ma ho anche definito la velocità massima in passi/secondo. Velocità superiori a 1000 passi al secondo possono essere inaffidabili, quindi l’ho impostata a 600 (dovrai sperimentare per vedere qual è la velocità massima per il tuo setup). Nota che specifico il nome del motore passo-passo (‘stepper’) per cui voglio definire la velocità massima.

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

Loop

Nella sezione loop, prima impostiamo la velocità a cui vogliamo far girare il motore con la funzione  setSpeed(). (puoi anche metterla nella sezione setup del codice).

La funzione  stepper.runSpeed()  controlla il motore e quando è il momento di fare un passo esegue 1 passo. Questo dipende dalla velocità impostata e dal tempo dall’ultimo passo. Se vuoi cambiare la direzione del motore, puoi impostare una velocità negativa:  stepper.setSpeed(-400);  fa girare il motore nell’altra direzione.

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 per controllare il numero di passi o rivoluzioni

Con il seguente sketch puoi controllare velocità, direzione e numero di passi/rivoluzioni. Non si usa accelerazione o decelerazione.

In questo caso, il motore passo-passo compie 1 rivoluzione in senso orario a 400 passi/sec, poi 1 rivoluzione in senso antiorario a 200 passi/sec, e infine 3 rivoluzioni in senso orario a 600 passi/sec.

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

Spiegazione del codice

La prima parte del codice fino alla sezione loop() è esattamente la stessa dell’esempio precedente.

Nel loop uso un  while loop  in combinazione con la funzione  currentPosition()  . Prima imposto la posizione corrente del motore passo-passo a zero con  stepper.setCurrentPosition(0).

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

Poi usiamo un ciclo while. Un ciclo while ripete continuamente, e all’infinito, finché l’espressione dentro le parentesi () diventa falsa. Quindi in questo caso controllo se la posizione corrente del motore passo-passo è diversa da 200 passi (!= significa: è diverso da). Finché è così, facciamo girare il motore a velocità costante impostata da  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();
  }

Nel resto del loop facciamo esattamente lo stesso, solo con velocità e posizione target diverse.

3. Codice esempio con accelerazione e decelerazione

In questo esempio vedremo una delle principali caratteristiche della libreria AccelStepper: aggiungere accelerazione e decelerazione.

Con il seguente sketch puoi aggiungere accelerazione e decelerazione ai movimenti del motore passo-passo, senza codici complicati. La prima parte di questo sketch è uguale all’esempio 1, ma setup e loop sono diversi.

Il motore farà cinque rivoluzioni avanti e indietro con una velocità di 200 passi al secondo e un’accelerazione di 50 passi/secondo ² .

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

Come funziona il codice

Nel setup, oltre alla velocità massima, dobbiamo definire accelerazione e decelerazione. Per questo usiamo la funzione  setAcceleration().

  // Set the maximum steps per second:
  stepper.setMaxSpeed(200);
  // Set the maximum acceleration in steps per second^2:
  stepper.setAcceleration(50);

Nella sezione loop del codice, ho usato un modo diverso per far ruotare il motore di un numero predefinito di passi. Prima imposto la posizione target con la funzione  moveTo(). Poi usiamo semplicemente la funzione  runToPosition()  per far muovere il motore verso la posizione target con la velocità e accelerazione impostate. Il motore decelera prima di raggiungere la posizione target.

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

Infine, impostiamo la nuova posizione target a zero, così torniamo all’origine.

Conclusione

In questo articolo ti ho mostrato come controllare un motore passo-passo con l’Arduino Motor Shield Rev3. Abbiamo visto 4 esempi, usando sia la libreria Stepper che AccelStepper.

Spero che tu l’abbia trovato utile e informativo. Se vuoi saperne di più su altri driver (microstepping) come il  A4988, dai un’occhiata agli articoli qui sotto.

Altri tutorial sui motori passo-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 hai altre domande, lascia pure un commento qui sotto.