Arduino N° 60 - Stepper Position

< Arduino N°  59

Achille De Santis

> Arduino N°  61

Questo programma di esempio ci permette di familiarizzarci  con l'uso di un motore stepper.
I motori stepper si possono recuperare agevolmente da una stampante fuori uso.



/*
 Stepper Motor Control -
 This program drives a unipolar or bipolar stepper motor.
 The motor is attached to digital pins 8,9,10,11 of the Arduino.
 The motor should revolve in one direction, then in the other direction.
 Modified 24-06-2020 by Achille De Santis
*/

#include <Stepper.h>

const int stepsPerRevolution = 200;      // number of steps per revolution for your motor

#define P1 8
#define P2 9
#define P3 10
#define P4 11

Stepper myStepper(stepsPerRevolution, P1, P2, P3, P4);    // initialize the stepper library on pins 8 through 11:

void avanti(int p) { myStepper.step(p); }       // step in one direction:
void indietro(int p) { myStepper.step(-p); }   // step in the other direction:

void setup()
  { 
    myStepper.setSpeed(60);    // set the speed at 60 rpm 
    Serial.begin(9600);             // initialize the serial port
  }

void loop()
  {
    Serial.println("clockwise");
    avanti(1);                           //  one step in one direction
    delay(500);

    Serial.println("counterclockwise");
    indietro(1);                       //  one step in the other direction
    delay(500);
  }



Simulazione: 


Argomenti correlati:  Arduino N° 59 - Pilotaggio Stepper Motor

> Arduino N°  61

Arduino N° 59 - Pilotaggio Stepper Motor

< Arduino N° 58

Achille De Santis

> Arduino N°  60

Pilotaggio di un motore "a passo" (detto anche "passo-passo" o "stepper motor") attraverso un sensore di posizione.

Un potenziometro, comandato esternamente, segnala la posizione del cursore ad un ingresso analogico. La scheda Arduino, comandata da questo sketch, fa tutto il resto.

Lo spostamento angolare del motore è relativo a quello operato sulla manopola del potenziometro.

Importante è la determinazione del valore iniziale di posizione del motore.

Per il pilotaggio del motore a passo occorre una interfaccia che nel nostro caso può essere rappresentata dal modulo di pilotaggio motori con L298. Il modulo in questione è in grado di pilotare due motori in continua o un motore passo-passo.   

Nel caso di alimentazione "esterna" del modulo L298 è necessario predisporre il relativo ponticello (jumper) in modo opportuno.

/* ------------------------------ Inizio programma ---------------------------------------------------
 * Stepper Motor Knob
 * A stepper motor follows the turns of a potentiometer
 * (or other sensor) on analog input 0.
 *
 * http://www.arduino.cc/en/Reference/Stepper 
 * This example code is in the public domain.
 * Modified by Achille De Santis - 13-06-2020
 */

#include <Stepper.h>
#define STEPS 200         // dai "dati di targa" del motore; in questo caso: 1.8 DEG/step.
// questo parametro determina la "precisione" della movimentazione, cioè l'angolo di un passo.
                          
// ---------- I/O ---------------------------------
#define P1    7     // abilitazione alla partenza
#define POT   0     // A0  ingresso analogico, collegato al potenziometro di posizione
#define A     8
#define B     9
#define C     10
#define D     11
// ------------------------------------------------

Stepper stepper(STEPS,A,B,C,D); // presenta una istanza della classe stepper, specificando  
                                // il numero di passi del motore ed i piedini ad esso collegati.

bool m;                 // variabile di stato, consenso alla partenza del motore (0)
const int vel=30;       // predispone la velocità del motore a 30 giri/min

int previous;           // valore precedente di lettura dall'ingresso analogico.
int val;                // valore analogico

void intestazione()
{ Serial.println(" ---------------------------------------------- ");
  Serial.println(" - Tecnatron - ing. Achille De Santis         - ");
  Serial.println(" - Stepper MotorKnob                          - "); 
  Serial.println(" -     V. 3.1 del 25-06-2020                  - "); 
  Serial.println(" ---------------------------------------------- ");
}


void setup() 
  {
    Serial.begin(9600);         // setto la velocità di comunicazione
    intestazione();             // intestazione, inviata alla seriale
    
    pinMode(P1, INPUT_PULLUP);
    stepper.setSpeed(vel);     // stabilisce la velocità del motore
    val = analogRead(POT);     // legge inizialmente il sensore
    previous = val;            // e stabilisce la posizione iniziale.
  }

