in ingresso arduino può ricevere segnali da un elettrovalvola?

ciao, volevo provare a realizzare uno schema in cui, l'elettrovalvola del giardino che funziona a 24V, quando viene attivata dalla sua centralina, viene riconosciuta da arduino come attivata. Arduino a sua volta, attiva una pompa.
In poche parole ho tre lettrovalvole EV1 EV2 EV3
non partono mai insieme ma solo una alla volta, se parta una EV qualsiasi, arduino, attiva una pompa. La pompa deve essere attivata solo per due minuti.
Ho pensato ad un circuito del genere...ma....posso prendere un positivo delle elettrovalvole e mandarlo ad un pin in ingresso di arduino?!?
ho dei dubbi... posto lo schema che avevo pensato...mi date dei consigli? grazie!


sperando che io possa operare come da schema...mi ero cimentato anche nella stesura del codice...gli date un occhio?
grazie ancora!

// definizione stati
#define ATTESA 0 
#define TIME_ON 2  // definizione STATO ON (LAVORO)

const byte OUT = 5; //pin4=collegamento uscita al galleggiante 
const byte IN_ev1 = 2;  //pin2=collegamento ingresso relè
const byte IN_ev2 = 3;  //pin3=collegamento ingresso relè
const byte IN_ev3 = 4;  //pin4=collegamento ingresso relè

byte stato_ev1;
byte stato_ev2;
byte stato_ev3;
byte stato_OUT;

unsigned long Tcorr;
unsigned long T0;
unsigned long I2 = 2 * 60 * 1000UL;  //definisco 2minuti come tempo ON

int caso;


void setup()
{
  pinMode(OUT, OUTPUT);
  pinMode(IN_ev1, INPUT);
  pinMode(IN_ev2, INPUT);
  pinMode(IN_ev3, INPUT);
  // condizioni iniziali
  caso = ATTESA;
  stato_ev1 = LOW;
  stato_ev2 = LOW;
  stato_ev3 = LOW;
  T0 = millis();
  }

void loop()
{
  Tcorr = millis();
  stato_ev1 = digitalRead(IN_ev1); // Legge ingresso A
  stato_ev2 = digitalRead(IN_ev2); // Legge ingresso A
  stato_ev3 = digitalRead(IN_ev3); // Legge ingresso A
  

// definizione stati
  switch (caso)
  {

    case ATTESA:
      if(stato_ev1 == LOW && stato_ev2 == LOW && stato_ev3 == LOW)
      {
        stato_OUT = LOW;
      }
      else
      {
        caso = TIME_ON; // PASSA ALLA FASE start
        T0 = Tcorr;     // Azzera il contatore
      }
      break;

    case TIME_ON:
      if(stato_ev1 == LOW && stato_ev2 == LOW && stato_ev3 == LOW)
      {
        stato_OUT = LOW;
        caso = ATTESA;
      }
      else
      {
        if (Tcorr - T0 >= I2)
        {
          T0 = Tcorr;   // Azzera contatore
          caso = ATTESA;
        }
        else
        {
          stato_OUT = HIGH;
        }
      }
      break;


    default:
      break;

  } // End switch
  
  digitalWrite(OUT, stato_OUT);
  
}  // End loop

La tensione massima di ingresso all'Arduino è di 5V, con 24V bruci l'integrato.
Devi abbassare la tensione.

Inoltre non devi inviare solo il positivo, ma anche il GND deve essere in comune con l'elettrovalvole.

Grazie paoloP....
ehmm.....detto più terra a terra? :slight_smile:
nel senso...ho capito che devo abbassare la tensione in ingresso ad arduino...e dovrei capire come...
ma non ho capito nemmeno come fare a portare in ingresso anche il gnd? devo "raccogliere i negativi" delle tre elettrovalvole e collegarle tutte e tre insieme al GND (ad esempio quello che c'è tra il pin 19 e il 21) giusto?
per il discorso tensione...come potrei abbassarla senza influenzare l'utilizzo "normale" delle EV? (il mio circuito con arduino andrebbe solo in alcune fasi dell'anno, non sempre)

