Visualizzazione post con etichetta Motori. Mostra tutti i post
Visualizzazione post con etichetta Motori. Mostra tutti i post

mercoledì 2 giugno 2021

Arduino N° 97 - Accelerazione motore in DC_V3

< Arduino N° 96

 Achille De Santis

> Arduino N°  98




In questo post propongo un dispositivo per il comando progressivo di un .motore in corrente continua, che ne determina l'accelerazione/decelerazione.


Aprendo il monitor seriale è possibile controllare il valore PWM impostato, di volta in volta; L'aggiornamento del valore, da zero a 255, viene effettuato soltanto quando c'è un comando di variazione di velocità, altrimenti resta memorizzato il valore precedente. In questo modo, si aumenta la leggibilità a monitor e si evita lo scorrimento continuo dei valori.



I due condensatori posti sulla linea di alimentazione servono a filtrare l'alimentazione ed a prevenire fenomeni di interferenza. Il diodo di "libera circolazione protegge il transistore da sovratensioni."


Il motore è predisposto per ruotare in un solo verso.
Se è necessario, si può cambiare il verso di rotazione invertendo la polarità sul motore agendo sui morsetti.

Attenzione al verso del diodo di libera circolazione!

Nel caso fosse necessario un doppio verso di rotazione il circuito andrebbe modificato con l'uso di un driver L293 o L298 o, in alternativa, facendo uso di un relay 2vie/2posizioni configurato come invertitore di polarità. 

Nota:

Il circuito è SOLO dimostrativo. L'uscita va ASSOLUTAMENTE collegata ad una sorgente di alimentazione separata. La figura la riporta collegata alla alimentazione di Arduino a puro titolo di esempio.


Simulazione: 

Accelerazione motore in DC_V3


Argomenti correlati: 



mercoledì 14 aprile 2021

Arduino N° 90 - Elettrovalvola bistabile (con comando impulsivo)

< Arduino N° 89

 Achille De Santis

> Arduino N°  91


    Una elettrovalvola del tipo bistabile può essere comandata con due impulsi: l'impulso positivo "apre", l'impulso negativo "chiude".  Per il comando basta quindi formare un impulso di pochi millisecondi prevedendone l'inversione di polarità. Il dispositivo si può convenientemente realizzare con una configurazione sia a semi-ponte che a ponte. Volendo utilizzare un controllore per la logica di comando può essere conveniente optare per la seconda soluzione che prevede l'uso di Arduino e di un modulo  "ponte ad H" per il circuito di potenza. Partendo dal principio di funzionamento del ponte ad "H" usato per la movimentazione di motori in continua, ho implementato questo sketch per il pilotaggio dell'elettrovalvola (EV).

Dal punto di vista esterno, i comandi si riducono a due pulsanti per l'apertura e chiusura dell'EV.

Si potrebbe anche modificare il firmware prevedendo un funzionamento di tipo "Toggle": il primo impulso APRE, il secondo CHIUDE; lascio al lettore l'onere e l'onore della modifica.


Tra i parametri che è possibile cambiare c'è la durata dell'impulso, ora  impostata su un valore di 500 mSec solo per comodità di simulazione. Potete cambiarla in 50 mSec, sufficienti, nella maggior parte dei casi, per la giusta commutazione. 


Dal momento che il programma è sufficientemente strutturato, è possibile modificarlo facilmente per aggiungere un'altra EV sull'uscita rimasta libera.

Basta aggiungere altri pulsanti per impartire dall'esterno i comandi e modificare quanto basta le istruzioni per la manovra.

Il circuito integrato utilizzato è l'L293D, per ridurre lo spazio occupato. Nel caso fosse necessario, è possibile ed opportuno utilizzare il modulo premontato con L298N, che ha due canali e sopporta circa 2 A di corrente di uscita.


La simulazione del dispositivo è disponibile per l'analisi e il download

    Premendo i pulsanti APRE/CHIUDE si fornisce il comando al dispositivo. L'attuazione viene segnalata dallo stato dei LED in uscita. 

    Come si vede, ogni uscita è un segnale impulsivo monostabile. La "tenuta" viene effettuata dall'attuatore, che mantiene il suo stato anche in mancanza di alimentazione.



Nota:

Il circuito è SOLO dimostrativo. L'uscita va ASSOLUTAMENTE collegata ad una sorgente di alimentazione separata. La figura la riporta collegata alla alimentazione di Arduino a puro titolo di esempio.


Simulazione: 

Elettrovalvola bistabile

 

Argomenti correlati: 

Pilotaggio di motori in CC


