Archivi categoria: arduino

Arduino: Stepper 28BYJ-48 – AccelStepper library

La libreria Stepper Arduino è ottima per controllare un solo stepper, ma quando si desidera controllare velocità e accelerazione dello stepper oppure è necessario controllare contemporaneamente più stepper bisogna utilizzare la libreria AccelStepper.

In questo breve tutorial vedremo come controllare velocità e accelerazione ed in una successiva lezione controlleremo più stepper.

AccelStepper aggiunge le seguenti funzionalità:

accelerazione e decelerazione;
supporta il mezzo passo;
controllo di più stepper simultaneamente e simultaneamente si possono far fare passi indipendenti su ogni stepper.

AccelStepper non è inclusa nell’IDE di Arduino, bisognerà installarla.

Installazione della libreria

Per installare la libreria, andare in Sketch > Include Library > Manage Libraries…

Nel campo di ricerca inserire “AccelStepper”. Selezionare la prima voce che compare e procedere con l’installazione

Lo schema elettrico di collegamento è il medesimo visto nella lezione precedente, potete utilizzare entrambi gli schemi proposti, con alimentazione presa direttamente da Arduino o con alimentazione esterna che vi consiglio.

Codice Arduino

Di seguito lo sketch di esempio “Bounce”, che permette l’accelerazione del motore passo-passo in una direzione per decelerare e poi fermarsi. Trovate lo sketch “Bounce” tra gli esempi a corredo della libreria, su questo programma ho apportato alcune modifiche inserendo i commenti che ne spiegano il funzionamento.

1// Bounce
2// Prof. Maffucci Michele
3//
4// Una sola rotazione in accelerazione da 0 a 2048 e viceversa
5 
6// inclusione della libreria AccelStepper
7#include <AccelStepper.h>
8 
9// definizione di una costante
10// funzionamento:
11// in fullstep  impostare 4
12// in halfstemp impostare 8
13#define FULLSTEP 4
14 
15// creazione dell'istanza della classe mioStepper
16/*
17   IN1 -> 8
18   IN2 -> 9
19   IN3 -> 10
20   IN4 -> 11
21*/
22AccelStepper mioStepper(FULLSTEP, 8, 10, 9, 11);
23 
24void setup() {
25 
26  // impostare la velocità massima,
27  // accelerazione,
28  // velocità iniziale
29  // numero di passi da compiere
30 
31  mioStepper.setMaxSpeed(1000);
32  mioStepper.setAcceleration(50);
33  mioStepper.setSpeed(100);
34  mioStepper.moveTo(2048);
35}
36 
37void loop()
38{
39 
40  // distanceToGo restituisce il numero di passi compiuti.
41  // Se distanceToGo raggiunge lo zero, cioè numero di passi è uguale a zero
42  // inverte il senso di rotazione assegnando un valore negativo al numero di passi
43  // da compiere.
44 
45  if (mioStepper.distanceToGo() == 0)
46    mioStepper.moveTo(-mioStepper.currentPosition());
47 
48  // se non è stato raggiunto il valore zero, muove lo stepper di un passo
49  mioStepper.run();
50}

Per maggiori informazioni vi rimando alla pagina di riferimento della libreria

Video Player

Media error: Format(s) not supported or source(s) not found

Scarica il file: https://www.maffucci.it/wp-content/uploads/2020/11/28BYJ-48-AccelStepper-video.mp4?_=1

00:00

Usa i tasti freccia su/giù per aumentare o diminuire il volume.

Esercizi per i miei studenti

Esercizio 1
Realizzare uno sketch che da serial monitor permetta all’avvio di Arduino l’impostazione di:

velocità massima;
accelerazione;
velocità iniziale;
numero di passi da compiere;

Con l’inserimento dell’ultimo parametro ed il successivo invio si avvia lo stepper.

Esercizio 2
Eseguire le stesse funzionalità dell’esercizio precedente, ma l’avvio dello Stepper avviene solamente alla pressione di un pulsante.

Esercizio 3
Aggiungere all’esercizio precedente un pulsante di stop che permetta di interrompe in qualsiasi momento la rotazione dello stepper.

Modificare un motore passo passo 28BYJ-48 da unipolare a bipolare

2 Repliche

Scrivo questo breve tutorial perché in questi giorni sto progettando i prototipi delle attività didattiche che spero potranno essere realizzati dai miei studenti nel mese di febbraio prossimo durante le attività di PCTO. Tra le future attività la realizzazione di più bracci robot da controllare con Arduino e PLC Siemens. Il braccio robot che sto realizzando è costituito da 3 motori passo passo 28BYJ-48 ed un servomotore. La scelta del 28BYJ-48 rispetto ai più potenti NEMA 17 risiede semplicemente nei costi di realizzazione per me e i miei studenti che vorranno replicare il progetto.

Poiché ho l’esigenza di aumentare il numero di grammi al centimetro che possono essere spostati/sollevati dal braccio ho convertito il passo passo 28BYJ-48 da unipolare a bipolare.

Questo motore passo passo è molto piccolo ma ha una potenza sufficiente per realizzare diverse sperimentazioni. Nello scorso anno scolastico, sempre durante le attività di PCTO, alcuni miei studenti hanno sviluppato l’automazione di un’ascensore la cui struttura portante era da me stata realizzata e tagliata a laser, mente i ragazzi si sono occupati dell’assemblaggio delle parti e della programmazione.

Il 28BYJ-48, come detto nel mio precedente post, è disponibile in due versione, con alimentazione a 5V e a 12V, le due versioni sono identiche, differiscono ovviamente per l’impedenza interna. In questo breve tutorial userò la versione a 12V, ma la procedura è la medesima per la versione a 5V.

Il motore passo passo possiede un riduttore incorporato da 1/64 ciò implica un passo molto piccolo del motore 0,087890625 gradi per passo. Il riduttore ha però un aspetto negativo, ne riduce la velocità di rotazione, ma possiamo sopportare questa sua lentezza considerando il fatto che il prezzo dei questo motore è estremamente contenuto, la versione a 5V può essere acquistata online a non più di 2,5 € e quindi per piccole sperimentazioni è più che sufficiente.

