Arduino ed i motori passo passo

Motori Passo-Passo o Stepper Motor

I Motori Passo Passo (detti anche Stepper Motor) riescono a far ruotare il proprio albero di un preciso angolo fisso, detto “Passo” o “Stepper”. I campi di applicazione sono molteplici, li troviamo nelle stampanti 3D, nelle Frese, nei Plotter e nei Robot.
Ci sono vari tipi di Motori Passo Passo:
– a magneti permanenti
– a riluttanza variabile
– ibridi
Noi ci soffermeremo sui primi, meno costosi, ideali se non devono raggiungere velocità elevate di rotazione.

Motori Passo Passo a Magneti Permanenti

Senza entrare troppo nello specifico, i Motori Passo Passo a Magneti Permanenti hanno un albero centrale (rotore), con una serie di magneti permanenti montati su di esso e delle bobine che circondano l’albero (avvolte sullo statore). Le bobine ricevono alternativamente corrente e creano campi magnetici che respingono, o attraggono, i magneti sull’albero, facendo ruotare il motore. Inoltre, permettono di mantenere fermo l’albero in un determinato punto (Attenzione: non smontate mai questo tipo di motore, perché la magnetizzazione iniziale viene fatta dopo l’assemblaggio, sfilare l’albero del motore dalla sede fa perdere ai magneti una parte del loro magnetismo, dimezzando la coppia disponibile del motore!). La coppia massima si raggiunge quando si tiene fermo l’albero in una posizione e decrementa in base alla velocità di rotazione dell’albero. I Motori Passo Passo possono essere alimentati con qualsiasi tensione (cioè 9,12,15,18,24,28 volt), purché, la corrente che dovrà scorrere nelle bobine, venga limitata attraverso la scheda di pilotaggio.

I Motori Passo Passo a magneti permanenti si dividono in due categorie:
– unipolari
– bipolari

Motori Passo Passo Unipolari

I Motori Passo Passo Unipolari hanno da cinque a otto fili e quattro bobine (in realtà due bobine divise a metà con una connessione centrale su ciascuna bobina). I collegamenti centrali delle bobine sono uniti insieme e utilizzati come alimentazione di potenza. Sono chiamati Stepper Unipolari perché la potenza arriva sempre su un unico polo centrale.

Motori Passo Passo Bipolari

I Motori Passo Passo Bipolari di solito hanno quattro o otto fili che escono da esso. A differenza degli Stepper Unipolari, gli Stepper Bipolari non hanno una connessione centrale comune. Hanno invece due serie indipendenti di bobine. Sono chiamati Bipolari perché per far ruotare l’albero occorre invertire la polarità di alimentazione delle bobine secondo una precisa sequenza.

Motori Passo Passo con Arduino

Quindi per far funzionare un Motore Stepper non basta semplicemente dare tensione al motore (come per i motori CC), ma ci servirà conoscere alcune caratteristiche di questo motore.

Le principali  caratteristiche dei Motori Passo Passo che ci possono interessare per utilizzarli con Arduino sono:
– Passi per giro (Step for revolution): è il numero di passi richiesti per compiere un giro completo.
– Angolo per passo (Step angle): è il valore dell’angolo che percorre il rotore tra un passo e l’altro.
– unipolare / bipolari (in base al tipo cambia lo schema di alimentazione)
– Numero di fili.
– La tensione e la corrente max per ogni fase.

Motori Passo Passo Unipolari con Arduino

Per controllare lo Stepper, applicare la tensione a ciascuna delle bobine secondo la seguente sequenza:

I motori a Passo Passo si possono far ruotare anche con frazioni di passo. L’esempio che segue aggiunge alla precedente sequenza i mezzi passi, basta eccitare più bobine contemporaneamente.

Per controllare un Motore Stepper Unipolare, si utilizza un array di transistor Darlington.
I 4 fili andranno collegati ai Transistor. Il quinto filo e, se presente, anche il sesto, andranno collegati alla tensione di alimentazione.

