Comando per ritardo ad Elettrovalvola

[58019378]

Buon Giorno,

per non aprire un altro post mi allego a questo;

ho aperto un altro sketch che allego, non riesco trovare il comando per dargli il ritardo al Elettrovalvola cosi comè scritto non funziona le ho provate tutte in quel poco che so ma non va, dove sto sbagliando??

unsigned long previousMillis   =             0 ;
const unsigned long interval   =          1000 ;

unsigned long previousMillis_A =             0 ;
const unsigned long interval_A =          5000 ;



const byte pinSonda_Umidita_Terreno     =   A5 ;
const int limite_Sonda_Umidita_Terreno  =    0 ;
const byte pinRelay_Pompa               =    2 ;


const byte pinElettrovalvola             =   3 ;
byte stateRelayElettrovalvola            = LOW ;

unsigned int counter = 0;

int valUmidita = 0,  valSonda_Umidita_Terreno = 0,   valLumen = 0 ;


const byte pin_Analogico                  = A5 ;
const byte pin_Relay_Pompa                =  2 ;

const byte pin_Elettrovalvola             =  3 ;


void setup() {

  Serial.begin ( 9600 ) ;
}
void Lettura_Sonda_Umidita_Terreno ( ) {

  valSonda_Umidita_Terreno = analogRead  ( pinSonda_Umidita_Terreno ) ;

  Serial.print ( " Valore Conducibilita " ) ;
  Serial.print ( valSonda_Umidita_Terreno, DEC ) ;
  Serial.println ( " Ω  " ) ;
  Serial.println ( ) ;

  
  valUmidita = map ( valSonda_Umidita_Terreno,  260,  535,  100,  0 ) ;

  Serial.print   ( " Uidita del Terreno  :     " ) ;
  Serial.print   ( valUmidita );
  Serial.println ( " % ") ;
  Serial.println ( ) ;

}

void Ritardo_pinElettrovalvola ( ) {

  if ( stateRelayElettrovalvola == LOW )  {
    stateRelayElettrovalvola     = HIGH  ;

  }
  digitalWrite ( pinElettrovalvola, stateRelayElettrovalvola ) ;
}

void loop() {

  unsigned long currentMillis = millis ( ) ;

  if ( currentMillis - previousMillis >=  interval ) {

    Lettura_Sonda_Umidita_Terreno ( ) ;

    previousMillis = currentMillis ;

  }
  
currentMillis = millis ( ) ;

  if ( valSonda_Umidita_Terreno <= limite_Sonda_Umidita_Terreno )

  {

    digitalWrite ( 2,          0 );

    digitalWrite ( 3,       LOW );
  }
  else
  {

    digitalWrite ( 2,          1 );

    digitalWrite ( 3,       HIGH );

    if ( currentMillis - previousMillis_A >=  interval_A )
    {
      Ritardo_pinElettrovalvola ( ) ;

      previousMillis_A = currentMillis ;
    }
  }
}

[Maurotec]

@58019378

if ( currentMillis - previousMillis_A >=  interval_A )
    {
      Ritardo_pinElettrovalvola ( ) ;

      previousMillis_A = currentMillis ;
    }

if ( currentMillis - previousMillis_A >=  interval_A )
    {
      Ritardo_pinElettrovalvola ( ) ;

      previousMillis_A = millis() ;    // *** prova così ***
    }

Non dimenticare di premere CTRL-T e poi postare il codice ci ho messo troppo tempo per leggere e capire con la formattazione casuale.

Ciao.

[58019378]

Non so il perchè ma ancora non funziona, il led si accende appena avvio il programma , non so se possa differire ma al posto del Elettrovalvola ho in uso un Led per semplificare e vedere meglio come si comporta il codice.
In pratica il led si dovrebbe accendere 5 secondi dopo del avvio del programma ma non lo fa.

[58019378]

Se prima di inserire il codice faccio CTRL + T mi si apre una nuova pagina Web se inserisco il codice tra CTRL + E non va bene per semplificare e non avere problemi come lo inserisco?

[cotestatnt]

@58019378

prima di inserire il codice faccio CTRL + T

Nell'IDE Arduino non sul browser

