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

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 -------------------------------------

Simulazione: Controllo motore in DC con PWM

> Arduino N° 21

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”

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

> Arduino N° 20

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: 

Pilotaggio motore in DC con accelerazione

Arduino - Modulo driver motori con ponte ad “H”

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

> Arduino N° 19

Arduino N° 13 - Pilotaggio motoriduttore in DC con ponte ad "H"

< Arduino N° 12

Achille De Santis

> Arduino N° 14

/* ---------------------- Inizio programma -------------------------------------
    Pilotaggio motore in DC con ponte H
    Subroutine per motore avanti ed indietro.
  */

  #define switchPin   2    // switch input
  #define motor1Pin   3    // H-bridge leg 1 (pin 2, 1A)
  #define motor2Pin   4    // H-bridge leg 2 (pin 7, 2A)
  #define enablePin   9    // H-bridge enable pin
  #define ledPin      13      // LED

  void setup()
  {
    pinMode(switchPin, INPUT);  // set the switch as an input:
            // set all the other pins you're using as outputs:
    pinMode(motor1Pin, OUTPUT);
    pinMode(motor2Pin, OUTPUT);
    pinMode(enablePin, OUTPUT);
    pinMode(ledPin, OUTPUT);
 
    digitalWrite(enablePin, HIGH); // set enablePin high so that motor can turn on:
  }
         
 void MOTORE(int M1, int M2)    // predispone il motore generico
   {
     digitalWrite(M1, LOW);         // set leg 1 of the H-bridge low
     digitalWrite(M2, HIGH);        // set leg 2 of the H-bridge high
   }
 
  void avanti()         {     MOTORE(motor1pin, motor2pin);   }      // fa girare il motore in avanti
  void indietro()      {     MOTORE(motor2pin, motor1pin);   }      // fa girare il motore all'indietro

  void loop()
  {
    if (digitalRead(switchPin) == HIGH)          // se lo switch è "alto" il motore girerà in una direzione
    {      avanti();    }
      else                                                       // se lo switch è "basso" il motore girerà nell'altra direzione
      {      indietro();     }
  }

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

Con lo stesso principio informatore è possibile inserire il comando di "fermo" motore.

Lascio al lettore l'onore e l'onere di sviluppare la piccola routine.


Argomenti correlati:
Pilotaggio motoriduttore con accelerazione

Arduino - Modulo driver motori con ponte ad “H”


> Arduino N° 14

Dimensionamento Transistore BJT in commutazione

prof. De Santis

Utile foglio elettronico di calcolo rapido per il 

Dimensionamento Transistore BJT in commutazione

Dimensionamento Transistore BJT in interdizione, zona attiva, saturazione.

Immettete i soli dati espressi in rosso. NON modificate gli altri campi.

Motore in continua con comando di accelerazione

A. De Santis

Motore in continua con comando di accelerazione

Arduino - Modulo driver motori