Come array Darlington possiamo utilizzare un ULN2003A (Qui potete scaricare il suo Datasheet) che all’interno possiede 7 transistor, o ULN2803A (Qui potete scaricare il suo Datasheet) che all’interno ne possiede 8. Entrambi possono pilotare Motori alimentati fin a 50V e forniscono al Max 500mA.
Il motore che utilizzeremo per gli esempi è un 28YJ-48 A 5V (Qui potete scaricare il suo Datasheet). Il filo di Alimentazione è quello rosso.

Nella precedente tabella sono riportati gli step necessari a far ruotare un Motore Stepper ed il relativo filo del motore 28YJ-48 A 5V. La combinazione dei fili risulta essere 2 – 1 – 4 – 3 che, per praticità, possiamo scrivere con 4 – 3 – 2 – 1, per ruotare in un verso e 1 – 2 – 3 – 4 per ruotare nell’altro.

Lo schema da utilizzare con Arduino è il seguente:
Lo sketch da utilizzare per provarne il funzionamento è il seguente:

// Connessioni ULN2003A
#define Pin1 7
#define Pin2 8
#define Pin3 9
#define Pin4 10
#define Pulsante 12
#define Potenziometro A0

bool rotazione = false; // variabile per senso rotazione
bool pressione; // variabile per leggere lo stato del pulsante
bool ultimapressione = false; // variabile per salvare lo stato della pressione pulsante
int ritardo;

void setup() {
  pinMode(Pin1, OUTPUT);
  pinMode(Pin2, OUTPUT);
  pinMode(Pin3, OUTPUT);
  pinMode(Pin4, OUTPUT);
  pinMode(Pulsante, INPUT_PULLUP);

  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, LOW);
}

void loop() {
  ritardo = map(analogRead(Potenziometro), 0, 1023, 2, 50);
  // Legge il valore del potenziometro e lo converte in ritardi
  // Maggiore sarà il ritardo, minore sarà la velocità di rotazione
  pressione = digitalRead(Pulsante);
  if (pressione == LOW && ultimapressione == HIGH) {
    rotazione = !rotazione; // Inverte lo stato del motore
  }
  ultimapressione = pressione;
  if (rotazione == true) { // se true allora il motore gira in Avanti
    Avanti();
  }
  if (rotazione == false) { // se true allora il motore gira in Indietro
    Indietro();
  }

}
void Avanti() {
  // Step 1
  digitalWrite(Pin1, HIGH);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, LOW);
  delay(ritardo);
   // Step 2
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, HIGH);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, LOW);
  delay(ritardo);
  // Step 3
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, HIGH);
  digitalWrite(Pin4, LOW);
  delay(ritardo);
  // Step 4
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, HIGH);
  delay(ritardo);
}

void Indietro() { // La rotazione in indietro viene fatta a passi interi
  // Step 4
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, HIGH);
  delay(ritardo);
  // Step 3
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, HIGH);
  digitalWrite(Pin4, LOW);
  delay(ritardo);
  // Step 2
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, HIGH);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, LOW);
  delay(ritardo);
  // Step 1
  digitalWrite(Pin1, HIGH);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, LOW);
  delay(ritardo);
}

Il programma fa ruotare il motore alla velocità di rotazione impostata tramite potenziometro ed il pulsante invertirà il senso di rotazione.

Se volessimo spegnere e lasciare libero il motore basterà porre LOW i quattro i Pin.

In commercio l’ULN2003A lo possiamo trovare già montato su una scheda, tipo questa:

Lo schema da utilizzare con Arduino è il seguente:

Lo sketch da utilizzare sarà lo stesso del precedente esempio.

Motori Passo Passo Bipolari con Arduino

Per controllare un Motore Passo Passo Bipolare invece di utilizzare quattro bobine si utilizzano entrambi i poli delle due bobine e si inverte la polarità della corrente. La sequenza da inviare al motore sarà la stessa del Motore Passo Passo Unipolare, visto precedentemente.

Il modo più semplice per invertire la polarità nelle bobine è utilizzare una coppia di ponti H.

L’L293D (Qui potete scaricare il suo Datasheet), o il suo equivalente SN754410NE (Qui potete scaricare il suo Datasheet), hanno due ponti H al loro interno e li possiamo utilizzare per questo scopo, infatti possono pilotare Motori alimentati fino a 36V e fornire al Max 600mA per canale.