void loop() 
  {
    val = analogRead(POT);          // legge il sensore 
    m = digitalRead(P1);            // legge il valore di abilitazione
    if (m==0)
    { 
      stepper.step(val - previous); // esegue i passi da fare, positivi o negativi. 
      previous = val;               // aggiorna il valore alla posizione attuale.
      Serial.print("valore attuale: ");   Serial.println(val); // stampa la posizione attuale
    }
  }
    // -------------------- Fine programma --------------------------------------------------------



Simulazione: 

Argomenti correlati:  Arduino N° 57 - Controllo Motore passo-passo - esempio

> Arduino N°  60

Arduino N° 58 - Pilotaggio intermittente di una uscita digitale

      

< Arduino N°  57

Achille De Santis

> Arduino N°  59

Fig. 1: Modulo di prova;

Pilotaggio intermittente di una uscita digitale, con segnalazione della commutazione attraverso un breve impulso che pilota un cicalino (buzzer).

Il ciclo di commutazione viene abilitato portando a massa il piedino S (switch).

Non occorre resistenza di pull-up, già prevista internamente. 

Il dispositivo non rappresenta nulla di nuovo ma è un esempio di come si possano elaborare nuove applicazioni da cose già note: l'intermittente (o lampeggiatore) , il "buzzer" attivo (o "cicalino"), il circuito universale di prova, il relay.

/* ----------------- Inizio Programma -------------------------------------------
 * Pilotaggio intermittente di un Relay con Arduino
 * Segnalazione tramite Buzzer
 * Uso delle routines per le operazioni elementari ripetitive.
 * Aggiungere il piedino di attivazione del comando!!!!!!!!
 * Se non è necessario il relay, come separatore galvanico, 
 * si può sostituire con un transistore di adeguata potenza.  
 * Achille De Santis - V5.0 del 09-06-2020
 * 
 */
// --------------- I/O -------------------------------
 #define S    6      // ingresso switch
 #define R    13     // Uscita comando relay
 #define B    12     // Uscita comando buzzer
// ---------------------------------------------------

 const int  T1=200, T2=1000;

void intestazione()
{ Serial.println("\n ------------------------------------------------- ");
  Serial.println(" - Tecnatron - ing. Achille De Santis        - ");
  Serial.println(" - Comando uscita intermittente     V. 1.0 - "); 
  Serial.println(" - Segnalazione con buzzer                       -"); 
  Serial.println(" --------------------------------------------------\n");
}

void buzz()
{
  digitalWrite(B,HIGH);     // comanda B alto 
  delay(T1);                // attende T1 millisecondi
  digitalWrite(B, LOW);     // comanda B basso 
}

void setup()
{
  pinMode (R,OUTPUT);          // Relay: viene settato il pin R come uscita
  pinMode (B,OUTPUT);          // Buzzer: viene settato il pin B come uscita
  pinMode (S,INPUT_PULLUP);    // Switch: ingresso
  Serial.begin(9600);         // predispongo la velocità di comunicazione
  intestazione();             // intestazione, inviata alla seriale
}

void loop()
{ 
  while (digitalRead(S)==0)
  { 
    digitalWrite(R,1);  buzz(); 
    delay(T2);
    digitalWrite(R,0);
    delay(T2);                  // ritardo, poi il ciclo si ripete
  }
}
// ---------------------- Fine Programma ----------------------------------------

Simulazione: 

Comando relay con buzzer

Argomenti correlati:

Lampeggiatore, 
Intermittente, 
Lampeggiatore modulato

Arduino N° 30 - Lampeggiatore per indicatori di direzione
Arduino N° 50 - Modulo di prova per 6 uscite digitali



> Arduino N° 59

Arduino N° 57 - Controllo Motore passo-passo - esempio

< Arduino N° 56

Achille De Santis

> Arduino N° 58

Esempio di pilotaggio di un motore a passo.
Il motore effettua una rotazione completa avanti/indietro.
Nell'esempio viene ipotizzato un motore con 200 passi/giro.


