Archivi categoria: arduino

Errori comuni nell’uso di Arduino – usare troppa memoria RAM

Nella collezione degli errori nell’uso di Arduino aggiungo l’uso improprio della memoria Flash (RAM) disponibile all’interno del microcontrollore. La dimensione della memoria RAM differisce sulle varie schede Arduino, nell’esempio prendo in considerazione la scheda Arduino UNO R3.

Nell’esempio che segue, un semplice Blink, viene dichiarato un array di interi che in fase di compilazione provocherà un errore di dimensione troppo grande dell’array:

// laMiaCollezione è un array di interi che ha una dimensione di:
// (20000x16)/8=40kB
// superiore alla RAM disponibile in un Arduino UNO R3 che è di 32kB 
// si faccia riferimento al seguente link:
// https://www.arduino.cc/en/tutorial/memory

int laMiaCollezione[20000];

void setup() {
  Serial.begin (9600);
  Serial.println ("Avvio programma");
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000); 
}

Dovreste rilevare l’errore indicato nell’immagine che segue:

Se non vedete il led L (connesso al pin13) lampeggiare o rilevate un errore simile a quello indicato nell’immagine sopra, vuol dire che state utilizzando troppa memoria RAM. Fate attenzione che molte librerie utilizzano la RAM (ad es. Libreria di schede SD, librerie LCD, ecc.).

Nel link allegato nello sketch di esempio potete consultare la pagina specifica di Arduino.cc in cui viene spiegato come viene usata la memoria sull’Arduino UNO R3:

  • Flash 32k byte (di cui 0.5k usato per il bootloader)
  • SRAM 2k byte
  • EEPROM 1k byte

Nel dettaglio:

  • 32kB (1024×32=32768bit) di memoria Flash di cui 0,5 kB (equivalenti a 512 bit) sono dedicati al bootloader.
    Il microcontrollore presente sull’Arduino UNO R3 è un ATmega328P. All’interno della memoria Flash (RAM) del microcontrollore è presente una zona di memoria riservata in cui viene allocato il Bootloader, un programma che ha il compito di controllare se dopo il reset della scheda vie è la possibilità di caricare in memoria, tramite la USB, un nuovo programma creato dall’utente. Se non è presente nessun nuovo programma il controllo passa all’inizio del programma presente in memoria, quello precedentemente caricato e viene eseguito e il controllo non ritorna più al Bootloader fino a quando non si esegue un nuovo reset della scheda, reset che avviene quando viene caricato una nuovo programma dell’utente.
  • 2 KB di SRAM (2048 bit), è una RAM statica volatile utilizzata per gestire le variabili contenute nel programma (sketch) creato dall’utente e i dati che servono al microcontrollore per funzionare.
  • 1KB di EEPROM (1024 bit) memoria i cui valori vengono mantenuti anche quando la scheda viene spenta.

Esercizio

Nello sketch riportato sopra quel è il numero massimo di interi che può ospitare l’array laMiaCollezione affinché non si incorri nell’errore di memoria RAM piena?

Arduino – Esercizio: Realizzare un timer per il lavaggio delle mani

Di seguito mostro parte della soluzione agli esercizi assegnati ai miei studenti negli scorsi giorni in riferimento alla progettazione di un semplice dispositivo di automazione da collocare in bagno in prossimità del lavandino, in grado di rilevare ad una distanza minima fissata la presenza delle mani e l’avvio di un timer che mostra il trascorrere del tempo. L’indicazione del tempo che trascorre viene realizzata con un servomotore a cui dovrà poi essere fissata una lancetta e che mostra il trascorrere del tempo su una scala graduata. Il tempo di lavaggio viene fissato a 30 secondi. Sulla serial monitor dovrà essere indicato lo stato di avvio del sistema ed il tempo.

Soluzione

Controllo servomotore

// Prof. Maffucci Michele
// gestione servomotore

#include <Servo.h>

int pos = 0;

Servo mioServo;

// scrivere pos +=1 è la stessa cosa che scrivere pos = pos + 1

void setup()
{
  mioServo.attach(9);
}

void loop()
{
  // muove il servo da 0 a 180 gradi
  // con passi di 1 grado
  
 for (pos = 0; pos <= 180; pos += 1) {
    // viene detto al servo di posizionarsi
    // nella posizione inserita nella variabile 'pos'
    mioServo.write(pos);
    // attende 15 ms wait 15 ms
	// per far raggiungere il sevo la posizione
    delay(15); // attesa di 15 millisecondi
  }
  for (pos = 180; pos >= 0; pos -= 1) {
    // viene detto al servo di posizionarsi
    // nella posizione inserita nella variabile 'pos'
    mioServo.write(pos);
    // attende 15 ms wait 15 ms
	// per far raggiungere il sevo la posizione
    delay(15); // attesa di 15 millisecondi
  }  
}

Controllo sensore ultrasuoni

// Prof. Maffucci Michele
// Impostazione sensore ultrasuoni

// distanza minima dell'ostacolo (in cm)

const int distanzaMinima = 20;
int misuraDistanza = 0;

long durata;          // durata dell'impulso
long distanza;        // distanza dell'oggetto
int pin_segnale = 7;  // pin Arduino a cui è collegato il sensore SR04
int pin_trig = 10;    // pin Arduino a cui è collegato il sensore SR04


void setup()
{
    Serial.begin(9600);
	pinMode(pin_trig, OUTPUT);
  	pinMode(pin_segnale, INPUT);
  	Serial.println("Sensore ad ultrasuini");
}

void loop()
{
  Serial.print("Distanza ostacolo: ");
  Serial.println(distanzaOstacolo());
  delay(100);
}

// rilevazione distanza ostacolo

// misura la distanza dell'ostacolo
long distanzaOstacolo()
{
  digitalWrite(pin_trig, LOW);
  delayMicroseconds(2);
  digitalWrite(pin_trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(pin_trig, LOW);
  durata = pulseIn(pin_segnale, HIGH);
  distanza = (durata / 2) / 29.1;
  delay(100);
  return distanza;
}

Timer lavaggio mani

// Prof. Maffucci Michele
// realizzazione di un timer
// per il lavaggio delle mani
// in un tempo di 30 secondi

#include <Servo.h>

// Impostazione servomotore
int pos = 0;

Servo mioServo;

// Impostazione sensore ultrasuoni

// distanza minima dell'ostacolo (in cm)

const int distanzaOstacolo = 20;
int misuraDistanza = 0;

long durata;          // durata dell'impulso
long distanza;        // distanza dell'oggetto
int pin_echo = 7;     // pin Arduino a cui è collegato il sensore SR04
int pin_trig = 10;    // pin Arduino a cui è collegato il sensore SR04

void setup() {
    Serial.begin(9600);
    mioServo.attach(9);
	pinMode(pin_trig, OUTPUT);
  	pinMode(pin_echo, INPUT);
  	
// Posizionamento iniziale del servo
  
  mioServo.write(180);
  delay(500);
  mioServo.write(0);
  delay(500);
  mioServo.write(180);

// Avvio alla partenza
  
  Serial.println("Avvio programma lavaggio mani"); 
}

void loop() {
  
  // Se la distanza delle mani dal rubinetto è
  // inferiore alla distanzaOstacolo si avvia il timer
  
    if (misuraDistanzaOstacolo() < distanzaOstacolo) {
    	contoAllaRovesciaServo();
  }
  delay(100);
}


// Conto alla rovescia
// sposta il servo di 6 gradi ogni secondo

void contoAllaRovesciaServo() {
  Serial.println("Conto alla rovescia: ");
  int passi = 30;
  
  for (int i = passi; i >= 0; i--) {

    mioServo.write(i * 6);
    delay(1000);
    Serial.print(i);
    Serial.println(" sec");

  }

  // azzeramento del servo.
  // Le mani sono pulite
  mioServo.write(180);
  delay(500);
}

// misura la distanza dell'ostacolo
long misuraDistanzaOstacolo()
{
  digitalWrite(pin_trig, LOW);
  delayMicroseconds(2);
  digitalWrite(pin_trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(pin_trig, LOW);
  durata = pulseIn(pin_echo, HIGH);
  distanza = (durata / 2) / 29.1;
  delay(100);
  return distanza;
}

Esercizio 1

Modificare lo sketch precedente aggiungendo due LED, verde e rosso. Lo stato di riposo, timer non funzionante, deve essere indicato dal LED verde acceso e Led rosso spento, mentre lo stato di funzionamento del timer deve essere evidenziato dal LED verde spento e LED rosso acceso.

Esercizio 2

Modificare lo sketch precedente aggiungendo due LED, verde e rosso e un buzzer. Lo stato di riposo, timer non funzionante, deve essere indicato dal LED verde acceso e Led rosso spento, all’avvio del timer il buzzer deve emettere una nota ad una frequenza fissata per un tempo di  1 secondo. Lo stato di funzionamento del timer deve essere evidenziato dal LED verde spento e LED rosso acceso, allo scadere del tempo di lavaggio deve essere emessa una nota di durata 1 secondo ad una frequenza diversa dalla nota di avvio.

Esercizio 3

Realizzare l’esercizio 2 con le medesime caratteristiche e componenti, però sostituendo il servomotore usato come indicatore, con un display LCD 16×2 che indichi il trascorrere del tempo.

Buon lavoro 🙂

Errori comuni nell’uso di Arduino – inizializzazione di più variabili

La tentazione di risparmiare linee di codice è sempre in agguato e tentare di inizializzare più variabili su una sola riga è forte, però alcune volte ciò che intendiamo fare non corrisponde a ciò che correttamente intende il compilatore.

Con la scrittura:

int x, y, z = 67;

non viene assegnato il valore 67 ad ogni singola variabile, ma solamente la variabile z viene inizializzata a 67.

L’errore quindi non risiede nella scrittura, il compilatore non restituirà errore, ma nel modo in cui il programmatore intende l’assegnamento credendo che tutte le variabili vengano inizializzate a 67.

La scrittura

int x = 67, y = 67, z = 67;

permette l’assegnamento del valore 67 ad ogni singola variabile. Si ricordi di separare ogni assegnamento da una virgola, ciò accade solo e soltanto se si indicano tipo e assegnamento su stessa linea.

Per l’assegnamento di valori diversi scriveremo:

int x = 99, y = 3, z = 67;

Io in genere preferisco una scrittura di questo tipo:

int x = 99;
int y = 3;
int z = 67;

che permette di visualizzare meglio le variabili utilizzate, non favorisce fraintendimenti nell’assegnamento e permette inoltre di scrivere chiaramente un commento a lato di ogni assegnamento.

Esercizio (semplice semplice 🙂 ) per i miei studenti:

Realizzare uno sketch che dimostra quanto esposto in questo post.

Buon Coding 🙂

Errori comuni nell’uso di Arduino – dimenticare il punto e virgola dopo il return

Errore:

if (contatore < 60)
    return    // manca il punto e virgola
contatore = contatore + 1;

Il codice sopra viene compilato come se fosse:

if (contatore < 60)
return contatore = contatore + 1;

Si ricorda che dopo un return incondizionato il codice che segue non verrà mai eseguito.

Ad esempio:

contatore = contatore + 1;
return contatore;
contatore = 10; // questa linea di codice non verrà mai eseguita

Esercizio (semplice semplice 🙂 ) per i miei studenti di terza:

Realizzare due sketch che accettano un input numerico intero da tastiera (sulla Serial Monitor) che dimostrano le due situazioni esposte nella spiegazione precedente.

Controllo di un motore passo-passo bipolare NEMA17 con Driver L298N

I motori “passo-passo” o “stepper” sono motori elettrici sincroni il cui avanzamento avviene a passo singolo corrispondente ad uno specifico angolo di rotazione, pertanto è possibile farli ruotare a piacimento di un angolo preciso. Uno stepper è in grado di mantenere con precisione velocità di rotazione e posizione senza la necessitò di utilizzo di trasduttori di feedback come dinamo tachimetriche o encoder.
I motori passo-passo sono ampiamente utilizzati nell’ambito dell’automazione industriale: robotica, stampanti, scanner, o per esempio come stanno facendo alcuni miei allievi, per regolare l’inclinazione di un pannello solare per realizzare un inseguitore solare.

Rispetto ad altre tipologie di motori elettrici il motore passo-passo non modifica la velocità di rotazione in funzione della coppia a cui è sottoposto l’albero rotante, la mantiene costante e nel caso in cui la coppia aumenti il motore si ferma.

I motori stepper per essere pilotati richiedono una sequenza di impulsi generati da appositi circuiti elettronici di controllo.

In laboratorio vedremo come controllare il movimento di un motore passo-passo bipolare con Arduino mediante l’uso di un Motor Driver L298N. Su questo sito ho dettagliato l’uso di questa scheda per controllare motori in CC per robot didattici, però con questo tutorial voglio indicare ai miei studenti come effettuare il controllo di un motore passo passo NEMA17 che dovranno utilizzare nelle prossime esperienze di laboratorio.

Richiami teorici

Lo stepper motor o motore passo-passo è definito anche come “trasduttore elettromeccanico” in quanto converte impulsi elettrici di comando in passi elementari (step) di ampiezza angolare fissata in funzione del tipo di motore.

Questo tipo di motore elettrico per poter funzionare deve essere collegato ad un circuito di alimentazione specifico e ad un sistema di controllo elettronico in grado di governare l’angolo e la velocità di rotazione.
Come per tutti i motori elettrici anche il motore passo-passo è costituito da una parte fissa detta statore ed una parte mobile detta rotore su cui è connesso un albero di rotazione dotato di cuscinetti:

Nello statore sono disposti gli avvolgimenti di rame, costituiti da bobine di rame smaltato (isolato), mentre il rotore è costituito da materiale magnetico.

Esistono tre tipi di motori passo passo:

  • a magnete permanente (PM)
  • a riluttanza variabile (VR)ibrido (HY)

Gli avvolgimenti dello statore sono collegati in modo da realizzare un sistema bifase, ma esistono anche sistemi trifase e polifase ma sono più rari.

I motori passo-passo si suddividono a loro volta in due famiglie:

  • motori bipolari (la corrente negli avvolgimenti statorici scorre nei due versi)
  • motori unipolari (la corrente negli avvolgimenti statorici scorre in un solo verso)

In questa guida prenderà in considerazione solamente i motori a magneti permanenti (PM) e di questi considereremo solamente i motori passo-passo bipolari. La spiegazione teorica e l’utilizzo delle altre tipologie di motori sarà argomento di successive lezioni.

Motore a magnete permanente – motore passo-passo bipolare

Il principio di funzionamento di questa tipologia di motori è basato sull’attrazione di due poli magnetici che presentano polarità differenti. Un polo è costituito da un magnete permanete (calamita) mentre l’altro è il polo di un elettromagnete il cui magnetismo è generato da una corrente che fluisce in spire avvolte su un materiale ferromagnetico.

Si ricorda che facendo scorrere una corrente su una bobina avvolta su un nucleo di ferro viene generato un campo magnetico che presenterà una polarità Nord-Sud secondo la “regola della mano destra”:

immaginiamo di impugnare l’avvolgimento con la mano destra in modo che le dita indichino il verso di percorrenza della corrente, il pollice indicherà la direzione del vettore campo elettromagnetico e la punta del pollice indica il verso del vettore individuando il Nord magnetico:

Per far muovere il rotore dovremo quindi modificare il verso di percorrenza della corrente nelle bobine dello statore in modo che la forza di attrazione Nord-Sud tra i poli dello statore e del rotore generi il moto rotatorio.

Nello statore sono presenti due magneti disposti in maniera ortogonale uno rispetto all’altro su cui sono avvolte due bobina i cui terminali sono nominati: A+ e A-, B+ e B- così sono indicati nelle tabelle tecniche di questi dispositivi (i segni + e – a fianco alle lettere A e B non sono da confondere con la polarità), mentre il rotore è costituito da un magnete permanente costituito quindi da un polo Nord e un polo Sud.

Movimento del rotore

Facendo circolare una corrente continua nell’avvolgimento statorico A+ e A- viene generato un campo magnetico che porterà il rotore a ruotare e a bloccarsi nella posizione in cui le polarità magnetiche saranno opposte, così come indicato nel disegno che segue:

Togliendo alimentazione all’avvolgimento statorico A+ A- e alimentando l’avvolgimento statorico B+ B- si avrà una configurazione differente dei magneti statorici ed una conseguente rotazione di 90° del rotore in senso antiorario, come indicato nel disegno che segue:

Togliendo alimentazione all’avvolgimento statorico B+ B- e alimentando in senso opposto (polarità inversa) l’avvolgimento statorico A+ A- si invertiranno le polarità del campo magnetico ed una rotazione di 90° in senso antiorario del rotore così come indicato nel disegno che segue:

Da ciò si comprende che invertendo il verso di percorrenza della corrente prima prima in un avvolgimento statorico e poi nell’altro si otterrà ogni volta una rotazione di 90° del rotore.
L’alimentazione di una fase alla volta (di un avvolgimento statorico alla volta) è detto a “full step”, cioè passo intero.

La sequenza completa di rotazione è costituita da 4 passi (o 4 fasi) e quindi per ottenere una rotazione continua del rotore bisognerà realizzare la seguente sequenza di alimentazione:

La sequenza di movimento, secondo la tabella sopra indicata, sarà quella dell’immagine che segue dove per semplicità di esposizione è stato semplificato il disegno del motore:

Per invertire il senso di rotazione degli elettromagneti sarà sufficiente quindi invertire la sequenza con cui vengono alimentate le bobine statoriche.

Il movimento del motore può avvenire anche alimentando contemporaneamente entrambe le bobine statoriche, in questo modo il rotore si disporrà a 45° rispetto alla posizione precedente. La tabella delle singole fasi diventa:

la posizione del rotore sarà quella descritta dai disegni che seguono:

Controllo

I fili che costituisco i due poli sono distinti da colori diversi e il controllo del motore passo-passo deve essere effettuato da un driver bipolare, nel nostro caso un L298N.

La sequenza di eccitazione, sarà realizzata da un microcontrollore, nel nostro caso Arduino ed in una successivamente lezione vedremo come controllare uno stepper mediante PLC Siemens 1200 con un’altro tipo di driver.

Il driver bipolare, può essere paragonato in estrema sintesi a 8 interruttori, 4 interruttori per ogni bobina statorica

Elettronicamente il driver bipolare è costituito da un circuito elettronico a doppio ponte H, il nostro L298N, che consente di invertire il senso della corrente nelle bobine statoriche. Gli interruttori del circuito precedente vengono realizzati con transitor mosfet o bjt. Comandando la polarizzazione di coppie di transitor per ogni ponte H sarà possibile alimentare le bobine con polarità diverse.

Nell’esempio che segue viene preso in considerazione un solo ponte H.

Nel circuito sono presenti 4 transitor due NPN (Tr2 e Tr3) e due PNP (Tr1 e Tr4), collegati come indicato nel disegno che segue:

Mediante l’utilizzo di due output digitali di un microcontrollore invieremo sui pin IN1 e IN2 valori HIGH e LOW (tensioni di 5V e 0V) in modo da controllare la polarizzazione dei transitor e il conseguente verso di percorrenza della corrente che circola nella bobina statorica del motore.

Quando nel punto IN1 si ha un valore HIGH e su IN2 un valore LOW, andranno in conduzionei transistor Tr4 e Tr2 provocando la rotazione in un senso del motore

quando nel punto IN1 il segnale è LOW e su IN2 il segnale è HIGH i transistor che andranno in conduzione saranno il Tr1 e il Tr3, provocando la rotazione nel senso opposto al passo precedente:

La modalità di collegamento del circuito impedisce di alimentare contemporaneamente la coppia di transitor evitando così cortocircuiti.
I quattro diodi sono detti diodi di ricircolo ed il loro scopo è quello di proteggere i transistor dalla sovratensione generata dalla bobina statorica (induttanze) nel momento dell’apertura del circuito, infatti quando i transitor passano dalla condizione di conduzione a quella di interdizione (si apre l’interruttore) la corrente circolante dovrebbe andare istantaneamente a zero, ma l’induttore (la bobina statorica del motore) tende ad impedire questa brusca variazione, la tensione sul collettore del transitor tende ad aumentare a valori molto elevati.

Se immaginate il transitor in interdizione come ad un interruttore aperto, che quindi assume una resistenza elevatissima, l’induttore si comporterà per un breve istante come un generatore di tensione cercando di far passare in questa resistenza elevatissima la stessa corrente che era presente quando il bjt si comportava come interruttore chiuso, ma per la legge di ohm (V = RxI) la tensione sul collettore del bjt raggiunge valori molto alti, superiori alla tensione di alimentazione danneggiando il bjt.
Per evitare la distruzione del bjt viene inserito un diodo con catodo rivolto verso il positivo dell’alimentazione.

Durante la conduzione del transistor, il diodo non sarà polarizzato direttamente, mentre quando non sarà polarizzato (interruttore aperto) la corrente non passerà più attraverso il transistor, ma attraverso il diodo polarizzato direttamente.

Realizzazione del circuito

Il NEMA 17 richiede un’alimentazione tipica di 12V. La rotazione completa di 360° del rotore si ottiene facendo compiere 200 passi al motore. Ogni passo corrisponderà ad un angolo di 1,8°. La velocità massima che questo tipo di motore può raggiungere è di 60 RPM (dall’inglese revolutions per minute in italiano rotazioni per minuto giri/min).

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.

Collegare l’alimentazione esterna a 12V al terminale VCC e mantenere posizionare i jumper (i ponticelli) ENA ed ENB come indicato nell’immagine che segue in modo che il motore passo passo sia sempre abilitato al funzionamento.

Effettuare il collegamento dei pin di ingresso (IN1, IN2, IN3 e IN4) del modulo L298N a quattro pin di uscita digitale Arduino, nell’esempio sono stati utilizzati i pin: 8, 9, 10 e 11.

Collegare i fili A +, A-, B + e B- dal motore passo-passo al modulo come mostrato nell’immagine che segue.

Lo sketch indicato di seguito, che potrete utilizzare come base di partenza per le vostre sperimentazioni, permetterà di controllare il motore passo-passo facendogli compiere ripetutamente un giro in senso orario ed uno in senso antiorario.

// Inclusione della libreria stopper
#include <Stepper.h>

// Numero di step (passi) per effettuare una rotazione completa
const int stepPerRotazione = 200;

// Creazione dell’istanza dello Stepper
Stepper mioStepper(stepPerRotazione, 8, 9, 10, 11);

void setup()
{
    // impostazione della rotazione a 60 rpm:
    mioStepper.setSpeed(60);
    // inizializzazione della porta seriale:
    Serial.begin(9600);
}

void loop() 
{
    // una rotazione in una direzione
    Serial.println("Rotazione oraria");
    mioStepper.step(stepPerRotazione);
    delay(500);

    // una rotazione in una direzione
    Serial.println("Rotazione antioraria");
    mioStepper.step(-stepPerRotazione);
    delay(500);
}

Questo sketch include la libreria Stepper https://www.arduino.cc/en/Reference/Stepper.
La libreria avrà il compito di sequenziare gli impulsi verranno inviati al motore stepper.

// Inclusione della libreria stopper
#include <Stepper.h>

Definizione della variabile stepPerRotazione che stabilisce il numero di passi per un’intera rivoluzione, in questo caso 200 che corrispondono a 1,8 gradi per passo.

// Numero di step (passi) per effettuare una rotazione completa
const int stepPerRotazione = 200;

Creazione di un’istanza della libreria stepper. La creazione dell’istanza prevede l’indicazione del numero di step per rivoluzione e l’indicazione dei 4 pin digitali di Arduino a cui dovranno essere collegati i pin IN1, IN2, IN3, IN4 della scheda L298N.

// Creazione dell’istanza dello Stepper
Stepper mioStepper(stepPerRotazione, 8, 9, 10, 11);

Nel setup:

  • impostiamo la velocità del motore passo-passo invocando la funzione setSpeed()
  • impostiamo la velocità di comunicazione della Serial Monitor
void setup()
{
    // impostazione della rotazione a 60 rpm:
    mioStepper.setSpeed(60);
    // inizializzazione della porta seriale:
    Serial.begin(9600);
}

Nel loop() invochiamo la funzione step() che permette di stabilire il numero di passi, valori negativi consentono di invertire il senso di rotazione del motore.

void loop() 
{
    // una rotazione in una direzione
    Serial.println("Rotazione oraria");
    mioStepper.step(stepPerRotazione);
    delay(500);

    // una rotazione in una direzione
    Serial.println("Rotazione antioraria");
    mioStepper.step(-stepPerRotazione);
    delay(500);
}

Esercizi per i miei studenti

Esercizio 1
Realizzare un sistema che permetta la marcia e l’arresto del motore passo passo mediante l’uso di due pulsanti.

Esercizio 2
Realizzare un sistema che permetta la marci e l’arresto ed il controllo del senso di rotazione del motore. Usare pulsanti per il controllo della marcia e dell’arresto e dell’inversione di marcia.

Esercizio 3
Realizzare un sistema che mediante serial monitor permetta l’impostazione del numero di rotazioni e del senso di rotazione.

Esercizio 4
Realizzare un sistema che mediante tastierino esterno consenta di impostare il numero di rotazioni del sistema e il senso di rotazione del motore.
Utilizzare un display 16×2 I2C da usare per messaggi e allarmi.

Sul display dovrà essere visualizzato:

  • Numero di giri in tempo reale
  • Passi del motore
  • Senso di rotazione

Esercizio 5
Svolgere le stesse funzionalità dell’esercizio 4 ed aggiungere un sensore di temperatura TPM36 che superato un valore limite di temperatura di riscaldamento del motore passo passo attivi una ventola che lo raffreddi riportando la temperatura nel range di sicurezza stabilito, cessato l’allarme la ventola di raffreddamento si deve fermare.