Buon lavoro a tutti!


> Arduino n° 91

mercoledì 29 luglio 2020

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


mercoledì 22 luglio 2020

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

mercoledì 8 luglio 2020

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

mercoledì 20 maggio 2020

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

< Segue da Arduino N°  49 

prof. Achille De Santis

> Arduino N°  51




Fig. 1: il modulo, assemblato su  protoboard.












Questo modulo universale di prova vi permetterà di simulare e controllare rapidamente sei uscite digitali (da D8 a D13), senza dover ogni volta predisporvi dei LED.

L'assorbimento dei LED è di circa 7,4 mA l'uno, ampiamente al di sotto della corrente massima sia della singola uscita che della corrente totale.

Il collegamento a pettine consente una rapida inserzione sul connettore di Arduino relativo alle uscite D8-D13, massa compresa; sono previsti 8 contatti, per comodità di inserzione, ma ne vengono utilizzati soltanto sette; il primo contatto a destra (Vref) è, comunque, predisposto.

Come in figura 1, la piccola breadboard resta libera per gestire le altre parti circuitali.

L'assemblaggio dei componenti è stato eseguito sul lato rame, per un facile inserimento della striscia di contatti e una agevole visualizzazione dei LED.

Volendo, è anche possibile eseguire il lavoro per un montaggio in verticale, con un connettore a pettine, a 90°; in questo caso il montaggio dei componenti si eseguirà sulla faccia isolante.
 
Componenti:

6 x resistori 470 Ohm;
6 x diodi LED rosso, micro
basetta protoboard passo 2.54 mm
connettore a pettine, maschio, 8 contatti passo 2.54 mm.
Conservate i reofori: vi fanno comodo per creare le poche piste necessarie! 


Buon lavoro a tutti!


Argomenti correlati:



> Arduino N°  51

mercoledì 18 dicembre 2019

Arduino N° 28 - Azionamento relay per motoriduttori avanti / indietro

< Arduino N° 27

 Achille De Santis

> Arduino N° 29





Routine da utilizzare nel corpo del programma.
Nel programma vanno definiti i parametri di ingresso alla routine:   R1, L1, R2,
Rele1  è il comando per il primo relé;
Rele2  è il comando per il secondo relé;
LED1  è una 'spia di equilibrio'.


 /* -------------- Inizio Programma -----------------------------------------------------------------
 *  Azionamento relay per motoriduttori avanti / indietro
 *  Un potenziometro stabilisce la posizione angolare del motoriduttore;
 *  un sensore di posizione (a  potenziometro),  collegato "a ponte" con il primo, rivela il
 *  raggiunto equilibrio.
 */
// ------- I/O ---------------------------------------
#define rele1       11
#define rele2       12
#define Ledpin3  13
// ---------------------------------------------------

void titolo()
{
  Serial.println(" -          Tecnatron Creation                    - ");
  Serial.println(" -          tecnatron@gmail.com               - ");
  Serial.println(" - Azionamento relay per motoriduttori   ");
  Serial.println(" -  Avanti / Indietro                                 - ");
  Serial.println(" ----------------------------------------------- ");
}

void azionamento(bool R1, bool L1, bool R2) // routine ausiliaria non richiamata direttamente.
     {
       digitalWrite(rele1, R1);
       digitalWrite(Ledpin3, L1);         // Led equilibrio
       digitalWrite(rele2, R2);
     }     
 void fermo()       { azionamento (HIGH, HIGH, HIGH); }
 void sinistra()    { azionamento (HIGH, LOW, LOW);   }
 void destra()      { azionamento (LOW, LOW, HIGH);   }

void setup()
{
  Serial.begin(9600);             // velocità di comunicazione
  titolo();
  pinMode (rele1, OUTPUT);
  pinMode (rele2, OUTPUT);
  pinMode (Ledpin3, OUTPUT);
}

void loop()
{
               // inserire qui il programma
}

// ------------------ Fine Programma --------------------------------------------


Nota:
Se non volete caricare troppo l'uscita di Arduino o del microcontrollore potete inserire uno stadio buffer a BJT sul piedino di uscita del canale di comando.



Simulazione: 

mercoledì 11 dicembre 2019

Arduino N° 27 - Pilotaggio di 2 motori con ponte ad H

< Arduino N° 26

 Achille De Santis

> Arduino N° 28




Utili sottoprogrammi per la gestione ed il controllo di motori in continua da utilizzare per la movimentazione  di robot, veicoli ecc...