Credo tu possa usare un fotoaccoppiatore per valvola e qualche resistenza.
In questo modo mantieni separati i due circuiti.

Ad esempio: 4N35 (http://www.robot-italy.net/downloads/4N35.pdf)

ok, e per la questione dei collegamenti?
i tre negativi delle EV posso raccoglierle e collegarle al GND di arduino?
...mentre lo schema che mi hai suggerito, va fatto ognuno per ogni EV, giusto?

una considerazione....giusto per imparare...
poniamo il caso che arduino non ci sia, ma al suo posto solo un relè normalissimo. Bene, giusto per capire il funzionamento delle cose, se "raccogliessi i positivi" nel relè, ma usassi un diodo in serie ad ogni EV, escluderei il caso in cui una EV eccitata possa "far tornare indietro corrente" ed eccitare un'altra EV che invece era chiusa dalla centralina?
grazie!

Si corretto. Anche se presumo che all'interno della centralina i negativi siano tutti collegati tra di loro. Quindi basta sceglierne uno.
Lo vedi subito con un multimetro e il test di continuità elettrica. (esegui il test con l'apparecchio staccato dalla rete elettrica)

Se usi gli optoisolatori non serve collegare il GND tra di loro.

ok garzie....inizio a capirci qualcosa allora :slight_smile:
...tornando all'utilizzo di arduino, che è quello che volevo appunto imparare...
vediamo se posso avere intuito una soluzione....
potrei usare un 7812 con in serie un 7805 così potrei abbassare i 24V positivi delle EV
la domanda è....visto che devo tenere separati gli ingressi per poterli distinguere...mi serviranno 3 distinti circuiti con 7812+7805 ?

in mezzo però (dopo l'uscita del 1805 e prima di arduino) devo mettere tre fotoaccoppiatori (uno per ogni positivo di ogni EV)
seguendo il tuo schema con 4N35 dovrei collegare:
x-1 = uscita positivo del 7805
gnd1 = negativo EV1
IND1 = pin 2 arduino
gnd2 = GND arduino

con il secondo fotoaccioppiatore
x-1 = uscita positivo del 7805 (può essere l'uscita di una unica coppia di 7812+7805, oppure ne devo usare una coppia per ogni EV???)
gnd1 = negativo EV2
IND1 = pin 3 arduino
gnd2 = GND arduino (la stessa di prima)

con il terzo fotoaccoppiatore stessa storia....
grazie!

Usa i fotoaccoppiatori, come ti è stato suggerito, senza i 78xx.
Guardati come funzionano, capirai subito come collegarli.

E' sbagliato anche il relè collegato in quel modo come nella prima immagine. Assorbe troppa corrente, ci vuole un transistor.
Vedi le schede di pighi che tovi al sito www.pighixxx.com alla voce ABC ci sono anche altre "basic connection" e ti saranno utili.

Ovviamente usare una UNO per una cosa del genere è esagerato.
Potresti usare anche solo un relè temporizzato.
O un circuitino con un attiny85 se sai fare le saldature.
Oppure un pressostato sulla pompa che la attiva quando i rubinetti sono aperti...

ciao e grazie dei coonsigli!
interessante l'attiny85 non lo conoscevo, e supporta anche la funzione millis()
devo però alimentarlo a 5v....alla fine di cose da aggiungere ce ne sono parecchie....ma per imparare va più che bene.
lato pratico però forse lo schema che ho fatto nel post #4 è quello più rapido e semplice!

mi piace anche l'idea del pressostato...però sapresti indicarmi un link a qualche prodotto adatto al mio scopo in modo da poterci capire di più?
se cerco usando la chiave di ricerca pressostato....mi si apre il mondo...

infine il relè temporizzato è una idea...però, che costano poco, a 24v (circa 3-4euro) ne ho trovati solo con il delay start...ma va bene lo stesso....
se ogni EV si apre per bagnare per 5minuti, faccio il processo inverso, do un delay di 3min, così la pompa si accende solo per i due minuti che volevo....
se conosci altri relè più idonei dimmi pure :slight_smile:

grazie ancora!!!!!

PaoloP:
Credo tu possa usare un fotoaccoppiatore per valvola e qualche resistenza.
In questo modo mantieni separati i due circuiti.

Ad esempio: 4N35 (http://www.robot-italy.net/downloads/4N35.pdf)

ciao, mi hai fatto mettere una resistenza da 2.2k per limitare la corrente in ingresso al fotoaccoppiatore, giusto?
leggendo il datasheet infatti, se ho capito bene, nella seconda pagina, in tabella dove parla di EMITTER indica la parte in ingresso e dice che al massimo può supportare 100mA corretto?
però in questo modo, se prendo il positivo direttamente dalla EV che è a 24V, entrerei nel pin1 con i 24V, mentre sempre in tabella, e sempre se ho capito bene, dove trovo la massima V input ?
ho visto un Reverse Input Voltage = 6V è quello? in questo caso è corretto usare i 24V della EV che passano per la resistenza da 2.2k e poi entrano nel pin1 ?
grazie e scusate la banalità! :frowning:

La resistenza puoi metterla anche da 1k ohm.
Con quella resistenza passeranno solo 18mA [(24-6)/1000]. Forse quella da 2.2k è eccessiva.

Per i led non trovi la tensione massima applicabile perchè si pilotano in corrente.
Devi fare in modo di non superare il valore massimo in corrente qualunque sia la tensione. Anche se fossero 100V.
Il reverse input voltage è la caduta di tensione nel ramo del circuito dovuta alla presenza di quel led. E' utile per calcolare il valore di corrente tramite la legge di Ohm.

grazie PaoloP ora mi è più chiaro il tutto!

ciao, finalmente mi è arrivato arduino e l'attiny85 che volevo usare per questo progetto
il mio attiny85 già il pcb preassemblato con la porta micro usb per la programmazione.
ho caricato nel software di arduino le librerie per attiny e mi compaiono
il problema però è quando collego l'attiny85 al pc che non me lo riconosce come dispositivo COM
quindi non so cosa impostare nel software di arduino per fare scrivere la eprom con il mio programma
come dovrei fare?!?
grazie!
ps. il mio attiny85 è praticamente identico a questo:
http://www.ebay.it/itm/381327679684?_trksid=p2060353.m2749.l2649&ssPageName=STRK%3AMEBIDX%3AIT

Quelle schedine basate sull'85 hanno alcune peculiarità. Per programmarle non collegarle al PC, inizialmente. Compila lo sketch, se non dà errori fai Upload e SOLO ALLORA collegane una tramite USB, ma ti dirà comunque lui quando farlo.

Quelle schedine basate sull'85 hanno alcune peculiarità. Per programmarle non collegarle al PC, inizialmente. Compila lo sketch, se non dà errori fai Upload e SOLO ALLORA collegane una tramite USB, ma ti dirà comunque lui quando farlo.

Per me è cosa nuova, hai maggiori info su l'oggetto in questione?

Ciao.

Sono cloni del Digispark: https://digistump.com/wiki/digispark

Ho partecipato al Kickstarter, le conosco bene...

Comunque secondo me Marco si è solo complicato la vita. Vero che un Arduino è sprecato, ma visto che con meno di 2€ puoi avere un Nano (clone)...

ciao stasera do un occhio e provo! :smiley:
perchè complicato la vita?
che vantaggio avevo con il nano? :slight_smile:
grazie mille a tutti per il tempo che mi dedicate!!

Avresti avuto una piattaforma più comune e un po' di scomodità in meno. Il problema più grande probabilmente è che non hai una porta seriale su cui stampare messaggi per facilitare il debugging. Non facilmente, almeno.

Ci sono poi altre scomodità sui singoli pin, tipo che il pin 5 arriva solo a ~3V quando alto, anche il 3 ha qualche limitazione e altro ancora.

Tutte "caratteristiche" giustificate ed accettabili, per carità, se lo si fa con coscienza. Qua mi pare che ci si dimentichi un po' troppo spesso che molti di coloro che si avvicinano al mondo di Arduino non hanno alcuna conoscenza di elettronica e/o programmazione, per cui sarebbe meglio mettere da parte l'efficienza/eleganza a favore della semplicità.

ciao, sono riuscito a programmare il mio attyny85 con DigistumpIDE1.5.8C usando la miniusb

il codiche che ho caricato è questo:

// definizione stati
#define ATTESA 0 
#define TIME_ON 2  // definizione STATO ON (LAVORO)

const byte OUT = 5; //pin5=collegamento uscita al galleggiante 
const byte IN_ev1 = 2;  //pin2=collegamento ingresso relè
const byte IN_ev2 = 3;  //pin3=collegamento ingresso relè
const byte IN_ev3 = 4;  //pin4=collegamento ingresso relè

byte stato_ev1;
byte stato_ev2;
byte stato_ev3;
byte stato_OUT;

unsigned long Tcorr;
unsigned long T0;
unsigned long I2 = 2 * 60 * 1000UL;  //definisco 2minuti come tempo ON

int caso;


void setup()
{
 pinMode(OUT, OUTPUT);
 pinMode(IN_ev1, INPUT);
 pinMode(IN_ev2, INPUT);
 pinMode(IN_ev3, INPUT);
 // condizioni iniziali
 caso = ATTESA;
 stato_ev1 = LOW;
 stato_ev2 = LOW;
 stato_ev3 = LOW;
 T0 = millis();
 }

void loop()
{
 Tcorr = millis();
 stato_ev1 = digitalRead(IN_ev1); // Legge ingresso A
 stato_ev2 = digitalRead(IN_ev2); // Legge ingresso A
 stato_ev3 = digitalRead(IN_ev3); // Legge ingresso A
 

// definizione stati
 switch (caso)
 {

   case ATTESA:
     if(stato_ev1 == LOW && stato_ev2 == LOW && stato_ev3 == LOW)
     {
       stato_OUT = LOW;
     }
     else
     {
       caso = TIME_ON; // PASSA ALLA FASE start
       T0 = Tcorr;     // Azzera il contatore
     }
     break;

   case TIME_ON:
     if(stato_ev1 == LOW && stato_ev2 == LOW && stato_ev3 == LOW)
     {
       stato_OUT = LOW;
       caso = ATTESA;
     }
     else
     {
       if (Tcorr - T0 >= I2)
       {
         T0 = Tcorr;   // Azzera contatore
         caso = ATTESA;
       }
       else
       {
         stato_OUT = HIGH;
       }
     }
     break;


   default:
     break;

 } // End switch
 
 digitalWrite(OUT, stato_OUT);
 
}  // End loop

il Digistump ha gli ingressi/uscite nominate sul pcb come p0 p1 p2 p3 p4 p5
avendo io usato come ingressi

const byte OUT = 5; //pin5=collegamento uscita al galleggiante
const byte IN_ev1 = 2; //pin2=collegamento ingresso relè
const byte IN_ev2 = 3; //pin3=collegamento ingresso relè
const byte IN_ev3 = 4; //pin4=collegamento ingresso relè

il pin di ingresso 2 3 4 saranno p2 p3 p4 mentre quello di uscita sarà il p5, corretto?
se volessi fare un test del mio circuito simulando le elettrovalvole....e vedendo cosa ottengo in uscita, potreste suggerirmi uno schema adatto a testare il funzionamento del mio primo programma?

grazie mille!!!!!!!!!!

il pin di ingresso 2 3 4 saranno p2 p3 p4 mentre quello di uscita sarà il p5, corretto?

No, se su p5 ci colleghi un gallegiante (contatto) il pin devi configurarlo come ingresso, e gli altri come uscita.

 pinMode(OUT, INPUT);
 pinMode( IN_ev1, OUTPUT );
 pinMode( IN_ev2, OUTPUT );
 pinMode( IN_ev3, OUTPUT );

Ciao.