[58019378]

Neanche il seguente comando che ho inserito è neanche giusto?

void Ritardo_pinElettrovalvola ( ) {

  if ( stateRelayElettrovalvola == LOW )  {

    stateRelayElettrovalvola     = HIGH  ;t

  }

Ho fatto CTRL + T nel IDE di arduino poi l'ho incollato , cosi è giusto?

[cotestatnt]

Aldilà della formattazione, cosa dovrebbe fare questo sketch?
C'è un bel po' di confusione secondo me.

Dichiari questa variabile inizializzandola a 0

const int limite_Sonda_Umidita_Terreno  =    0 ;

e poi nel codice c'è

if ( valSonda_Umidita_Terreno <= limite_Sonda_Umidita_Terreno )

Come fa un valore letto dall'ADC su A5 ad essere minore di 0 quando il range è 0 - 1023?

[Maurotec]

@58019378

void setup() {

  Serial.begin ( 9600 ) ;

  pinMode(pin_Elettrovalvola, OUTPUT);
  pinMode(pin_Relay_Pompa, OUTPUT);
}

Hai dimenticato pinMode per specificare se il pin è un ingresso o uscita.

Ciao.

[Datman]

...Ma che c'entra tutto questo con i LED RGB???...

@58019378

per non aprire un altro post mi allego a questo;

Aprire un'altra discussione è gratis e permette di seguire e ritrovare il discorso! Perché devi accodare a una discussione esistente un'altra discussione su un argomento diverso???...
Mah...

[Maurotec]

@Datman

Aprire un'altra discussione è gratis e permette di seguire e ritrovare il discorso! Perché devi accodare a una discussione esistente un'altra discussione su un argomento diverso???...
Mah...

La trovo una osservazione troppo sensata per non seguirla.

[gpb01]

Infatti ... post e risposte separate in nuovo thread.

Guglielmo

[58019378]

Ok, per ogni nuovo argomento nuovo aprirò una pagina dedicata.

[58019378]

Buon Giorno,
come richiesto da Maurotec ho inserito gli OUTPUT.
La riga dove cè limite sonda penso si possa regolare anche dopo per il momento non dovrebbe creare problemi.
Il problema ora per cui chiedo aiuto è il ritardo del avvio elettrovalvola.
Non so se la stringa inserita alla riga 52 dove cè il void ritardo_Elettrovalvola sia scritto correttamente.
Poi cè il richiamo sotto il digitalWrite ( 3, OUTPUT ); anchesso se è scritto in maniera corretta e se mancano ulteriori comandi.
Ho riguardato il codice ma non ne esco, non capisco do ve ci sia il problema per cui non funziona il ritardo.

Sono riuscito risolvere un primo punto, cioè ora quando avvio il programma l'elettrovalvola si accende 5 secondi più tardi e questo va bene ora il problema è che se tolgo la sonda dal terreno ( in questo caso sto utilizzando un bicchiere d'acqua) l'elettrovalvola si apre subito al posto di aprirsi 5 secondi più tardi come ritardo questo secondo punto?
Allego lo sketch per fare il pundo dove sono ( spero di allegarlo in maniera corretta perche ancora non ho ben capito il giusto inserimento )

unsigned long previousMillis   =             0 ;
const unsigned long interval   =          1000 ;

unsigned long previousMillis_A =             0 ;
const unsigned long interval_A =          5000 ;


const byte pin_Analogico                  = A5 ;

const byte pin_Relay_Pompa                =  2 ;

const byte pin_Elettrovalvola             =  3 ;
byte      stateElettrovalvola            = LOW ;


const byte pinSonda_Umidita_Terreno     =   A5 ;
const int limite_Sonda_Umidita_Terreno  =  350 ;


int valUmidita = 0,  valSonda_Umidita_Terreno = 0,   valLumen = 0 ;

const byte pinAnalogico                 = A5 ; 
const byte pinRelay_Pompa            =  2 ; 
const byte pinElettrovalvola            =  3 ; 