// ----------------------- Inizio programma -----------------------------------------------------
/* Stepper Motor Control - one revolution
 * This program drives a unipolar or bipolar stepper motor. 
 * The motor is attached to digital pins 8,9,10,11 of the Arduino. 
 * The motor should revolve one revolution in one direction, 
 * then one revolution in the other  direction. 
 * Created 11 Mar. 2007 
 * Modified 30 Nov. 2009 by Tom Igoe 
 * Modified 1 june 2020 by Achille De Santis
*/

#include <Stepper.h>

const int stepsPerRevolution = 200;   // change this to fit the number of steps per revolution
                                      // for your motor
// -------- I/O ----------------------------------------
#define P1 8
#define P2 9
#define P3 10
#define P4 11
// ------------------------------------------------------
Stepper myStepper(stepsPerRevolution, P1, P2, P3, P4);  // initialize the stepper library on pins 8 through 11:

void avanti()    {  myStepper.step(stepsPerRevolution);  }  // step one revolution in one direction
void indietro()  {  myStepper.step(-stepsPerRevolution); }  // step one revolution in the other direction

void setup() 
  {    
    myStepper.setSpeed(60);   // set the speed at 60 rpm    
    Serial.begin(9600);       // initialize the serial port
  }

void loop() 
  {
    // step one revolution  in one direction:
    Serial.println("clockwise");
    avanti();
    delay(500);

    // step one revolution in the other direction:
    Serial.println("counterclockwise");
    indietro();
    delay(500);
  }
// --------------------- Fine programma ----------------------------------------------  


Simulazione: 

Argomenti correlati:

> Arduino N° 58

Arduino N° 56 - Comando relay con buzzer avvisatore

< Arduino N°  55

Achille De Santis

> Arduino N°  57

Questo semplice programma è utile ai neofiti per familiarizzarsi con l'uso dei comandi digitali e con le temporizzazioni.

Il riscontro visivo è di immediata comprensione per chi comincia a destreggiarsi con Arduino o con i controllori programmabili, in generale.
Il relay viene comandato in modalità "monostabile", con la temporizzazione impostata nel FW. In pratica, il comando impulsivo sul pulsante determina l'eccitazione del relay per il tempo impostato, indipendente dal comando.
Il buzzer avverte acusticamente che il comando è stato eseguito.

   

Sul piedino D12 di uscita va collegato un "buzzer" cioè un "ronzatore" attivo, NON un altoparlante che manderebbe in corto l'uscita stessa, con conseguenze dannose sia per l'uscita che per l'altoparlante.

Volendo, invece, collegare un altoparlante dovrete operare alcune modifiche, HW e SW:

1. modificare il SW ed inserire un generatore di tono di B.F;
2. modificare l'HW inserendo una capacità di accoppiamento sull'uscita D12, in serie ad opportuna resistenza. 

/* ------------------------ Inizio programma ---------------------------
 * Pilotaggio intermittente di un Relay con Arduino
 * Segnalazione tramite Buzzer
 * Uso delle routines per le operazioni elementari ripetitive.
 * Aggiungere il piedino di attivazione del comando!!!!!!!!
 * Se non è necessario il relay, come separatore galvanico, 
 * si può sostituire con un transistore di adeguata potenza.  
 * Achille De Santis - V5.0 del 09-06-2020
 * 
 */

// --------------- I/O ------------------------------
 #define R    13     // Uscita comando relay
 #define B    12     // Uscita comando buzzer
 #define S    6      // ingresso switch
// --------------------------------------------------

 const int  T1=200, T2=1000;

void buzz()
{
  digitalWrite(B,HIGH);     // comanda B alto 
  delay(T1);                // attende T1 millisecondi
  digitalWrite(B, LOW);     // comanda B basso 
}

void setup()
{
  pinMode (R,OUTPUT);          // Relay: viene settato il pin R come uscita
  pinMode (B,OUTPUT);          // Buzzer: viene settato il pin B come uscita
  pinMode (S,INPUT_PULLUP);    // Switch: ingresso
}

void loop()
{ 
  while (digitalRead(S)==0)
  { 
    digitalWrite(R, 1); buzz();
    delay(T2);
    digitalWrite(R,0);
    delay(T2);                  // ritardo, poi il ciclo si ripete
  }
}

// ---------------------------- Fine programma -------------------------------------

Simulazione: 

Comando relay con buzzer avvisatore

Argomenti correlati:

Arduino N° 50 - Modulo di prova per 6 uscite digitali

Arduino N° 99 - Uso del BUZZER attivo e passivo

> Arduino N°  57