Motori passo-passo, pilotarli con arduino – quinta parte

In questo articolo realizzeremo un listato per pilotare il nostro motore, nel mio caso i due motori, inviando comandi dalla tastiera del pc, il listato originale è quello riportato sul sito arduino, al quale ho applicato alcune modifiche per pilotare 2 motori e non uno solo, come nell’esempio.

Nel prossimo, ed ultimo, articolo di questa serie ti mostrerò un simpatico video in cui due motori compiono in simultanea dei movimenti in base ad una sequenza di comandi inviati dal pc collegato ad arduino.

Passiamo subito all’analisi del codice che ho modificato per pilotare 2 motori:

int motorPinx[] = {8, 9, 10, 11};
int motorPiny[] = {4, 5, 6, 7};
int countX = 0;
int count2X = 0;
int countY = 0;
int count2Y = 0;
int delayTime = 10;
int val = 0;
int lettura = 0;
int letturaX = 0;
int letturaY = 0;
int pLetturaX = 0;
int pLetturaY = 0;

void setup() {
  Serial.begin(9600);
  for (countX=0; countX<4; countX++)
  {
    pinMode(motorPinx[countX], OUTPUT);
  }

  for (countY=0; countY<4; countY++)   {     pinMode(motorPiny[countY], OUTPUT);   }
}

void moveForwardX() {   if ((count2X == 0) || (count2X == 1)) {     count2X = 16;   }   count2X>>=1;
  for (countX = 3; countX >= 0; countX--) {
    digitalWrite(motorPinx[countX], count2X>>countX&0x01);
  }
  delay(delayTime);
}

void moveBackwardX() {
  if ((count2X == 0) || (count2X == 1)) {
    count2X = 16;
  }
  count2X>>=1;
  for (countX = 3; countX >= 0; countX--) {
    digitalWrite(motorPinx[3 - countX], count2X>>countX&0x01);
  }
  delay(delayTime);
}

void stopX() {
  for (countX=0; countX<4; countX++)   {     digitalWrite(motorPinx[countX], LOW);   }
} 

void moveForwardY() {
  if ((count2Y == 0) || (count2Y == 1)) {
      count2Y = 16;
  }
  count2Y>>=1;

  for (countY = 3; countY >= 0; countY--) {
    digitalWrite(motorPiny[countY], count2Y>>countY&0x01);
  }
  delay(delayTime);
}

void moveBackwardY() {
  if ((count2Y == 0) || (count2Y == 1)) {
    count2Y = 16;
  }
  count2Y>>=1;
  for (countY = 3; countY >= 0; countY--) {
    digitalWrite(motorPiny[3 - countY], count2Y>>countY&0x01);
  }
  delay(delayTime);
}

void stopY() {
  for (countY=0; countY<4; countY++)   {     digitalWrite(motorPiny[countY], LOW);   }
}

 void loop() {        lettura = Serial.read();     if ( lettura > 0)
    {
      Serial.print(delayTime);
      Serial.print('X: ', BYTE);
      Serial.print(letturaX, BYTE);
      Serial.print('Y: ', BYTE);
      Serial.print(letturaY, BYTE);
      Serial.print(' ', BYTE);
      Serial.println(lettura, BYTE);

      if ( lettura == 'q' || lettura == 'w' || lettura == 'e' ) { letturaX = lettura; } else { letturaX = pLetturaX; }
      if ( lettura == 'a' || lettura == 's' || lettura == 'd' ) { letturaY = lettura; } else { letturaY = pLetturaY; }
    }

    switch (letturaX) {

        case 'q':
          moveForwardX();
          break;

        case 'w':
          moveBackwardX();
          break;

        case 'e':
          stopX();
          break;
    }

    switch (letturaY) {

        case 'a':
          moveForwardY();
          break;

        case 's':
          moveBackwardY();
          break;

        case 'd':
          stopY();
          break;
    }  

    pLetturaX = letturaX;
    pLetturaY = letturaY;

}

Premetto che la mia idea è di pilotare 2 assi X e Y di una CNC, a tal proposito mi irferirò a ciascun motore con la lettera dell’asse corrispondente.
Le prime righe 1-13 settano le variabili che utilizzeremo per nel resto del codice, in particolare la riga 1 e 2 impostatno i pin che utilizzeremo per pilotare i due motori: 4,5,6 e 7 per l’asse Y e ,9,10 e 11 per l’asse X.
Anche le variabili che seguono sono distinte secondo l’assse di riferimento, fatta eccezione per “delayTime” che definisce la velocità di rotazione i funzione del tempo di attesa tra gli step dei motori, “val” e “lettura” che utilizzerò per memorizzare valori temporanei durante la rotazione.
Le linee 15-27 compongono la funzione di “setup” necessaria ad Arduino a inizializzare le variabili e predisporre, in questo caso, la comunicazione seriale, che utilizzerò per inviare i dati dal pc ad Arduino.

Il codice che segue è composto da funzioni per essere gestito facilmente e per duplicarlo agevolmente per i due assi.
La funzione moveForwardX() ( linee 25-30 ) farà ruotare di un un verso, che per convenzione di trattazione definiremo: avanti, l’albero del nostro motore. Il principio di funzionamento è quello dei numeri binari facendo shiftare ( >> ) il valore del contatore trasferito ai pin di arduino in modo continuo.
Allo stesso modo la funzione moveBackwardX() ( linee 32-41 ) imprimerà all’albero del nostro motore una rotazione nel verso contrario.
La funzione stopX() ( linee 43-45 ) ferma il motore portando a livello logico basso ( LOW ) tutti i pin della scheda Arduino.

Per l’asse Y ho duplicato le funzioni appena descritte cambiando l’array di pin in modo da imprimere comndi all’altro motore.

La funzione loop ( linee 69-126 ), defult Arduino, è eseguita ciclicamente e attende l’invio di una lettera dal pc mediante segnale seriale, le lettere q,w,e inviano comandi all’asse X; le lettere a,s,d inviano comandi all’asse Y.
Le linee 123 e 124 insieme alle righe 79 e 80 si assicurano che a cicli successivi eseguiti dalla funzione loop se non ci sono nuovi comandi restino validi quelli del cisclo precedente, in caso di variazione provvedono a impostarla verso i motori.

Curiosità: per la natura specifica del programma e dei comndi seriali gestiti da Arduino è possibile inviare contemporaneamente ( in un unico invio ) sia comandi all’asse X sia comandi all’asse Y (es.: qa -> rotazione di emtrambi gli assi in avanti, ws -> rotazione di entrambi gli assi indietro, qs -> rotazione X avanti e rotazione Y indietro, ecc… )