/* ---------------------------- Inizio Programma -----------------------------
 *  Achille De Santis
 * Pilotaggio di 2 motori con ponte H
 * V5 del 09-07-2019
 * In questo modo è facile pilotare anche tre o più motori.
 * Base di lavoro per la gestione di ROBOT, veicoli telecomandati ed altro.
*/

// ---------- pin dell'asse X dei motori --------------
#define MOTOR_XA      13  // motore polo XA
#define MOTOR_XB      12  // motore polo XB
// ---------- pin dell'asse Y dei motori --------------
#define MOTOR_YA      11  // motore polo YA
#define MOTOR_YB      10  // motore polo YB
// --------------------------------------------------------

void motore(int MA,bool A, int MB, bool B)       // motore generico
{
  digitalWrite(MA, A);  // motore, pin A
  digitalWrite(MB, B);  // motore, pin B
}

// --------------------------------------------------------------------------
void avantiSX()   {motore(MOTOR_XA, 1, MOTOR_XB, 0);}
void avantiDX()   {motore(MOTOR_YA, 1, MOTOR_YB, 0);}
void avanti()     {avantiSX(); avantiDX();}
// --------------------------------------------------------------------------
void indietroSX() {motore(MOTOR_XA, 0, MOTOR_XB, 1);}
void indietroDX() {motore(MOTOR_YA, 0, MOTOR_YB, 1);}
void indietro()   {indietroSX(); indietroDX();}
// --------------------------------------------------------------------------
void fermoSX()    {motore(MOTOR_XA,0,MOTOR_XB,0); }
void fermoDX()    {motore(MOTOR_YA,0,MOTOR_YB,0); }
void fermo()      {fermoSX(); fermoDX();  }
// -----------------------------------------------------------------------------
void DXavanti() { fermoDX(); avantiSX(); delay(300); avanti(); }
void SXavanti() { fermoSX(); avantiDX(); delay(300); avanti();  }
// -----------------------------------------------------------------------------
void DXindietro() { fermo(); indietroSX(); delay(300); fermo(); }
void SXindietro() { fermo(); indietroDX(); delay(300); fermo(); }
// ----------------------------------------------------------------------------- 

void setup()
{
  pinMode (MOTOR_XA, OUTPUT);
  pinMode (MOTOR_XB, OUTPUT);
  pinMode (MOTOR_YA, OUTPUT);
  pinMode (MOTOR_YB, OUTPUT);
}

void loop()
{
    // inserire qui il programma
}

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


mercoledì 4 dicembre 2019

Arduino N° 26 - Tachimetro ad infrarosso

< Arduino N°  25

 Achille De Santis

> Arduino N° 27




Tachimetro ad infrarosso, per misure di velocità angolare.

/* ---------------- Inizo Programma --------------------
 * Tachimetro
 * Modificato da Achille De Santis
 * V4 del 08-07-2019
 */
// ------------ I/O --------------------------------------
#define I    A0
#define U   13
// -------------------------------------------------------

int sensorvalue;               // variabile di ingresso
bool state1 = HIGH;
bool state2;
float rps;                        // velocità in giri/secondo
float rpm;                      // velocità in giri/minuto
long prevMillis = 0;
long interval = 200;
long currentTime;
long prevTime = 1;
long diffTime;
const int sensorthreshold = 30;   // indica la soglia "buio/luce" e "luce/buio"; provato; si può cambiare // in relazione alla distanza fisica dei led.
// per vedere quale valore sia adatto, prova il valore di "sensorvalue"
// come stampato da "serial monitor"

unsigned long currentMillis;

void test()                          //only for testing to determine the sensorthreshold value
                 {     delay(500);   Serial.println(sensorvalue);    }

void setup()
{
  Serial.begin(9600);
  pinMode(U, OUTPUT);      // assign pin "U" led as indicator because we cannot see the IR light
}

void loop()
{
  sensorvalue = analogRead(I);            // read from pin "I" (A0)
  if(sensorvalue < sensorthreshold)
    state1 = HIGH;
   else
    state1 = LOW;
   digitalWrite(U, state1);             // as iR light is invisible for us, the led on pin 13
                                                     // indicate the state of the circuit.
   if(state2!=state1)
   {                             // rileva quando lo stato cambia, "buio/luce" o
                                  // "luce/buio", ricorda che la luce IR è NON visibile all'occhio umano.
     if (state2>state1)
     {
       currentTime = micros();                      // Get the arduino time in microseconds
       diffTime = currentTime - prevTime;  // calculate the time diff from the last meet-up
       rps = 1000000/diffTime;                    // calculate how many rev per second, good to know
       rpm = 60000000/diffTime;                // calculate how many rev per minute
       currentMillis=millis();   
                                         // print to serial at every interval - defined at the variables declaration
       if(currentMillis-prevMillis>interval)
        {                              // see if now already an interval long
          prevMillis = currentMillis;     
          Serial.print(rps); Serial.print(" rps  "); Serial.print(rpm); Serial.println(" rpm");
        }     
       prevTime = currentTime;
     }
     state2 = state1;
   }
   // test();                        //prova per determinare il valore di soglia
}
// --------------------- Fine programma -----------------------------------------