Lo schema da utilizzare con Arduino è il seguente:

Lo sketch da utilizzare per provarne il funzionamento è il seguente:

// Connessioni L293D
#define EN12 6
#define Pin1 7
#define Pin2 8
#define Pin3 9
#define Pin4 10
#define EN34 11
#define Pulsante 12
#define Potenziometro A0

bool rotazione = false; // variabile per senso rotazione
bool pressione; // variabile per leggere lo stato del pulsante
bool ultimapressione = false; // variabile per salvare lo stato della pressione pulsante

int ritardo = 0; // ritardo per gestire la velocità di rotazione

void setup() {

  pinMode(EN12, OUTPUT);
  pinMode(EN34, OUTPUT);
  pinMode(Pin1, OUTPUT);
  pinMode(Pin2, OUTPUT);
  pinMode(Pin3, OUTPUT);
  pinMode(Pin4, OUTPUT);
  pinMode(Pulsante, INPUT_PULLUP);

  digitalWrite(EN12, HIGH);
  digitalWrite(EN34, HIGH);
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, LOW);
}

void loop() {
  ritardo = map(analogRead(Potenziometro), 0, 1023, 750, 5000); 
// Legge il valore del potenziometro e lo converte in ritardi
// Maggiore sarà il ritardo, minore sarà la velocità di rotazione
  pressione = digitalRead(Pulsante);
  if (pressione == LOW && ultimapressione == HIGH) {
    rotazione = !rotazione; // Inverte lo stato del motore
  }
  ultimapressione = pressione;
  if (rotazione == true) { // se true allora il motore gira in Avanti
    Avanti();
  }
  if (rotazione == false) { // se true allora il motore gira in Indietro
    Indietro();
  }
}

void Avanti() { 
  // La rotazione in avanti viene fatta a mezzi passi
  // Step 1
  digitalWrite(Pin1, HIGH);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, LOW);
  delayMicroseconds(ritardo);
  // Step 1,5
  digitalWrite(Pin1, HIGH);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, HIGH);
  delayMicroseconds(ritardo);
  // Step 2
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, HIGH);
  delayMicroseconds(ritardo);
  // Step 2,5
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, HIGH);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, HIGH);
  delayMicroseconds(ritardo);
  // Step 3
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, HIGH);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, LOW);
  delayMicroseconds(ritardo);
  // Step 3,5
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, HIGH);
  digitalWrite(Pin3, HIGH);
  digitalWrite(Pin4, LOW);
  delayMicroseconds(ritardo);
  // Step 4
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, HIGH);
  digitalWrite(Pin4, LOW);
  delayMicroseconds(ritardo);
  // Step 4
  digitalWrite(Pin1, HIGH);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, HIGH);
  digitalWrite(Pin4, LOW);
  delayMicroseconds(ritardo);
}

void Indietro() { 
  // La rotazione in indietro viene fatta a passi interi
  // Step 4
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, HIGH);
  digitalWrite(Pin4, LOW);
  delayMicroseconds(ritardo);
  // Step 3
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, HIGH);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, LOW);
  delayMicroseconds(ritardo);
  // Step 2
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, HIGH);
  delayMicroseconds(ritardo);
  // Step 1
  digitalWrite(Pin1, HIGH);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, LOW);
  delayMicroseconds(ritardo);
}

Come negli esempi precedenti, il programma fa ruotare il motore alla velocità di rotazione impostata tramite potenziometro ed il pulsante inverte il senso di rotazione.

Se i nostri motori necessitano di correnti maggiori e fino a 2A, si può utilizzare un altro circuito integrato: l’L298N (Qui potrete scaricare il datasheet).

Cambia il packaging, ma il funzionamento è identico; ha però 2 pin in più: il current sensing A ed il B, che non tratteremo ora.

Il L298N si trova già assemblato con tutta l’elettronica necessaria al suo funzionamento. Una versione è la seguente:

Note sulla scheda: Enable A ed Enable B sono forniti con due ponticelli, per l’uso con un Motore Stepper Bipolare li lasceremo inseriti.