void setup() {

  Serial.begin ( 9600 ) ;

  pinMode ( pin_Relay_Pompa,    OUTPUT ) ;
  pinMode ( pin_Elettrovalvola,  OUTPUT ) ;
}
void Lettura_Sonda_Umidita_Terreno ( ) {

  valSonda_Umidita_Terreno = analogRead  ( pinSonda_Umidita_Terreno ) ;

  Serial.print ( " Valore Conducibilita " ) ;
  Serial.print ( valSonda_Umidita_Terreno, DEC ) ;
  Serial.println ( " Ω  " ) ;
  Serial.println ( ) ;

  valUmidita = map ( valSonda_Umidita_Terreno,  260,  535,  100,  0 ) ;

  Serial.print   ( " Uidita del Terreno  :     " ) ;
  Serial.print   ( valUmidita );
  Serial.println ( " % ") ;
  Serial.println ( ) ;
}
void Ritardo_pinElettrovalvola ( ) {

  if ( stateElettrovalvola == LOW )  {

    stateElettrovalvola     = HIGH  ;
  }
  digitalWrite ( pin_Elettrovalvola,  stateElettrovalvola ) ;
}
void loop() {

  unsigned long currentMillis = millis ( ) ;

  if ( currentMillis - previousMillis >=  interval ) {

    Lettura_Sonda_Umidita_Terreno ( ) ;

    previousMillis = currentMillis ;
  }
  currentMillis = millis ( ) ;

  if ( valSonda_Umidita_Terreno <= limite_Sonda_Umidita_Terreno )
  {
    digitalWrite ( pinRelay_Pompa  ,     LOW ) ;
    digitalWrite ( pin_Elettrovalvola ,     LOW ) ;
  }
  else
  {
    digitalWrite ( pin_Elettrovalvola ,     HIGH ) ;

    if ( currentMillis - previousMillis_A >=  interval_A )
    {
      if ( stateElettrovalvola == LOW );

      Ritardo_pinElettrovalvola ( ) ;

      previousMillis_A = currentMillis ;

      digitalWrite ( pin_Elettrovalvola ,     HIGH ) ;
    }
  }
}

Pultroppo ora sono Bloccato non so più come procedere.

[Maurotec]

else
  {

    digitalWrite ( 2,          1 );

    digitalWrite ( 3,       HIGH );   // qui in effetti accendi il pin 3
    // vai a vedere la dichiarazione const byte pinElettrovalvola               //=   3 ;

    if ( currentMillis - previousMillis_A >=  interval_A )
    {
      Ritardo_pinElettrovalvola ( ) ;

      previousMillis_A = currentMillis ;
    }
  }

Stavi andando bene fino al momento che hai preteso di correre. Rallenta e segui le regole:

1. al posto dei numeri usa le costanti dichiarate prima.
2. usa // per scrivere un commento nel tuo sorgente.
3. usa spesso CTRL-T per identare il codice.

Apporta le modifiche e posta nuovamente il codice correttamente identato.

Riguardo al punto (2) un commento che non aggiunge informazioni utili non è utile, es:

const byte pin_Relay_Pompa  =  2 ;   // pin a cui è connessa la pompa

Questo commento non fornisce ulteriori informazioni rispetto al nome della variabile che si dice essere autodocumentante.

I commenti si usano anche per annotarsi qualcosa durante la codifica, ad es: // NOTE: non dimenticarsi di attivare ecc

Ciao.

[58019378]

Perche il programma al avvio lo esegue correttamente e poi se inserisco la sonda nel umidita e poi la tolgo non esegue più correttamente il programma ma si accendono in contemporanea sia la pompa che l'elettrovalvola? anzichè aprire l'elettrovalvola ritardata?

Sarebbe bello poter proseguire, ma se oltre non riesco andare devo lasciare lo sketch sospeso.

[tizubuntu]

Prima di tutto mai abbattersi ma perseverare se si vuole andare avanti.

Leggendo di botto il programma, mi pare di vedere un po’ di confusione sia nelle dichiarazioni di variabili e funzioni, sia sul loro uso.

Es. tu dichiari una funzione chiamata Ritardo_Elettrovalvola. In realtà non fa altro che invertire lo stato del pin e basta senza tempi.
Poi, nella If dove controlli il valore della sonda , alla sezione else prima accendi l’elettrovalvola e poi verifichi se sono trascorsi i 5 secondi. Dovresti fare al contrario.
Ripeto, l’ho letto di un fiato prima di andare a lavoro.