Argomenti correlati:

> Arduino N° 27

mercoledì 23 ottobre 2019

Arduino N° 20 - Controllo motore CC con PWM

< Arduino N° 19

 Achille De Santis

> Arduino N° 21




Controllo di velocità per motori in Corrente Continua attraverso comando PWM.
Due pulsanti UP/DOWN permettono di regolare la velocità in modo "proporzionale" con una "gradinata" di 256 valori diversi.
Uno stadio driver a transistore BJT accoppia/separa lo stadio finale attuatore.
Dimensionando opportunamente lo stadio è anche possibile alimentare un motore  a tensioni nominali diverse (es. 12 V o 24 volt).


/* ------------------------------Inizio Programma -------------------------------------
 *  26/5/2015
 *  PWM per comando dei motori in CC (controllo UP/DOWN)
 *  L'uscita va disaccoppiata con uno stadio driver.
 *  Modificato da Achille De Santis il 07-07-2019
 *
*/

// -------------------------- I/O .------------------------
#define UP           2     
#define DOWN    3   
#define USCITA  9           // Uscita PWM
// --------------------------------------------------------

bool S1;                         // variabili booleane interne
bool S2;
const int PAUSA=10;   // Costante pausa. Serve a dare comandi progressivi non troppo veloci.
int pwm;                       // variabile di uscita

void setup()
{
  // Impostazione di pull-up interna ad Arduino
  pinMode(UP, INPUT_PULLUP);            // il pulsante va collegato verso massa
  pinMode(DOWN, INPUT_PULLUP);    // il pulsante va collegato verso massa
  pinMode(USCITA, OUTPUT);               // uscita per comando motore
  pwm = 0;
}

void loop()
{
  S1=digitalRead(UP);
  S2=digitalRead(DOWN);

  if(S1=LOW && pwm<255) pwm++;
    else if(S2=LOW && pwm>0) pwm--;
  analogWrite(USCITA, pwm);
  delay(PAUSA);
}

 // ------------------------------ Fine Programma -------------------------------------



mercoledì 16 ottobre 2019

Arduino N° 19 - Prova di 2 motori in DC usando un Ponte H

< Arduino N° 18

 Achille De Santis

> Arduino N° 20





Prova di due motori in DC, o di due motoriduttori, per controllare la giusta funzione dei comandi.

Si tratta, qui, di piccoli motori a magneti permanenti.

Per motori ad eccitazione indipendente il programma va adeguatamente adattato.
E' possibile cambiare i piedini di uscita per i motori, per adattarli a quelli disponibili ed al dispositivo utilizzato.


/* -----------------------------Inizio programma --------------------------------------------
 * Controllo di 2 motori in DC usando un Ponte H a due canali con L298N
 * Autore: Achille De Santis
*/

// --------------------------- I/O ---------------------------------------------------------------
//Definizione piedini Arduino collegati all'entrata del Ponte H
// ---------------- M1 --------
#define IN1 4
#define IN2 5
// ---------------- M2 -------
#define IN3 6
#define IN4 7
// ----------------------------------------------------------------------------------------------

  const int T1= 2000;   // tempo di ON
  const int T2= 500;    // tempo di OFF

void setup()
  {                           //Definisce i piedini di uscita
    pinMode(IN1, OUTPUT);
    pinMode(IN2, OUTPUT);
    pinMode(IN3, OUTPUT);
    pinMode(IN4, OUTPUT);
  }

void MOTORE(int A, boolean a, int B, boolean b) // azionamento motore generico
  {    digitalWrite(A, a);       digitalWrite(B, b);  }

void AVANTI (int A, int B)     {  MOTORE(A, HIGH, B, LOW);  }    // azionamento motore avanti
void DIETRO (int A, int B)    {  AVANTI(B, A);  }                            // azionamento motore indietro
void FERMO(int A, int B)      {  MOTORE(A, LOW, B, LOW);    }   // arresto motore generico