Il JUMPER +5V permette di far circolare la tensione dei motori dentro uno stabilizzatore a +5V che alimenta la logica del L298N; se alimentiamo i motori con tensioni maggiori di +12V DEVE essere rimosso, altrimenti lo stabilizzatore si danneggia. Una volta rimosso tale JUMPER si dovrà provvedere a fornire i +5V esternamente. Nel caso si alimenti con tensioni inferiori a +12V il JUMPER può essere lasciato, così facendo lo stabilizzatore fornirà sia tensione +5V alla logica, che in uscita del morsetto (potremmo utilizzare questi +5V per alimentare Arduino).

Lo schema da utilizzare con Arduino è il seguente:

Lo sketch da utilizzare sarà simile a quello precedente.

#define Pulsante 12
#define Potenziometro A0
#define Pin1 7
#define Pin2 6
#define Pin3 5
#define Pin4 4

bool rotazione = false; // variabile per senso rotazione
bool pressione; // variabile per leggere lo stato del pulsante
bool ultimapressione = false; // variabile per salvare lo stato della pressione pulsante

int ritardo = 0; // ritardo per gestire la velocità di rotazione

void setup() {

  pinMode(Pulsante, INPUT_PULLUP);
  pinMode(Pin1, OUTPUT);
  pinMode(Pin2, OUTPUT);
  pinMode(Pin3, OUTPUT);
  pinMode(Pin4, OUTPUT);

  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, LOW);
}

void loop() {
  ritardo = map(analogRead(Potenziometro), 0, 1023, 2, 200);
  // Legge il valore del potenziometro e lo converte in ritardi
  // Maggiore sarà il ritardo, minore sarà la velocità di rotazione
  pressione = digitalRead(Pulsante);
  if (pressione == LOW && ultimapressione == HIGH) {
    rotazione = !rotazione; // Inverte lo stato del motore
  }
  ultimapressione = pressione;
  if (rotazione == true) { // se true allora il motore gira in Avanti
    Avanti();
  }
  if (rotazione == false) { // se true allora il motore gira in Indietro
    Indietro();
  }
}
void Avanti() {
  // Step 1
  digitalWrite(Pin1, HIGH);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, LOW);
  delay(ritardo);
  // Step 2
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, HIGH);
  delay(ritardo);
  // Step 3
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, HIGH);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, LOW);
  delay(ritardo);
  // Step 4
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, HIGH);
  digitalWrite(Pin4, LOW);
  delay(ritardo);
}

void Indietro() {
  // Step 4
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, HIGH);
  digitalWrite(Pin4, LOW);
  delay(ritardo);
  // Step 3
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, HIGH);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, LOW);
  delay(ritardo);
  // Step 2
  digitalWrite(Pin1, LOW);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, HIGH);
  delay(ritardo);
  // Step 1
  digitalWrite(Pin1, HIGH);
  digitalWrite(Pin2, LOW);
  digitalWrite(Pin3, LOW);
  digitalWrite(Pin4, LOW);
  delay(ritardo);
}

L’unica differenza è che non usiamo i due pin En12 ed En34.

I motori Stepper ed i Driver con controllo di corrente

In tutti gli esempi trattati precedentemente, i Motori Passo Passo sono stati alimentati senza preoccuparsi della corrente che veniva inviata alle bobine. Così facendo si possono incorrere in due problemi:
-Surriscaldamento dei Driver
-Surriscaldamento dei Motori
In entrambi i casi si rischia di danneggiare qualcosa.

Si possono utilizzare vari Driver con il controllo della corrente. Due di questi, ampiamente utilizzati anche per controllare i motori delle stampanti 3D, son il driver A4988  ed il Driver DRV8825.

Utilizzo dei Driver A4988 e DRV8825 con Arduino

Entrambi i driver sono semplici da usare ,e se acquistati già assemblati su circuito stampato, sono anche Pin compatibili.

Le caratteristiche del A4988 (Qui potete scaricare il suo Datasheet) sono:
Tensione di esercizio minima: 8 V
Massima tensione di esercizio: 35 V
Corrente continua per fase: 1 A
Corrente massima per fase: 2 A
Tensione logica minima: 3 V
Tensione logica massima: 5,4 V
Risoluzioni Microstep: Full, 1/2, 1/4, 1/8 e 1/16 Le caratteristiche del A4988 (Qui potete scaricare il suo Datasheet) sono:
Tensione di esercizio minima: 8.2 V
Massima tensione di esercizio: 45 V
Corrente continua per fase: 1,5 A
Corrente massima per fase: 2,2 A
Tensione logica minima: 2,5 V
Tensione logica massima: 5,25 V
Risoluzioni Microstep: Full, 1/2, 1/4, 1/8, 1/16 e 1/32Sostanzialmente le differenze sono che il DRV8825 riesce a pilotare più corrente e può gestire microstep fino a 1/32, contro 1/16 del A4988.

Vediamo ora nel dettaglio le funzioni dei piedini.
– Il pin VDD o FAULT è l’ingresso dell’alimentazione logica del Driver.
– Il pin VMOT è l’ingresso dell’alimentazione dei motori (max 35 V per l’A4988 e 45 V per il DRV8825). Vicino a questo pin è importante collegare un condensatore elettrolitico da 100 µF con la funzione di filtro dai picchi di tensione, senza si rischia di danneggiare il Driver.
– Il pin ENABLE serve per abilitare o disabilitare il motore, se impostato basso (LOW) il motore è attivo, se impostato alto (HIGH) il motore va in Stand-by, ma l’elettronica resta comunque attiva (internamente ha una resistenza di Pull-Down, quindi se lasciato sconnesso è di default LOW).
– Il pin SLEEP se impostato basso (LOW)  toglie alimentazione anche all’elettronica del Driver (ha una resistenza interna di Pull-UP, quindi se lasciato sconnesso è di default HIGH).
– Il pin RESET se impostato basso (LOW) azzera il controllore che governa il driver e pone le uscite di comando dei motori (1A, 1B, 2A, 2B) a zero logico, anche se STEP continua a ricevere impulsi (non ha resistenze interne quindi il pin deve essere connesso, solitamente si collega al pin SLEEP se non si vuole gestire lo Sleep ed il Reset esternamente).
– Il pin STEP richiede un’alternanza di stati logici alto/basso (pulse) per poter far ruotare il motore (l’impulso deve durata almeno 1 µS per l’A4988 e di circa 2 µS per il DRV8825).
– Il pin DIR serve a gestire il senso di rotazione del motore ne caso riceva un impulso su STEP. Se impostato basso (LOW) girerà in un senso e, se impostato alto (HIGH) girerà nell’altro (non ha resistenze interne quindi il pin deve essere connesso).
– I pin MS1,MS2,MS3 (per il A4988) o i M0,M1,M3 (per il DRV8825) servono per impostare i Microstep, hanno internamente una resistenza di Pull-Down, quindi se lasciati sconnessi sono di default tutti LOW ed il Driver lavora in FULL Step.

Nota sui microstep: All’inizio di questa guida c’è uno schema che illustra come alimentare il motore per far compiere anche i mezzi passi (1/2), questo raddoppierà il numero dei passi da compiere per eseguire una rotazione. Con questi Driver si possono far compiere frazioni di passi anche più piccoli, come 1/4, 1/8, 1/16 e, per i DRV8825, anche 1/32, si moltiplicheranno quindi per 4, 8,16 o 32 il numero dei passi che dovremo compiere per eseguire una rotazione completa.

La regolazione della corrente erogata si esegue tramite il piccolo trimmer presente sulla scheda (notare che le due schede hanno il trimmer al lato opposto). Utilizzate un piccolo cacciavite ceramico con punta a taglio, costano pochi euro e evitano che eventuali correnti statiche possano danneggiare i Driver.

La formula per calcolare il valore VRef per il Driver A4988 è:
Vref = Correntedaerogare / 2.5

Esempio: se volessimo erogare 1A per fase del motore, la formula sarebbe:
Vref = 1/ 2.5 = 0,4 V

La formula per calcolare il valore VRef per il Driver DRV8825 è:
Vref = Correntedaerogare / 2

Esempio: se volessimo erogare 1A per fase del motore la formula sarebbe:
Vref = 1/ 2 = 0,5 V

Vref si deve misurare (per entrambi i Driver) con un multimetro impostato in Tensione Continua V con fondo-scala di 20V (dipenderà dal vostro multimetro).
Il terminale positivo andrà posto su centro del trimmer metallico e il puntale negativo su GND.

Per evitare il surriscaldamento dei Driver A4988 e DRV8825 in commercio si trovano delle piccole alette di raffreddamento provviste di uno speciale biadesivo (spesso vengono fornite di serie con i Driver), si consiglia caldamente l’utilizzo.

Lo schema da utilizzare con Arduino è il seguente:

I tre fili Rosa che vanno a MS1, MS2 e MS3 si possono collegare o meno a seconda dei Microstep che vogliamo impostare per il motore, nel seguente esempio non li abbiamo utilizzati.

Esistono in commercio anche delle schede adattatori per utilizzare i Driver.

Lo sketch da utilizzare sarà il seguente.

// Connessioni Driver A4988 o DRV8825
#define dirPin 4
#define stepPin 5
#define EnablePin 6
#define Pulsante 12
#define Potenziometro A0

bool rotazione = false; // variabile per senso rotazione
bool pressione; // variabile per leggere lo stato del pulsante
bool ultimapressione = false; // variabile per salvare lo stato della pressione pulsante
int ritardo;

void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  pinMode(EnablePin, OUTPUT);
  pinMode(Pulsante, INPUT_PULLUP);
  
  digitalWrite(EnablePin, LOW); // Enable è attivo se LOW
}

void loop() {
  ritardo = map(analogRead(Potenziometro), 0, 1023, 200, 2000);
  // Legge il valore del potenziometro e lo converte in ritardi
  // Maggiore sarà il ritardo, minore sarà la velocità di rotazione
  pressione = digitalRead(Pulsante);
  if (pressione == LOW && ultimapressione == HIGH) {
    rotazione = !rotazione; // Inverte lo stato del motore
  }
  ultimapressione = pressione;
  if (rotazione == true) { // se true allora il motore gira in Avanti
    digitalWrite(dirPin, HIGH);
  }
  if (rotazione == false) { // se true allora il motore gira in Indietro
    digitalWrite(dirPin, LOW);
  }

  digitalWrite(stepPin, HIGH);
  delayMicroseconds(ritardo);
  digitalWrite(stepPin, LOW);
  delayMicroseconds(ritardo);
}

Usare i Motori Passo Passo con la libreria Stepper.h

Insieme all’IDE di Arduino viene fornita la libreria Servo.h che facilita l’uso dei Motori Stepper.

Questo è uno sketch preso dagli esempi disponibili nell’IDE e riadattato per lo schema visto prima.

#include <Stepper.h>
const int stepsPerRevolution = 200;
Stepper myStepper(stepsPerRevolution, 7, 6, 5, 4);

void setup() {
  myStepper.setSpeed(60);
  Serial.begin(9600);
}

void loop() {
  Serial.println("clockwise");
  myStepper.step(stepsPerRevolution);
  delay(500);
  Serial.println("counterclockwise");
  myStepper.step(-stepsPerRevolution);
  delay(500);
}

Il programma farà ruotare il motore di un giro in un verso e poi nell’altro, alla velocità indicata.

La libreria Stepper.h è molto semplice da usare.

Si crea l’oggetto myStepper con il comando:

Stepper myStepper(stepsPerRevolution, pin1, pin2, pin3, pin4);

dove dobbiamo indicare il numero dei passi del motore necessari a compiere un giro, ed i pin dove è collegato il motore.

Il comando:

 myStepper.setSpeed(girialminto);

serve ad indicare la velocità di rotazione del motore.

Il comando:

myStepper.step(stepsdacompiere);

serve a specificare quanti passi deve compiere il Motore, se il numero è positivo il Motore ruoterà in un verso, se il numero è negativo ruoterà nell’altro. Fare attenzione al numero di passi indicato, perché il programma, mentre fa ruotare il motore, non farà altro. Per capire meglio, è come se fosse nella funzione delay(), quindi per non bloccare l’esecuzione del programma per molto tempo, conviene dare pochi passi alla volta.