In funzione della modo con cui viene pilotato questo passo passo può raggiungere i 300 gcm in half step, per raggiunge i 380 gcm quando si passa a full step.

Gli stepper bipolari sono più efficienti di quelli unipolari in essi viene alimentata una sola bobina per volta (1/2 una bobina per essere precisi) mentre per i bipolare entrambe le bobine sono alimentate, quindi si ottiene una coppia maggiore.

L’immagine di seguito mostra ciò che accade in un passo passo bipolare.

Sono presenti due avvolgimenti anziché quattro rispetto ad uno stepper unipolare. Entrambi gli avvolgimenti possono essere attivi in qualsiasi momento ma la polarità viene commutata su quattro fasi, ciò vuol dire che questo motore ha solo quattro fili anziché 5 (o 6 o 8).

Per convertire un 28BYJ-48 da unipolare a bipolare bisogna interrompere la connessione indicata in rosso nell’immagine, quella contrassegnata con 2 + 3 + 6 + 7. La configurazione diventerebbe come quella rappresentata nell’immagine di sinistra.

Per effettuare questa conversione è sufficiente un cutter ed un cacciavite. Come indicato nell’immagine che segue, utilizzate il cacciavite per sollevare il cappuccio azzurro che protegge un piccolo circuito elettronico in cui noterete 11 punti di saldatura, questo circuito non fa altro che collegare le varie bobine del passo passo.

Interrompete la pista centrale come indicato nell’immagine in questo modo renderemo il passo passo bipolare.
Questa modifica potrà farvi raggiungere gli 800 gcm che è almeno il doppio rispetto all’unipolare in full step (380 gcm) e quasi 3 volte di più per un unipolare half step (300 gcm).

A questo punto avremo bisogno di un driver che consenta il pilotaggio del motore, per questo potreste utilizzare L293D oppure un ULN2003 o ancora un A4988.

Fate riferimento agli articoli passati.

Non dimenticare di regolare al minimo la corrente del vostro driver A4988 / DRV8825, in quanto per questi motori non è possibile fornire più di 100 mA per fase, se superate questo valore potreste distruggere il motore.

Buon Making a tutti.

Controllare uno Stepper 28BYJ-48 con ULN2003 mediante Arduino

6 Repliche

Il 28BYJ-48 è un motore passo passo unipolare a 5 fili tra i più economici che potete trovare in commercio (poco meno di 3€), è spesso inserito all’interno dei kit Arduino compatibili che troviamo su molti store online.

Si presenta in due versioni, a 5V e a 12V

Generalmente forniscono una buona coppia anche in stato di stop fintanto che viene fornita alimentazione al motore. L’unico aspetto negativo è l’elevato assorbimento anche in stato di stop che risulta di 240 mA.

Specifiche tecniche (derivate dal datasheet del motore)

Dimensioni del motore (derivate dal datasheet del motore)
Di seguito le dimensioni fisiche del motore nel caso in cui dobbiate realizzare parti meccaniche (bracci robot, plotter, ecc…) su cui fissare il motore.

Per quanto riguarda il funzionamento degli Stepper Motor vi rimando ai due articoli:

Questo tipo di motore è spesso venduto con una scheda di controllo.
Ho utilizzato spesso questo stepper per piccoli bracci robot o piccoli plotter, avrei potuto ovviamente utilizzare motori più performanti, ma il basso costo risulta particolarmente compatibile con il portafoglio anche dei miei studenti.

Per questa lezione useremo:

motore passo passo 28BYJ-48
scheda di controllo con ULN2003A
scheda Arduino UNO R3
6 connettori maschio femmina
una breadboard

Ma prima di iniziare con la pratica alcuni richiami di teoria.

Sono presenti 5 fili di connessione che fanno riferimento alle bobine e all’alimentazione. All’interno del motore sono presenti due bobine, al centro di ogni bobine abbiamo la connessione alla tensione di alimentazione (5V o 12V) filo di colore rosso, mentre gli altri connettori:

arancione;
rosa;
giallo;
blu;

saranno connessi ciclicamente a massa in modo che ci sia passaggio di corrente tra questi e il positivo ed ogni volta vi sarà il passaggio di corrente in queste bobine, l’albero del motore compirà un passo.

All’interno del motore sono presenti due bobine, al centro di ogni bobine abbiamo la connessione alla tensione di alimentazione (5V) filo di colore rosso, mentre gli altri connettori: arancione, rosa, giallo, blu saranno connessi ciclicamente a massa in modo che ci sia passaggio di corrente tra questi e il positivo ed ogni volta vi sarà il passaggio di corrente in queste bobine l’albero del motore compirà un passo (fare riferimento agli articoli indicati all’inizio).

Secondo la scheda tecnica, quando il motore 28BYJ-48 funziona in modalità a full step, ogni passo corrisponderà ad una rotazione di 11,25°. Ciò significa che verranno effettuati 32 passi per giro (360°/11,25° = 32), però il motore possiede al suo interno una riduzione di 1/63,68395 che viene approssimato ad 1/64 ciò implica che ci saranno in realtà 32*63,68395 passi per giro = 2037,8864 all’incirca 2038 passi (attenzione che se si approssima il rapporto la riduzione ad 1/64 il numero di passi per giro risulta 2048).

E’ possibile controllare questo motore in modo più preciso utilizzando i micro stepping, in questa guida ne mostrerò il funzionamento in full step e successivamente utilizzando un’apposita libreria, che ne semplifica l’utilizzo, verrà controllato in half step.

Per i 28BYJ-48 l’intervallo tra ogni passo è di 2 millisecondi, quindi teoricamente potrebbe funzionare ad una velocità massima di 500 passi/s, da ciò si desume che per fare una rotazione completa sono necessari 4 secondi.

La scheda di controllo.

Sulla scheda di controllo trova posto l’integrato ULN2003A che include un array di 7 transistor Darlington, ognuno in grado di gestire una corrente di 500mA con tensioni nell’ordine dei 50V

L’ULN2003A risulta utile per la gestione di carichi di tipo induttivo come: stepper (passo-passo), motori CC, rele’, ecc… E’ presente su ogni Darlington un diodo che consente la soppressione di disturbi, rendendo superflua l’installazione di diodi esterni.

Sulla scheda di controllo troviamo anche 4 diodi LED con in serie le resistenze per limitane la corrente. I 4 LED indicati con le lettere A, B, C, D indicano lo stato di attivazione delle varie bobine.

La scheda può essere utilizzata per stepper 28BYJ-48 a 5V o a 12 V. Inserire il negativo sul pin in cui è presente il – e il positivo dove è presente il simbolo +. I pin ON/OFF consentono di attivare o disattivare la scheda di controllo, nella posizione indicata nell’immagine che segue la scheda è in stato ON, togliendo il ponticello passa nello stato OFF.

Poiché l’assorbimento del passo passo può arrivare fino a 240 mA è indispensabile utilizzare un’alimentazione esterna mantenendo comuni le masse tra il microcontrollore e scheda di controllo dello stepper, però in questa lezione per rendere agevole la sperimentazione a titolo dimostrativo utilizzerò l’alimentazione a 5V direttamente ad Arduino, di seguito sono riportati i due circuiti con alimentazione da scheda Arduino ed esterna.

Schema di collegamento
(con alimentazione presa da scheda Arduino)

Schema di collegamento
(con alimentazione esterna)

Collegherò i pin IN1, IN2, IN3, IN4 della scheda di controllo del motore ai pin di Arduino: 8, 9, 10, 11.

Per rendere più semplice la programmazione possiamo utilizzare la libreria stepper presente all’interno dell’IDE di Arduino così come fatto nei due articoli indicati ad inizio di questa lezione. La libreria permette il controllo di stepper unipolari che bipolari.

Come indicato sul reference di Arduino, la libreria è dotata delle seguenti funzioni:

Utilizzerò lo sketch stepper_oneRevolution presente nell’IDE di Arduino.
Lo sketch farà muovere il motore passo-passo in senso orario lentamente e poi rapidamente in senso antiorario.

Come detto nella parte iniziale di questa lezione, l’albero del motore eseguirà 2048 passi per effettuare un’intera rotazione.

In questo esempio, l’albero esegue una rotazione completa in senso orario, eseguendo il numero di 2048 passi utilizzando la libreria Arduino Stepper.
Così come per l’esempio precedente utilizzeremo anche in questo caso i pin digitali di Arduino: 8, 9, 10, 11 così come indicato nello schema precedente.

Come detto nella parte iniziale di questa lezione, l’albero del motore eseguirà 2048 passi per effettuare un’intera rotazione.

1/*
2 * Prof. Michele Maffucci
3 * 28.10.2020
4 */
5 
6// inclusione della libreria Stepper 
7#include <Stepper.h>
8 
9// definizione del numero di passi per rotazione
10const int stepsPerRevolution = 2048;
11 
12// creazione dell'istanza della classe stepper
13 
14/*
15 * IN1 -> 8
16 * IN2 -> 9
17 * IN3 -> 10
18 * IN4 -> 11
19 */
20 
21Stepper myStepper(stepsPerRevolution, 8, 10, 9, 11);
22 
23void setup() {
24  /* 
25   * non è necessario impostare i pin di Arduino
26   * a cui collegare la scheda dello stepper 
27   * vengono gestiti dalla libreria
28   */
29 
30// imposta la velocità a 15 rpm:
31  myStepper.setSpeed(15);
32 
33// inizializzazione della porta seriale
34  Serial.begin(9600);
35}
36 
37void loop() {
38  // imposta una rotazione in senso orario
39  Serial.println("orario");
40  myStepper.step(stepsPerRevolution);
41  delay(500);
42 
43// imposta una rotazione in senso antiorario
44  Serial.println("antiorario");
45  myStepper.step(-stepsPerRevolution);
46  delay(500);
47}

Spiegazione del codice

Lo sketch inizia con l’inclusione della libreria Stepper.

`1`	`#include <Stepper.h>`

Successivamente, definiamo una costante stepsPerRevolution che contiene il numero di “passi” che il motore eseguirà per completare un giro. Nel nostro caso, è il 2048

`1`	`const` `int` `stepsPerRevolution = 2048;`

Il motore passo-passo unipolare 28BYJ-48 viene azionato agendo sui pin IN1-IN3-IN2-IN4 per fare ciò deve essere create un’istanza della libreria stepper chiamata myStepper in cui inseriamo la sequenza di pin 8, 10, 9, 11.
Assicuratevi di effettuare questa operazione correttamente altrimenti il motore non funzionerà correttamente.

`1`	`Stepper myStepper(stepsPerRevolution, 8, 10, 9, 11);`

Nel setup definiamo la velocità di rotazione e inizializziamo la Serial Monitor in quanto invieremo su questa il senso di rotazione del motore.

1void setup() {
2  /* 
3   * non è necessario impostare i pin di Arduino
4   * a cui collegare la scheda dello stepper 
5   * vengono gestiti dalla libreria
6   */
7 
8// imposta la velocità a 15 rpm:
9  myStepper.setSpeed(15);
10 
11// inizializzazione della porta seriale
12  Serial.begin(9600);
13}

Nella funzione loop, nella prima parte del codice, stampiamo sulla Serial Monitor la stringa “orario” e successivamente usiamo la funzione step() per impostare il numero di passi che deve effettuare, nella seconda parte del codice stampiamo sulla Serial Monitor la stringa “antiorario” e successivamente usiamo la funzione step() impostando un valore negativo che farà ruotare il motore in senso antiorario.

1void loop() {
2  // imposta una rotazione in senso orario
3  Serial.println("orario");
4  myStepper.step(stepsPerRevolution);
5  delay(500);
6 
7// imposta una rotazione in senso antiorario
8  Serial.println("antiorario");
9  myStepper.step(-stepsPerRevolution);
10  delay(500);
11}

Il primo frammento di codice farà ruotare il motore in senso orario molto lentamente. E il secondo farà girare il motore in senso antiorario a una velocità molto più veloce.

Video Player

Media error: Format(s) not supported or source(s) not found

Scarica il file: https://www.maffucci.it/wp-content/uploads/2020/10/passo-passo-28BYJ-48.mp4?_=2

00:00

Usa i tasti freccia su/giù per aumentare o diminuire il volume.

Esercizi per i miei studenti