void loop()
  {
    AVANTI(IN1, IN2); delay(T1);    // Ruota Motore A in senso orario
    FERMO(IN1, IN2);  delay(T2);   // Ferma motore A 
    AVANTI(IN3, IN4); delay(T1);    // Ruota Motore B in senso orario
    FERMO(IN3, IN4);  delay(T2);   // Ferma motore B
    DIETRO(IN1, IN2); delay(T1);   // Ruota Motore A in senso anti-orario
    FERMO(IN1, IN2);  delay(T2);   // Ferma motore A
    DIETRO(IN3, IN4); delay(T1);   // Ruota Motore B in senso anti-orario
    FERMO(IN3, IN4);  delay(T2);   // Ferma motore B
  }
// ------------------------------ Fine programma -----------------------------------------------------



Riferimenti: Pilotaggio di motoriduttore in DC

Argomenti correlati: 

Arduino - Modulo driver motori con ponte ad “H”


mercoledì 9 ottobre 2019

Arduino N° 18 - Pilotaggio motore in DC

< Arduino N° 17

 Achille De Santis

> Arduino N° 19

 


Il  pilotaggio di motori in corrente continua è una delle applicazioni usate nell'IoT per la movimentazione di oggetti, robot ed altro.
Naturalmente, per effettuare in modo conveniente e con tecnica "generale" il pilotaggio dei motori in DC occorre predisporre un "Ponte ad H". Il ponte ad H è chiamato così per la sua tipica configurazione, a forma di H, dove il carico occupa una diagonale. Con opportuni comandi si può inviare al carico una tensione positiva o negativa.

Come al solito, il programma è "strutturato" e presenta delle routine che, svolgendo le operazioni ripetitive, semplificano l'implementazione di tutti i comandi.

Lascio all'utente l'onere e l'onore di prevedere un comando con funzione di ARRESTO MOTORE.
Prima di invertire il senso di marcia è sempre consigliabile passare per il comando di arresto!

Nota importante: questo programma NON è adatto per i motori che hanno una eccitazione indipendente ma, nel caso. si potrebbe adattare facilmente.


/* -------------------- Inizio Programma --------------------------
    Pilotaggio motore in DC con ponte H
    Achille De Santis - V3 del 27-06-2019
    Subroutine per motore avanti/indietro.
  */
// ------------------------- I/O ----------------------------------------
  #define switchPin    2    // comando verso di rotazione
  #define motor1Pin   3    // H-bridge morsetto 1 (pin 2, 1A)
  #define motor2Pin   4    // H-bridge morsetto 2 (pin 7, 2A)
  #define enablePin    9    // H-bridge enable pin
  #define ledPin        13   // LED
  //----------------------------------------------------------------------

  void blink(int whatPin, int howManyTimes, int milliSecs)         //    blinks an LED
  {
    int i=0;
    for (i=0; i<howManyTimes; i++)
    {
      digitalWrite(whatPin, HIGH); delay(milliSecs/2);
      digitalWrite(whatPin, LOW);  delay(milliSecs/2);
    }
  }

 void motore(boolean M1, boolean M2)                              // comanda il motore
   {
     digitalWrite(motor1Pin, M1);   // predispone il morsetto 1 del ponte H
     digitalWrite(motor2Pin, M2);   // predispone il morsetto 2 del ponte H
   }

  void avanti()   {  motore(0,1); }   // fa girare il motore in avanti
  void indietro() {  motore(1,0); }  // fa girare il motore all'indietro

  void setup()
  {
    pinMode(switchPin, INPUT);     // predispone switch come input, gli altri pin in uso come output.
    pinMode(motor1Pin, OUTPUT);
    pinMode(motor2Pin, OUTPUT);
    pinMode(enablePin, OUTPUT);
    pinMode(ledPin, OUTPUT);
 
    digitalWrite(enablePin, HIGH);  // inizializza enablePin alto, abilita ponte H:

    // lampeggia LED 3 volte. Questo succede una sola volta.
    // Se vedi lampeggiare il LED 3 volte, il modulo si è resettato,
    // probabilmente perché il motore ha causato un brown-out o un cortocircuito.

    blink(ledPin, 3, 100);
  }
       
  void loop()
  {
    boolean x = digitalRead(switchPin); 
    switch (x)                         
    {
      case 1: avanti();   break;       //  se lo switch è "alto" il motore girerà in una direzione,
      case 0: indietro(); break;      // se lo switch è "basso" il motore girerà in direzione opposta.
    }
  }
// ------------- Fine programma ---------------------------------------------------------------------------



Simulazione: Pilotaggio Motore in DC

Argomenti correlati: