Controllo di un motore in corrente continua

Questo progetto è pensato per controllare una successione predeterminata di rotazioni, in avanti e in indietro, per differenti intervallo di tempo di un motore a corrente continua, da utilizzarsi – a titolo di esempio – in un ciclo di lavorazione come una catena di montaggio.

Modificando la prima parte del codice e il programma principale è possibile modificare il ciclo di lavorazione.

Definizione del progetto

Le specifiche del progetto sono:

• avere due tasti: uno di avvio e uno di arresto;
  • nel caso venga premuto il tasto di arresto, il ciclo di lavorazione termina;
  • nel caso venga premuto il tasto di avvio, parte il ciclo di lavorazione.

Il ciclo di lavorazione è così strutturato:

Ciclo di lavorazione

Fase	Descrizione
1	Il motore ruota per $60''$ in avanti
2	Il motore ruota per $40''$ in indietro
3	Il motore ruota per $30''$ in avanti
4	Il motore si arresta

Pertanto, il ciclo di lavorazione ha una durata complessiva di $130''=2'~10''$.

Schema elettrico

Di seguito viene riportato lo schema elettrico. Si noti che il motore $M_{1}$ è alimentato con una tensione di $24~{\text{V}}$, una tensione troppo alta per il circuito di pilotaggio Arduino. Pertanto viene fornita esternamente, tramite relè, alimentati (a loro volta) con una tensione a $12~{\text{V}}$. Questo significa che – non essendoci alcun contatto elettrico tra il circuito di pilotaggio e l'attuatore – questo potrebbe lavorare anche con tensioni molto più elevate. I due diodi di ricircolo servono per proteggere le bobine dei relè durante i fenomeni transitori.

Infine i transistor si rendono necessari per evitare di richiedere all'Arduino un'elevata corrente in uscita.

Schema elettrico controllo motore DC

Schema di montaggio

Schema di controllo motore DC

Codice

Di seguito viene riportato il codice sorgente suddiviso nelle sue componenti principali:

• definizioni di variabili;
• setup;
• loop;

e funzioni definite dall'utente, quali:

• stop;
• forward;
• backwards.

Qui vengono definite, oltre a variabili di appoggio, quali pin vengono utilizzati e per quale scopo, la durata della pausa (funzionale a intercettare il corretto valore della funzione millis) e i tempi di fine dei tre cicli di attività.

/* Variabili globali */
int Start, Stop;
unsigned long time;

/* Definizioni dei pin */
int START = 2;   // Imposta il tasto START
int STOP  = 3;   // Imposta il tasto STOP
int OUT_1 = 4;   // Secondo driver NPN 
int OUT_2 = 5;   // Primo driver NPN 
int PAUSE = 200; // Step di 0.2 sec durante le attivita'

/* Definizioni delle attivita' */
unsigned long TIME_1 =  60000;  // 60 sec avanti
unsigned long TIME_2 = 100000;  // 40 sec indietro
unsigned long TIME_3 = 130000;  // 30 sec avanti

Nel setup, l'unica definizione è relativa all'utilizzo dei pin.

void setup() {
	pinMode(START, INPUT_PULLUP);  // Tasto Start
	pinMode(STOP,  INPUT_PULLUP);  // Tasto Stop
	pinMode(OUT_1, OUTPUT);        // Secondo driver NPN
	pinMode(OUT_2, OUTPUT);        // Primo driver NPN
}

Il programma attende una pressione dei pulsanti START o STOP.

Se viene premuto STOP, il ciclo si arresta: è la tipica funzione di un pulsante di arresto in caso di anomalie o eventi imprevisti.

Se viene premuto START, la variabile time viene inizializzata e il ciclo ha inizio. Come descritto nei commenti time > 0 determina la possibilità per il motore di muoversi. Il suo appartenere a una determinata fascia temporale il tipo di movimento da compiere (in avanti, in indietro o arrestarsi).

void loop() {
  // Legge lo stato dei due tasti
  Start = digitalRead(START);
  Stop  = digitalRead(STOP);

  if(Stop == LOW)
    stop();

  // Quando time > 0 il motore puo' muoversi
  if(Start == LOW)
    time = millis();

  // Primo step (fino a 60 secondi)
  if(time > 0 && (millis() - time) < TIME_1) 
    forward();

  // Secondo step (da 60 secondi fino a 100 secondi)
  if(time > 0 && (millis() - time) >= TIME_1 && (millis() - time) < TIME_2)  
    backwards() ;

  // Terzo step (da 100 secondi fino a 130 secondi)
  if(time > 0 && (millis() - time) >= TIME_2 && (millis() - time) < TIME_3) 
    forward();

  // A 130 secondi, il ciclo termina
  if(time > 0 && (millis() - time) >= TIME_3)
    stop();
}

Per arrestare il motore entrambi i relè vengono portati a $0~{\text{V}}$, inoltre la variabile time viene portata a 0: in questo modo il motore non potrà muoversi, anche se non ha terminato il suo ciclo di lavoro.

// Procedura di arresto del motore
void stop() {
  digitalWrite(OUT_1, LOW);
  delay(PAUSE);
  digitalWrite(OUT_2, LOW);
  // time = 0 -> Il motore non puo' muoversi
  time = 0;
}

Per il movimento in avanti, l'uscita del relè $K_{1}$ sarà pari a $24~{\text{V}}$, mentre l'uscita del relè $K_{2}$ sarà pari a $0~{\text{V}}$.

// Movimento in avanti
void forward() {
  digitalWrite(OUT_1, HIGH);
  delay(PAUSE);
  digitalWrite(OUT_2, LOW);
}

Viceversa, per il movimento in indietro, l'uscita del relè $K_{1}$ sarà pari a $0~{\text{V}}$, mentre l'uscita del relè $K_{2}$ sarà pari a $24~{\text{V}}$.

// Movimento in indietro
void backwards() {
  digitalWrite(OUT_1, LOW);
  delay(PAUSE);
  digitalWrite(OUT_2, HIGH);
}

Espansioni suggerite

Modificando il codice è possibile modificare il tipo di lavorazione. Importante: non è possibile regolare la velocità del motore direttamente, poiché non è stato utilizzato un circuito di potenza a commutazione elettronica (un relè non può commutare ogni centesimo di secondo, si romperebbe).

Tuttavia è possibile ottenere cicli differenti e, con un software più elaborato, un tasto che consenta la ripartenza da dove il ciclo era stato arrestato (come accade quando una fotocellula intercetta un ostacolo mentre una saracinesca è in movimento).