[58019378]

Ok grazie tizubuntu,
riguarderò lo sketch.

Niente sono qui che gli giro attorno ma non trovo la stringa giusta per il ritardo.

[58019378]

Dove sto Sbagliando? non riesco trovare la giusta sequenza

const unsigned long interval = 5000;

const unsigned long interval_A = 3000;

unsigned long previousMillis = 0;

unsigned long previousMillis_A = 0;

const byte pinSonda_Umidita_Terreno     =  A5;

const int limite_Sonda_Umidita_Terreno  = 275;

const byte pinRelay_Pompa                =  2;

const byte pinElettrovalvola             =  4;
byte stateElettrovalvola                 =  0 ;

int valUmidita = 350,  valSonda_Umidita_Terreno = 350,   valLumen = 0;


void setup ( )  {

 
  Serial.begin ( 9600 ) ;

  
  pinMode ( pinRelay_Pompa,        OUTPUT );
  pinMode ( pinElettrovalvola,     OUTPUT );
}

void Lettura_Sonda_Umidita_Terreno () {

  valSonda_Umidita_Terreno = analogRead  ( pinSonda_Umidita_Terreno );


  Serial.print ( " Valore Conducibilita " ) ;
  Serial.print ( valSonda_Umidita_Terreno, DEC ) ;
  Serial.println ( " Ω  " ) ;
  Serial.println ( ) ;


  valUmidita = map ( valSonda_Umidita_Terreno,  260,  535,  100,  0 );

  Serial.print   ( " Uidita del Terreno  :     " ) ;
  Serial.print   ( valUmidita );
  Serial.println ( " % ") ;
  Serial.println ( ) ;
}

void Ritardo_Elettrovalvola ( ) {

  if ( stateElettrovalvola == 0 )  {

    stateElettrovalvola = 1 ;
  }
  digitalWrite ( pinElettrovalvola, stateElettrovalvola ) ;
}
void loop ( )  {
 
  unsigned long currentMillis = millis();

  if ( currentMillis - previousMillis >=  interval ) {
   
    previousMillis = currentMillis;
   
    Lettura_Sonda_Umidita_Terreno ( ) ;
  }
  if ( valSonda_Umidita_Terreno <= limite_Sonda_Umidita_Terreno )
  {
    
    digitalWrite ( pinRelay_Pompa,          LOW ); 
    digitalWrite ( pinElettrovalvola,          LOW ); 
   
  } else {
 
    digitalWrite ( pinRelay_Pompa,          HIGH ); 

    if ( currentMillis - previousMillis_A <=  interval_A ) {

      Ritardo_Elettrovalvola ( ) ;
   
      previousMillis_A = currentMillis;
    } {
      digitalWrite ( pinElettrovalvola,       HIGH ); 

    }
  }
}

[Maurotec]

if ( currentMillis - previousMillis_A <=  interval_A ) {

      Ritardo_Elettrovalvola ( ) ;    // questa non fa altro che accendere se risulta spenta
   
      previousMillis_A = currentMillis;
    } {  // qui forse volevi metterci } else {
      digitalWrite ( pinElettrovalvola,       HIGH ); // qui accendi l'elettrovalvola ma quando la devi spegnere?
    }

Aiutati con Serial.println("entrato nella if ecc") così da vedere quale porzione di codice viene eseguita.

Specifica chiaramente quando vuoi accendere l'elettrovalvola e quando spegnerla, es:
L'elettrovalvola e la pompa si devono accendere a comando e poi si devono spegnere dopo 3 secondi.

Ciao.

[58019378]

Pultroppo sono punto a capo non ne vengo fuori;

  if ( valSonda_Umidita_Terreno <= limite_Sonda_Umidita_Terreno )
  {
   
    digitalWrite ( pinRelay_Pompa,          0 );
    digitalWrite ( pinElettrovalvola,       0 ); 
    
  } else {
   
    digitalWrite ( pinRelay_Pompa,          1 );
    digitalWrite ( pinElettrovalvola,       1 ); 
    }