Esercizio 1
Fare ruotare in modo continuo l’albero dello stepper, ad ogni rivoluzione accendere un LED per 200 ms. Visualizzare sulla serial monitor il contatore di rivoluzioni.

Esercizio 2
Aggiungere due pulsanti di controllo per lo start e per lo stop del motore. Indicare lo stato del pulsante sulla Serial Monitor.

Esercizio 3
Alla pressione del pulsante P1 il motore avanza di 512 passi alla pressione del pulsante P2 il motore torna indietro di 512 passi.

Esercizio 4
All’avvio del programma sulla Serial Monitor inserire un numero che identifica il numero di passi utilizzati per incrementare e decrementare il numero di passi mediante due pulsanti P1 e P2. Il numero di passi per l’incremento e il decremento è lo stesso.
Stampare sulla Serial Monitor il valore totale dei passi compiuti dallo stepper.

Esercizio 5
All’avvio del programma sulla Serial Monitor inserire due valori che identificano: il numero di passi utilizzati per incrementare e il numero di passi per decrementare. In questo esercizio si desidera impostare due valori che possono essere anche diversi per l’incremento e il decremento dei passi del motore.
Stampare sulla Serial Monitor il valore totale dei passi compiuti dallo stepper.

Esercizio 6
Mediante un sensore ad ultrasuoni realizzare un programma che nell’intervallo tra 3 cm e 19 cm avvicinando un ostacolo, per ogni centimetro il sensore incrementa di 128 passi e allontanandosi dall’ostacolo per ogni centimetro il numero di passi decremento di 128 passi.

Controllare un motore passo passo unipolari con Arduino

Lascia una risposta

In queste settimane i miei studenti stanno svolgendo una serie di esercitazioni in cui è necessario controllare la rotazione di un motore passo passo (stepper). L’obiettivo delle esercitazioni è quello di simulare il sistema di controllo di un forno a microonde e lo stepper viene utilizzato per la rotazione del piatto.

In un precedente articolo ho dettagliato il principio di funzionamento di questa tipologia di motori, in questo post ne riassumo le principali caratteristiche e condivido alcuni esempi che sono di base per la realizzazione delle sperimentazioni svolte per il laboratorio di TPSEE e Sistemi.

Richiami

Il vantaggio principale rispetto ad un motore brushed (a spazzola) in corrente continua e di un servomotore e che l’albero di rotazione di uno stepper può essere posizionati con precisione, spostandolo in avanti o all’indietro di un “passo” alla volta, ma possono anche ruotare continuamente.
In questa lezione verrà mostrato come controllare un motore passo-passo utilizzando Arduino ed un ponte H L293D, lo stesso utilizzato per controllare un motore a spazzola come quelli utilizzati in molti dei kit robotici che trovate sia questo sito.

Caratteristiche principali di uno stepper

La differenza sostanziale da un motore brushed in corrente continua risiede nel fatto che un motore passo passo mantiene la velocità di rotazione costante anche con un carico applicato, ovvero se sottoposti a sforzo mantengono velocità costante. Questa caratteristica consente di evitare sistemi di controreazione, utilizzando ad esempio degli encoder, per il mantenimento costante della velocità.
i motori passo passo erogano coppie elevate anche a basso numero di giri.
accelerazioni e frenate repentine
mantenimento del carico fermo e senza vibrazioni

Difetti

E’ necessario utilizzare un circuito elettrico di pilotaggio
rendimento energetico basso
velocità di rotazione ridotta
costo di acquisto elevato

Per le caratteristiche tecniche, il principio di funzionamento e le modalità di connessione vi rimando all’articolo: Controllo di un motore passo-passo bipolare NEMA17 con Driver L298N

Negli sketch di esempio che troverete in questo articolo prendo in considerazione 3 tipologie di stepper: i piccoli stepper dei CD-ROM e dei DVD dei computer, 28BYJ-48 comuni in molti kit Arduino, e i NEMA 17.

Negli sketch di esempio che troverete in questo articolo prendo in considerazione 3 tipologie di stepper: i micro stepper dei CD-ROM e dei DVD dei computer, i 28BYJ-48 comuni in molti kit Arduino, e i nema 17.

Negli sketch troverete alcune parti commentate, togliendo il commento ad alcune linee di codice, potrete impostare il funzionamento per una delle tre tipologie di stepper.

Una delle attività svolte nello scorso anno scolastico dai miei allievi è stato il recupero di tutti gli stepper dei vecchi pc alienati della scuola, ciò mi ha permesso di realizzare velocemente tutta una serie di esercitazioni sull’uso dei motori passo passo.

Gli tutti gli stepper recuperati sono stati posti su supporti stampati in 3D e fissati su basette di compensato. L’utilizzo degli stepper dei CD-ROM consente inoltre di realizzare attività di progetto interessanti, come ad esempio piccoli plotter oppure dei laser engraver.

Raccomandazioni per i miei studenti

Punto 1

Ricordate di individuare le bobine di un motore passo passo, l’operazione è un po’ difficoltosa per i passo passo dei CD-ROM che in genere non sono identificati da colori o dalla posizione.
Prima di collegare il motore alla scheda motori è necessario individuare i cavi A+, A-, B+ e B- sul motore. La maniera migliore è quella di consultare la scheda tecnica del motore in cui vi è una corrispondenza tra colore filo e cavo. In alternativa potete utilizzare un multimetro in modalità ohmmetro e misurare la resistenza tra le coppie dei cavi, quando misurerete un valore tra i 2 e i 4 ohm tra due terminali avrete individuato una delle bobine.

Punto 2

Sempre per i passo passo dei CD-ROM i fili di collegamento sono saldati al motore ed il punto di saldatura è molto piccolo, inoltre i fili di collegamento sono sottili è molto alto il rischio di romperli. Per evitare ciò ho utilizzato una strategia semplice ed economica, un ponte con un mammut su cui collego poi i fili che vanno ad essere collegati alla breadboard, così come rappresentato nell’immagine.

Punto 3

La spiegazione del funzionamento di ogni sketch è dettagliata con commenti nello sketch e tutti gli esempi sono da considerare come base di partenza per le esercitazioni svolte in presenza.

Esempio 1

Controllo rotazione stepper da Serial Monitor mediante tastiera. Valori positivi rotazione oraria, valori negativi rotazione antioraria

1// Prof. Michele Maffucci
2// 20.10.2020
3 
4// Controllo rotazione stepper mediante tastiera
5// valori positi rotazione oraria
6// valori negativi rotazione antioraria
7 
8#include <Stepper.h>
9 
10int in1Pin = 12;
11int in2Pin = 11;
12int in3Pin = 10;
13int in4Pin = 9;
14 
15/*
16in1 L293D - pin 12 Arduino
17in1 L293D - pin 11 Arduino
18in1 L293D - pin 10 Arduino
19in1 L293D - pin 9 Arduino
20*/
21 
22// 200 per stepper 17PM-M041-P1 - 12 V - 1,8 gradi per step
23 
24// 200 per microstepper CDROM - 5 V - 1,8 gradi per step
25// per evitare che slitti sul supporto impostare 170 come limite massimo
26 
27// 512 per stepper 28BY J-48 - 5 V - 5,525 gradi per step
28// per questo stepper il valore passato non e' step/giro 
29// per un giro completo 2048 step. 512 equivale ad 1/4 di giro 
30 
31// inizializzazione della libreria Stepper
32 
33const int stepPerGiro = 200;  // adattare al passo di rotazione del vostro stepper
34 
35Stepper myStepper(stepPerGiro, in1Pin, in2Pin, in3Pin, in4Pin);  
36  
37void setup()
38{
39  pinMode(in1Pin, OUTPUT);
40  pinMode(in2Pin, OUTPUT);
41  pinMode(in3Pin, OUTPUT);
42  pinMode(in4Pin, OUTPUT);
43   
44  Serial.begin(9600);
45   
46  // rotazioni per minuto, funzione dello stepper a disposizione
47  // e' un valore positivo.
48  // la funzione setSpeed non fa ruotare il stepper, imposta solamente la velocita'
49  myStepper.setSpeed(70);    // imposta la velocita' di rotazione a 20 rpm:
50}
51 
52void loop()
53{
54  if (Serial.available())
55  {
56    int steps = Serial.parseInt();
57     
58    // valori positivi fanno girare il mySteppere in senso orario
59    // valori negativi fanno girare il mySteppere in senso antioraio
60    myStepper.step(steps);
61  }
62}

Esercizio 2

Realizzare uno sketch che permetta di contare il numero di passi di rotazione fissato il numero di step per passo. Si evidenzi il raggiungimento di un passo con l’accensione di un LED.

Si visualizzi sulla serial monitor il messaggio:

“PASSO” – passo rotazione modulo “MODULO” passo: “CONTATORE STEP”

sono variabili:

“PASSO”,
“MODULO”
“CONTATORE STEP”

Nell’esempio:

PASSO: numero sequenziale
MODUOLO: step per passo
CONTATORE STEP: modulo del passo

1// Prof. Michele Maffucci
2// 20.10.2020
3 
4// contatore passi
5// il programma puo' pilotare stepper unipolari o bipolari
6// il numero di passi fissato nella variabile moduloStep
7// ad ogni passo viene rilevato anche da un LED
8 
9// 200 per stepper 17PM-M041-P1 - 12 V - 1,8 gradi per step
10 
11// 200 per microstepper CDROM - 5 V - 1,8 gradi per step
12// per evitare che slitti sul supporto impostare 170 come limite massimo
13 
14// 512 per stepper 28BY J-48 - 5 V - 5,525 gradi per step
15// per questo stepper il valore passato non e' step/giro 
16// per un giro completo 2048 step. 512 equivale ad 1/4 di giro 
17 
18 
19#include <Stepper.h>
20 
21const int stepPerGiro = 170;  // adattare al passo di rotazione del vostro stepper
22 
23// inizializzazione della libreria Stepper
24Stepper myStepper(stepPerGiro, 12, 11, 10, 9);
25 
26int contatorePassi = 0;         // numero di step raggiunto
27int moduloStep = 20;            // modulo rotazione stepper da 1 a numero massimo di passi
28                                // se moduloStep = 1 diventa un contatore di step
29int conta = 0;                  // conteggio fase
30 
31int ledPin = 7;                 // led rilevamento fase
32 
33void setup() {
34  // inizializzazione porta seriale
35  Serial.begin(9600);
36  // imposta la velocita' di rotazione a 20 rpm
37  myStepper.setSpeed(20);
38   
39  pinMode(ledPin, OUTPUT);
40}
41 
42void loop() {
43  // passi di rotazione
44  myStepper.step(moduloStep);
45  Serial.print(conta);
46  Serial.print(" - ");
47  Serial.print("passo rotazione modulo ");
48  Serial.print(moduloStep);
49  Serial.print(" ");
50  Serial.print("passo: ");
51  Serial.println(contatorePassi);
52  digitalWrite(ledPin, HIGH);
53  conta++;
54  contatorePassi=contatorePassi+moduloStep;
55  if (contatorePassi &amp;gt; stepPerGiro){
56    contatorePassi = 0;
57    conta = 0;
58  }
59  delay(500);
60  digitalWrite(ledPin, LOW);
61}

Variante per stepper 28BY J 48

1// Prof. Michele Maffucci
2// 20.10.2020
3 
4// contatore passi
5// il programma puo' pilotare stepper unipolari o bipolari
6// il numero di passi fissato nella variabile moduloStep
7// ad ogni passo viene rilevato anche da un LED
8 
9// in questo sketch si puo' effettuare le dovute correzioni per lo stepper
10// 28BY J-48
11 
12// 200 per stepper 17PM-M041-P1 - 12 V - 1,8 gradi per step
13 
14// 200 per microstepper CDROM - 5 V - 1,8 gradi per step
15// per evitare che slitti sul supporto impostare 170 come limite massimo
16 
17// 512 per stepper 28BY J-48 - 5 V - 5,525 gradi per step
18// per questo stepper il valore passato non e' step/giro
19// per un giro completo 2048 step. 512 equivale ad 1/4 di giro
20 
21 
22#include <Stepper.h>
23 
24const int stepPerGiro = 512;  // adattare al passo di rotazione del vostro stepper
25 
26const int BY = 1;             // 1 uso di BY - 0 uso di altro motore passo passo
27 
28// inizializzazione della libreria Stepper
29Stepper myStepper(stepPerGiro, 11, 9, 10, 8);
30 
31int contatorePassi = 0;         // numero di step raggiunto
32int moduloStep = 512;           // modulo rotazione stepper da 1 a numero massimo di passi
33// se moduloStep = 1 diventa un contatore di step
34int conta = 0;                  // conteggio fase
35 
36int ledPin = 13;                 // led rilevamento fase
37 
38void setup() {
39  // inizializzazione porta seriale
40  Serial.begin(9600);
41  // imposta la velocita' di rotazione a 20 rpm
42  myStepper.setSpeed(70);
43 
44  pinMode(ledPin, OUTPUT);
45}
46 
47void loop() {
48  // passi di rotazione
49  myStepper.step(moduloStep);
50  Serial.print(conta);
51  Serial.print(" - ");
52  Serial.print("passo rotazione ");
53  Serial.print("modulo ");
54  Serial.print(moduloStep);
55  Serial.print(" ");
56  Serial.print("passo: ");
57  Serial.println(contatorePassi);
58  digitalWrite(ledPin, HIGH);
59  contatore();
60  delay(500);
61  digitalWrite(ledPin, LOW);
62}
63 
64// funzione che conta i passi in funzione dello stepper utilizzato
65void contatore() {
66  conta++;
67  contatorePassi = contatorePassi + moduloStep;
68  switch (BY) {
69    case 0:
70      if (contatorePassi &amp;gt; stepPerGiro) {
71        contatorePassi = 0;
72        conta = 0;
73      }
74      break;
75    case 1:
76      if (contatorePassi &amp;gt; stepPerGiro * 4) {
77        contatorePassi = 0;
78        conta = 0;
79      }
80      break;
81  }
82}

Esempio 3

Realizzare uno sketch che permetta di far compiere in modo continuo un giro completo in senso orario ed uno in senso antiorario.

Svolgere l’esercizio sia con lo stepper 28BY J-48 che con il microstepper del CDROM

Noterete che per il microstepper del CDROM il carrello giunto alla fine slitta, in quanto 200 step per rotazione sono troppi. Valutare (in modo empirico) quanti stemp sono necessari affinche il carrello non slitti e modificare lo sketch di conseguenza.

Variante 1

Fare in modo che al completamento di un giro venga acceso un diodo LED

Variante 2

Utilizzando il microstepper fare in modo che il verso di spostamento della slitta sia segnalato da due LED ed i LED siano accesi in modo alternato in funzione del verso di scorrimento della slitta

- Direzione 1 – LED rosso acceso, LED verde spendo
- Direzione 2 – LED rosso spento, LED verde acceso

1// Prof. Michele Maffucci
2// 20.10.2020
3 
4// rotazione oraria e antioraria sequenziale
5 
6/*
7in1 L293D - pin 12 Arduino
8in1 L293D - pin 11 Arduino
9in1 L293D - pin 10 Arduino
10in1 L293D - pin 9 Arduino
11*/
12 
13// 200 per stepper 17PM-M041-P1 - 12 V - 1,8 gradi per step
14 
15// 200 per microstepper CDROM - 5 V - 1,8 gradi per step
16// per evitare che slitti sul supporto impostare 170 come limite massimo
17 
18// 512 per stepper 28BY J-48 - 5 V - 5,525 gradi per step
19// per questo stepper il valore passato non e' step/giro 
20// per un giro completo 2048 step. 512 equivale ad 1/4 di giro
21 
22#include <Stepper.h>
23 
24const int stepPerGiro = 170;  // adattare al passo di rotazione del vostro stepper
25 
26// inizializzazione della libreria Stepper
27Stepper myStepper(stepPerGiro, 12, 11, 10, 9);
28 
29void setup() {
30  // inizializzazione porta seriale
31  Serial.begin(9600);
32  // imposta la velocita' di rotazione a 60 rpm:
33  myStepper.setSpeed(60);
34}
35 
36void loop() {
37  // un giro completo in senso orario
38  Serial.println("antiorario");
39  myStepper.step(stepPerGiro);
40  delay(500);
41   
42  // un giro completo in senso antiorario
43  Serial.println("orario");
44  myStepper.step(-stepPerGiro);
45  delay(500);
46}

Esempio 4

Realizzare uno sketch che permetta di far cambiare il senso di rotazione alla pressione di un pulsante.
Rilevare la pressione del pulsante con l’accensione del LED collegato al pin 13.
Si colleghi il pulsante al pin 2 di Arduino, secondo quanto specificato nello schema di seguito. Utilizzare per questo esercizio il microstepper.

1// Prof. Michele Maffucci
2// 20.10.2020
3 
4// Cambio direzione rotazione alla pressione di un pulsante
5 
6// il programma puo' pilotare stepper unipolari o bipolari
7// il numero di passi  fissato nella variabile moduloStep
8// ad ogni passo viene rilevato anche da un LED
9 
10// 200 per stepper 17PM-M041-P1 - 12 V - 1,8 gradi per step
11 
12// 200 per microstepper CDROM - 5 V - 1,8 gradi per step
13// per evitare che slitti sul supporto impostare 170 come limite massimo
14 
15// 512 per stepper 28BY J-48 - 5 V - 5,525 gradi per step
16// per questo stepper il valore passato non e' step/giro
17// per un giro completo 2048 step. 512 equivale ad 1/4 di giro
18 
19 
20#include <Stepper.h>
21 
22const int stepPerGiro = 200;  // adattare al passo di rotazione del vostro stepper
23 
24// inizializzazione della libreria Stepper
25Stepper myStepper(stepPerGiro, 12, 11, 10, 9);
26 
27int contatorePassi = 0;         // numero di step raggiunto
28int moduloStep = 10;            // modulo rotazione stepper da 1 a numero massimo di passi
29                                // se moduloStep = 1 diventa un contatore di step
30 
31int moduloStepCorrente;         // variabile in cui memorizzare la direzione di rotazione corrente
32                                // alla pressione del pulsante
33 
34 
35const int pinPulsante = 2;      // pin a cui e' collegato il pulsante
36const int ledPin = 13;          // pin a cui e' collegato il LED
37 
38int statoPulsante = 0;           // stato corrente del pulsante
39 
40 
41void setup() {
42   
43  // inizializzazione pin a cui e' collegato il pulsante
44  pinMode(pinPulsante, INPUT);
45   
46  // inizializzazione pin a cui e' collegato il LED
47  pinMode(ledPin, OUTPUT);
48 
49  // imposta la velocita' di rotazione a 20 rpm
50  myStepper.setSpeed(20);
51}
52 
53void loop() {
54 
55  statoPulsante = digitalRead(pinPulsante);
56  if (statoPulsante == HIGH) {
57    digitalWrite(ledPin, HIGH);
58    moduloStepCorrente = -moduloStep;
59    myStepper.step(moduloStepCorrente);
60  }
61  else {
62    digitalWrite(ledPin, LOW);
63    myStepper.step(moduloStep);
64  }
65}

Utilizzare il sensore di distanza VL530X con Arduino

Lascia una risposta

Ho parlato di questo sensore di distanza quando qualche settimana fa mostrai come utilizzarlo con M5Stack mini: 5 min al giorno di sperimentazione con M5Stack mini – Sensore TOF seguendo il link trovate tutte le indicazioni sul principio di funzionamento ed una serie di dati tecnici che potrebbero essere utili per il vostro studio. Riprendo alcune parti del mio post in modo che le vostre sperimentazioni possano essere più agevoli:

…un sensore ToF (Time of Flight: tempo di volo) VL53L0X effettua un conteggio del tempo totale di volo dei fotoni dal momento in cui vengono emessi da un piccolissimo raggio laser al momento in cui viene rilevata la riflessione su un fotodiodo collocato sul sensore.
In generale il tempo di volo (spesso indicato con TOF, dall’inglese Time Of Flight) indica la misura del tempo impiegato da un oggetto, una particella o un’onda (elettromagnetica, acustica, elettromagnetica o di altro tipo) per percorrere una certa distanza in un mezzo determinato….
Il sensore ToF di cui dispongo è un VL53L0X che incorporato un emettitore Laser VCSEL ed un fotodiodiodo ricevitore SPAD. Il laser è in grado di emettere impulsi a 940 nm (prossimi al campo infrarosso). Il fotodiodiodo SPAD è estremamente sensibile al singolo fotone e grazie alla schermatura di cui è costituito riceve soltanto la lunghezza d’onda di 940 nm del laser.

Seguendo il link potete prelevare il datasheet del VL530X prodotto da ST.

Il sensore utilizzato con M5Stack mini è dotato di connettore GROVE, mentre la versione utilizzata per questo tutorial è una scheda breakout che potrete facilmente collegare ad Arduino.

Acquistai una serie di questi sensori per realizzare un sistema di rilevazione ostacoli di tipo laser per i kit robotici che faccio realizzare ai miei studenti, EduRobot e DotBot, ma poiché la situazione didattica di questi mesi è mutata drasticamente a causa dell’emergenza sanitaria, ho deciso di riutilizzare i sensori per un progetto semplice che iniziai qualche settimana fa: un bracciale per valutare la distanza tra le persone, sistema che per altro in diversi ambiti mi è stato chiesto di sviluppare.

Vin alimentazione del sensore, 3-5V. Collegate +5V di Arduino.
GND da connettere al GND di Arduino
SCL ed SDA dovranno essere connessi ai corrispondenti pin della scheda Arduino utilizzata, nel caso di un Arduino UNO R3 A5: SCL e A4: SDA

Installare la libreria Adafruit_VL53L0X Library Sketch > Include Library > Manage Libraries…:

Cercare la libreria Adafruit VL53L0X all’interno del motore di ricerca e procedere con l’installazione:

Aprire da File->Examples->Adafruit_VL53L0X->vl53l0x ed effettuare l’upload sulla scheda Arduino

Di seguito trovate gli sketch di esempio in cui ho effettuato alcune traduzioni:

1#include "Adafruit_VL53L0X.h"
2 
3Adafruit_VL53L0X lox = Adafruit_VL53L0X();
4 
5void setup() {
6  Serial.begin(115200);
7 
8  // per i dispositivi USB nativi, attende fino a quando la serial port non risulta disponibile
9  while (! Serial) {
10    delay(1);
11  }
12   
13  Serial.println("Test Adafruit VL53L0X");
14  if (!lox.begin()) {
15    Serial.println(F("Impossibile avviare VL53L0X"));
16    while(1);
17  }
18  // power 
19  Serial.println(F("VL53L0X API Esempio: misura distanza\n\n")); 
20}
21 
22 
23void loop() {
24  VL53L0X_RangingMeasurementData_t measure;
25     
26  Serial.print("Lettura misura... ");
27  lox.rangingTest(&measure, false); // se si inserisce 'true' si avvia la stampa dei dati di debug!
28 
29  if (measure.RangeStatus != 4) {  // dati errati
30    Serial.print("Distanza (mm): "); Serial.println(measure.RangeMilliMeter);
31  } else {
32    Serial.println(" fuori portata ");
33  }
34     
35  delay(100);
36}

Aprite serial monitor ed impostate la velocità a 115200 baud

Muovete la vostra mano sul sensore per leggere la misura della distanza tra mano e sensore, noterete che quando non viene rilevato nulla sulla serial monitor verrà visualizzato il messaggio: out of range (fuori portata).

Modificare l’indirizzo assegnato al sensore

Durante l’inizializzazione, invece di usare la funzione lox.begin(), usare lox.begin(0x30) per impostare l’indirizzo su 0x30 sul nuovo sensore aggiunto, oppure in qualsiasi parte dello sketch, quando deve essere usato il sensore usare la funzione lox.setAddress(0x30).

Connessione di più sensori

Nel caso abbiate la necessità di connettere più sensori bisognerà che ognuno di essi abbia un indirizzo I2C diverso. L’indirizzo predefinito per VL53L0X è 0x29 ma è possibile modificarlo via software. Gli indirizzi che possono essere utilizzati vanno da 0x30 a 0x3F.

Reset di tutti i sensori impostando i pin XSHUT a LOW per un tempo di 10 millisecondi.
Mantenere il sensore 1 attivo mantenendo a HIGH il pin XSHUT a HIGH.
Disattivare tutti gli altri sensori impostando i loro pin XSHUT a LOW
Inizializzare il sensore 1 con lox.begin(nuovo_i2c_address). Scegliere qualsiasi indirizzo tranne 0x29, dovete scegliere un indirizzo inferiore a 0x7F, scegliere un indirizzo nell’intervallo 0x30 a 0x3F.
Mantenere attivo il sensore n. 1 e disattivate il sensore n. 2 impostando il pin XSHUT ad HIGH.
Inizializzare il sensore n. 2 usando la funzione lox.begin (nuovo_i2c_address). Scegliere qualsiasi indirizzo tranne 0x29, l’indirizzo da scegliere dovrà rientrare nel range ammesso (0x30 a 0x3F).
Ripetere l’operazione per ciascun sensore, attivarli e assegnare ad ognuno un indirizzo diverso.

Attenzione che l’assegnazione dell’indirizzo non è permanente, in mancanza di alimentazione viene persa memoria dell’indirizzo assegnato a tutti i sensori, quindi la procedura deve essere ripetuta ogni volta che viene alimentato il circuito.

Nel caso abbiate un solo sensore l’indirizzo assegnato in automatico di default nel momento che date alimentazione è sempre 0x29.

Se operate con due sensori, per assegnare automaticamente gli indirizzi utilizzare lo sketch presente negli esempi che troverete all’interno della cartella della libreria Adafruit_VL53L0X: vl53l0X_dual

1#include "Adafruit_VL53L0X.h"
2 
3// indirizzi assegnati se sono presenti due sensori
4#define LOX1_ADDRESS 0x30
5#define LOX2_ADDRESS 0x31
6 
7// impostazione dei pin per lo spegnimento dei sensori
8#define SHT_LOX1 7
9#define SHT_LOX2 6
10 
11// creazioni degli oggetti vl53l0x
12Adafruit_VL53L0X lox1 = Adafruit_VL53L0X();
13Adafruit_VL53L0X lox2 = Adafruit_VL53L0X();
14 
15// per memorizzare le misure
16VL53L0X_RangingMeasurementData_t measure1;
17VL53L0X_RangingMeasurementData_t measure2;
18 
19/*
20  - Il reset dei sensori viene fatto impostando tutti i pin XSHUT a LOW per 10 millisecondi 'delay(10)',
21    successivamente, per uscire dal reset tutti gli XSHUT vemgono posti ad HIGH.
22  - Mantiene il sensore 1 attivo mantenedo il pin XSHUT HIGH
23  - Tutti gli altri sensori vengono disattivati ponendo a LOW i pin XSHUT
24  - L'inizializzazione del sensore n.1 avviene con lox.begin(new_i2c_address). Scegliere qualsiasi diverso da 0x29 ed inferiore a 0x7F.
25    Scegliere un valore compreso tra 0x30 a 0x3F.
26  - Mantiene il sensore n.1 attivo e disattiva il sensore n.2 impostando il pin XSHUT ad HIGH.
27  - L'inizializzazione del sensore n.2 avviene con lox.begin (new_i2c_address). Scegliere qualsiasi diverso da 0x29 o da qualsiasi indirizzo impostato per l'altro ensore.
28 */
29void setID() {
30  // reset di tutti i sensori
31  digitalWrite(SHT_LOX1, LOW);    
32  digitalWrite(SHT_LOX2, LOW);
33  delay(10);
34  // attivazione dei sensori
35  digitalWrite(SHT_LOX1, HIGH);
36  digitalWrite(SHT_LOX2, HIGH);
37  delay(10);
38 
39  // attivazione di LOX1 e reset di LOX2
40  digitalWrite(SHT_LOX1, HIGH);
41  digitalWrite(SHT_LOX2, LOW);
42 
43  // inizializzazione di LOX1
44  if(!lox1.begin(LOX1_ADDRESS)) {
45    Serial.println(F("Errore nell'avvio del primo VL53L0X"));
46    while(1);
47  }
48  delay(10);
49 
50  // attivazione di LOX2
51  digitalWrite(SHT_LOX2, HIGH);
52  delay(10);
53 
54  //inizializzazione di LOX2
55  if(!lox2.begin(LOX2_ADDRESS)) {
56    Serial.println(F("Errore nell'avvio del secondo VL53L0X"));
57    while(1);
58  }
59}
60 
61void read_dual_sensors() {
62   
63  lox1.rangingTest(&measure1, false); // se si inserisce 'true' si avvia la stampa dei dati di debug!
64  lox2.rangingTest(&measure2, false); // se si inserisce 'true' si avvia la stampa dei dati di debug!
65 
66  // stampa la lettura dei dati del primo sensore
67  Serial.print("1: ");
68  if(measure1.RangeStatus != 4) {     // se non si è fuori portata
69    Serial.print(measure1.RangeMilliMeter);
70  } else {
71    Serial.print("Fuori portata");
72  }
73   
74  Serial.print(" ");
75 
76  // stampa la lettura dei dati del secondo sensore
77  Serial.print("2: ");
78  if(measure2.RangeStatus != 4) {
79    Serial.print(measure2.RangeMilliMeter);
80  } else {
81    Serial.print("Fuori portata");
82  }
83   
84  Serial.println();
85}
86 
87void setup() {
88  Serial.begin(115200);
89 
90  // per i dispositivi USB nativi, attende fino a quando la serial port non risulta disponibile
91  while (! Serial) { delay(1); }
92 
93  pinMode(SHT_LOX1, OUTPUT);
94  pinMode(SHT_LOX2, OUTPUT);
95 
96  Serial.println("Inizio spegnimento...");
97 
98  digitalWrite(SHT_LOX1, LOW);
99  digitalWrite(SHT_LOX2, LOW);
100 
101  Serial.println("Entrambi in modalità ripristino...(i pin sono a LOW)");
102   
103   
104  Serial.println("Avvio...");
105  setID();
106  
107}
108 
109void loop() {
110    
111  read_dual_sensors();
112  delay(100);
113}

Buon Making a tutti

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Schema di collegamento (con alimentazione presa da scheda Arduino)

Schema di collegamento (con alimentazione esterna)

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Schema di collegamento
(con alimentazione presa da scheda Arduino)

Schema di collegamento
(con alimentazione esterna)