Verfica funzionamento sensori durante loop

Ciao a tutti,

sto buttando giù un codice che mi verifichi che le letture dei sensori(bme280) e sensore pioggia a pettine in inox autocostruito siano corrette e che non ci siano problemi sui sensori.

per entrambi sto ragionando in questo modo:

leggo il valore del sensore alla prima esecuzione del loop e lo “memorizzo in una variabile”, memorizzo il secondo valore in’altra variabile dopo l’esecuzione del secondo loop, al terzo loop, prima della verifica del sensore, faccio la differenza delle due letture e se rientrano all’interno di questi range:

if((pioggia_3>=300 && pioggia_3<=1024) || (pioggia_3>=-1024 && pioggia_3<=-300)) {

blocco l’esecuzione del loop.

faccio un’esempio per il sensore pioggia:

prima lettura del primo loop 1023
seconda lettura del secondo loop 1015
differenza prima lettura-seconda lettura = 8

  • il sensore legge correttamente -

secondo esempio(problema riscontrato quando il sensore a pettine mi si ossidò)

prima lettura del primo loop 530 (pioveva veramente)
seconda lettura del secondo loop 1015 (il valore si alzava anche con la pioggia)
differenza prima lettura-seconda lettura = -485

arduino mi va in blocco per letture troppo discordanti tra un loop e un’altro…

per esperienza diretta questa è l’unica anomalia che mi ha dato un sensore a pettine usato per la pioggia, non so quali altre anomalie potrebbe dare e quindi come condizionarmi le letture…

vorrei fare la stessa cosa per il bme280 per il discordo temperatura…
non so se ci sia un modo diverso per fare quanto detto…

grazie

Cosa vuol dire “Arduino mi va in blocco pr valori troppo discordanti”??? non è che nel tuo programma cadi in una casistica per cui resti “intrappolato” in un while o roba simile?

Ciao,

No...forse mi sono espresso male... la parte di codice che sto elaborando è per mettere in "blocco" io , o meglio fare in modo che arduino non esegua piu parte del loop se si crea la condizione dell'esempio sopra... il dubbio che ho è se ci sia un modo più giusto per poter verificare quello che vorrei verificare io...

Conviene che pubblichi tutto il programma. Anche per capire a che distanza di tempo fai le due letture.

Ciao,
P.

ho postato solo la parte che sto implementando, ho escluso quello che non serve per questa parte, il codice è molto lungo… se invece dovesse servire tutto lo inserisco…

lo sto testando e funziona… ma ripeto non so se ci sia un modo più corretto per controllarlo…

bool pioggia1  = false;
bool pioggia2  = false;
bool pioggia3  = false;
int pioggia_1 = 0;
int pioggia_2 = 0;
int pioggia_3 = 0;



void controllaPIOGGIA() { 
  
         digitalWrite (pin_pioggia, HIGH ); 
  
         delay(100); 
  
         misurazione = analogRead(pin_sensore); 
  
         digitalWrite (pin_pioggia, LOW ); 
  
   } 



void loop() {

if(pioggia1 == true && pioggia2 == true) {    // differenza tra le misurazioni ed eventuale blocco
  pioggia_3 = pioggia_1-pioggia_2;
  Serial.println("pioggia_3");
  Serial.println(pioggia_3);
   pioggia1 = false; 
  pioggia2 = false; 
 if((pioggia_3>=300 && pioggia_3<=1024) || (pioggia_3>=-1024 && pioggia_3<=-300)) {
 Serial.println("anomalia riscontrata");
 pioggia3 = true;
}
  }
if(pioggia3 == true) {
  Serial.println("blocco attivato");
stato_pulsanteSX = 1;                // CAMBIO STATO PULSANTE CHE FA ESCLUDERE L'APERTURA E
stato_pulsanteCENTRO = 1;         // CHIUSURA DELLE TENDE 
stato_pulsantePICCOLA = 1;               

}
controllaPIOGGIA(); // verifica del sensore pioggia

if(pioggia1 == true && pioggia2 == false) {   // seconda memorizzazione
  pioggia_2 = misurazione;
  Serial.println("pioggia_2");
Serial.println(pioggia_2);
pioggia2 = true;
}
if(pioggia1 == false && pioggia2 == false) {       // prima memorizzazione
  pioggia_1 = misurazione;
  Serial.println("pioggia_1");
Serial.println(pioggia_1);
pioggia1 = true;
}

simosere:
...sto buttando giù un codice che mi verifichi che le letture dei sensori(bme280) e sensore pioggia a pettine in inox autocostruito siano corrette ...

per entrambi sto ragionando in questo modo:

leggo il valore del sensore alla prima...

Quale sensore stai analizzando?

Ciao,
P.

al momento mi sono concentrato su quello della pioggia...

per esperienza diretta questa è l'unica anomalia che mi ha dato un sensore a pettine ossidato usato per la pioggia, non so quali altre anomalie potrebbe dare e quindi come condizionarmi le letture...

sto ragionando anche sul bme280.... non vedo altre soluzione se non fare come per il discorso pioggia... appena butto giù un codice lo posto.... essendo un sensore che lavora in i2c, si può controllare se sta funzionando in qualche altro modo? tipo verificando nel loop se è ancora inizializzato? certo che se è inizializzato, ma legge in maniera sbagliata si rende necessario un controllo come quello per la pioggia... boh...

simosere:
pioggia_3 = pioggia_1-pioggia_2;

if((pioggia_3>=300 && pioggia_3<=1024) || (pioggia_3>=-1024 && pioggia_3<=-300)) {
Serial.println(“anomalia riscontrata”);
pioggia3 = true;
}

Non ho suggerimenti specifici ma solo una possibile “miglioria” come semplificazione del codice. DAto che pioggia_3 andrà da -1023 a 1023 (differenza tra le due letture), tu di fatto consideri anomala una differenza tra le due misurazioni se maggiore di 300, esatto? E dal listato mi pare che a te non interessi se positiva o negativa, ma solo la differenza assoluta, esatto?
Magari farei una cosa del genere, che è più chiara e compatta visto che calcola proprio il valore assoluto della differenza (ho anche eliminato la variabile pioggia_3, apparentemente inutile in quanto valorizzata una sola volta):

  ...
  if ( abs(pioggia_1-pioggia_2)>=300 ) {
   Serial.println("anomalia riscontrata");
   pioggia3 = true;
  }

Quindi lo stesso criterio puoi applicarlo anche per la temperatura (anche se i sensori di temperatura possono essere imprecisi ma non credo diano gli stessi problemi di deterioramento delle forchette per la pioggia…).

PS ti prego, premi Ctrl-T nell’IDE e fatti indentare per bene il codice, sarà più leggibile anche per te oltre che per noi!

Ciao doc doc,
no, in realtà sono non ok tutti i valori compresi tra 300 e 1023 e -1023 e -300
riporto l’esempio che ho fatto qualche post fa dove a causa del sensore ossidato mi alternava letture da pioggia(valori bassi) e valori da non pioggia(valori alti)

prima lettura del primo loop 530 (pioveva veramente)
seconda lettura del secondo loop 1015 (il valore si alzava anche con la pioggia)
differenza prima lettura-seconda lettura = -485

cosa inversa
prima lettura del primo loop 1015 (pioveva veramente)
seconda lettura del secondo loop 530 (il valore si alzava anche con la pioggia)
differenza prima lettura-seconda lettura = 485

simosere:
no, in realtà sono non ok tutti i valori compresi tra 300 e 1023 e -1023 e -300

Si ma parliamo qui della DIFFERENZA tra le due letture, ognuna delle quali va da 0 a 1023, e non della lettura singola.

Il valore di cui parli, tra -1023 e -300 o tra 300 e 1023, è appunto la differenza ("pioggia_1-pioggia_2"), ma come ho cercato di spiegarti significa che in sostanza il VALORE ASSOLUTO della differenza ("abs(pioggia_1-pioggia_2)") se è maggiore di 300 corrisponde esattamente al tuo criterio, ed è quello che ti ho scritto.

grazie docdoc, non avevo capito e rileggendoti ora mi è tutto chiaro...

nel frattempo ho aggiunto una parte di ragionamento che non ho considerato nel ragionamento del codice sopra, ovvero che se comincia a piovere a goccioloni, siamo proprio sicuri che il valore analogico del sensore non passa magari da 1023 ad esempio a 700.... umh...

sono andato avanti con i ragionamenti e in attesa di un bello sgrullone con goccioloni importanti questa è l’evoluzione del codice postato nella prima versione, da ottimizzare come da consiglio di doc doc, per miei limiti mi risulta in questa fase più leggibile in questo modo… :slight_smile:

che ne dite?

if(bloccoattivato == false) {
if(pioggia3 == false) {
if(pioggia1 == true && pioggia2 == true) {    // differenza tra le misurazioni ed eventuale blocco
pioggia_3 = pioggia_1-pioggia_2;
Serial.println("pioggia_3");
Serial.println(pioggia_3);
pioggia1 = false;
pioggia2 = false;
if((pioggia_3>=300 && pioggia_3<=1023) || (pioggia_3>=-1023 && pioggia_3<=-300)) { 
controlloeffettuato = false;
Serial.println("anomalia riscontrata");
pioggia3 = true;
verificaanomalia = true;
}
else{                                                        
controlloeffettuato = true;
Serial.println("controlloeffettuato");
Serial.println(controlloeffettuato);
}
}
}
}
if(bloccoattivato == false) {
if(pioggia3 == true) {
if(pioggia1 == true && pioggia2 == true) {    // approfondimento in caso di anomalia
pioggia_4 = pioggia_1-pioggia_2;
Serial.println("pioggia_4");
Serial.println(pioggia_4);
pioggia1 = false;
pioggia2 = false;
count--;
Serial.println("count");
Serial.println(count);
if((pioggia_4>=300 && pioggia_4<=1023) || (pioggia_4>=-1023 && pioggia_4<=-300)) {
Serial.println("anomalia confermata");
pioggia4 = true;
verificaanomalia = true;
}
if (count == 0){
pioggia3 = false;
verificaanomalia = false;
count = 5;
}
}
}
}
if(bloccoattivato == false) {
if(pioggia4 == true) {
Serial.println("blocco attivato");
stato_pulsanteSX = 1;                // CAMBIO STATO PULSANTE CHE FA ESCLUDERE L'APERTURA E
stato_pulsanteCENTRO = 1;         // CHIUSURA DELLE TENDE
stato_pulsantePICCOLA = 1;
bloccoattivato = true;
}
}
controllaPIOGGIA(); // verifica del sensore pioggia

//verifica su falsi positivi

if(misurazione < 700 && statoverificapioggia == false && pioggiaconfermata == false &&  // verificaanomalia == false && controlloeffettuato == true) {
startingTimePIOGGIA = millis();
statoverificapioggia = true;
sogliapioggia = misurazione;
}

// se misurazione scende del 10% durante il periodo di controllo pioggia confermata e non falso positivo
if (statoverificapioggia == true && ((millis() - startingTimePIOGGIA) < TIMEOUTPIOGGIA)) {
if(verificaanomalia == false) {
if (misurazione <= (sogliapioggia-((sogliapioggia*10)/100))) {
pioggiaconfermata = true;
Serial.println("pioggiaconfermata");
Serial.println(pioggiaconfermata);
statoverificapioggia = false;
sogliapioggia = 0;
}
}
}

// se dopo 3 minuti di attesa misurazione è maggiore o uguale alla soglia, o è un falso positivo o ha smesso di piovere
if (statoverificapioggia == true  && ((millis() - startingTimePIOGGIA) > TIMEOUTPIOGGIA)) {
if(verificaanomalia == false) {
if (misurazione >= sogliapioggia) {
pioggiaconfermata = false;
statoverificapioggia = false;
sogliapioggia = 0;
}
}
// se dopo 3 minuti di attesa misurazione è minore alla soglia, sta veramente piovendo(DA VALUTARE SE METTERE UNA PERCENTUALE  ANCHE QUI... SE è DIMINUITO DEL 10% ANCHE QUI PER ESEMPIO)
}
if (statoverificapioggia == true  && ((millis() - startingTimePIOGGIA) > TIMEOUTPIOGGIA)) {
if(verificaanomalia == false) {
if (misurazione < sogliapioggia) {
pioggiaconfermata = true;
statoverificapioggia = false;
sogliapioggia = 0;
}
}
}  
if (pioggiaconfermata == true && misurazione >= 700) {
pioggiaconfermata = false;
}

if(bloccoattivato == false) {
if(pioggia1 == true && pioggia2 == false) {   // seconda memorizzazione
pioggia_2 = misurazione;
Serial.println("pioggia_2");
Serial.println(pioggia_2);
pioggia2 = true;
}
}
if(bloccoattivato == false) {
if(pioggia1 == false && pioggia2 == false) {       // prima memorizzazione
controlloeffettuato = false;
Serial.println("controlloeffettuato");
Serial.println(controlloeffettuato);
pioggia_1 = misurazione;
Serial.println("pioggia_1");
Serial.println(pioggia_1);
pioggia1 = true;
}
}

Dico che se non indenti il codice non si capisce una mazza... :wink:
Premi Ctrl-T nell'IDE e riposta il codice.

eccolo:

eccolo:

if (bloccoattivato == false) {

    if (pioggia3 == false) {

      if (pioggia1 == true && pioggia2 == true) {   // differenza tra le misurazioni ed eventuale blocco

        pioggia_3 = pioggia_1 - pioggia_2;

        Serial.println("pioggia_3");

        Serial.println(pioggia_3);

        pioggia1 = false;

        pioggia2 = false;

        if ((pioggia_3 >= 300 && pioggia_3 <= 1023) || (pioggia_3 >= -1023 && pioggia_3 <= -300)) {

          controlloeffettuato = false;

          Serial.println("anomalia riscontrata");

          pioggia3 = true;

          verificaanomalia = true;

        }

        else {

          controlloeffettuato = true;

          Serial.println("controlloeffettuato");

          Serial.println(controlloeffettuato);

        }

      }

    }

  }

  if (bloccoattivato == false) {

    if (pioggia3 == true) {

      if (pioggia1 == true && pioggia2 == true) {   // differenza tra le misurazioni ed eventuale blocco

        pioggia_4 = pioggia_1 - pioggia_2;

        Serial.println("pioggia_4");

        Serial.println(pioggia_4);

        pioggia1 = false;

        pioggia2 = false;

        count--;

        Serial.println("count");

        Serial.println(count);

        if ((pioggia_4 >= 300 && pioggia_4 <= 1023) || (pioggia_4 >= -1023 && pioggia_4 <= -300)) {

          Serial.println("anomalia confermata");

          pioggia4 = true;

          verificaanomalia = true;

        }

        if (count == 0) {

          pioggia3 = false;

          verificaanomalia = false;

          count = 5;

        }

      }

    }

  }

  if (bloccoattivato == false) {

    if (pioggia4 == true) {

      Serial.println("blocco attivato");

      stato_pulsanteSX = 1;                // CAMBIO STATO PULSANTE CHE FA ESCLUDERE L'APERTURA E

      stato_pulsanteCENTRO = 1;         // CHIUSURA DELLE TENDE

      stato_pulsantePICCOLA = 1;

      bloccoattivato = true;

    }

  }

  controllaPIOGGIA(); // verifica del sensore pioggia



  if (misurazione < 700 && statoverificapioggia == false && pioggiaconfermata == false && verificaanomalia == false && controlloeffettuato == true) {

    startingTimePIOGGIA = millis();

    statoverificapioggia = true;

    sogliapioggia = misurazione;

  }

  if (statoverificapioggia == true && ((millis() - startingTimePIOGGIA) < TIMEOUTPIOGGIA)) {

    if (verificaanomalia == false) {

      if (misurazione <= (sogliapioggia - ((sogliapioggia * 10) / 100))) {

        pioggiaconfermata = true;

        Serial.println("pioggiaconfermata");

        Serial.println(pioggiaconfermata);

        statoverificapioggia = false;

        sogliapioggia = 0;

      }

    }

  }

  if (statoverificapioggia == true  && ((millis() - startingTimePIOGGIA) > TIMEOUTPIOGGIA)) {

    if (verificaanomalia == false) {

      if (misurazione >= sogliapioggia) {

        pioggiaconfermata = false;

        statoverificapioggia = false;

        sogliapioggia = 0;

      }

    }

  }

  if (statoverificapioggia == true  && ((millis() - startingTimePIOGGIA) > TIMEOUTPIOGGIA)) {

    if (verificaanomalia == false) {

      if (misurazione < sogliapioggia) {

        pioggiaconfermata = true;

        statoverificapioggia = false;

        sogliapioggia = 0;

      }

    }

  }

  if (pioggiaconfermata == true && misurazione >= 700) {

    pioggiaconfermata = false;

  }



  if (bloccoattivato == false) {

    if (pioggia1 == true && pioggia2 == false) {  // seconda memorizzazione

      pioggia_2 = misurazione;

      Serial.println("pioggia_2");

      Serial.println(pioggia_2);

      pioggia2 = true;

    }

  }

  if (bloccoattivato == false) {

    if (pioggia1 == false && pioggia2 == false) {      // prima memorizzazione

      controlloeffettuato = false;

      Serial.println("controlloeffettuato");

      Serial.println(controlloeffettuato);

      pioggia_1 = misurazione;

      Serial.println("pioggia_1");

      Serial.println(pioggia_1);

      pioggia1 = true;

    }

  }

Posso farti alcune domande per chiarire alcuni punti?
Perchè mi sa che c’è un bel po’ di confusione, spero solo nella mia testa.

  1. Il sensore pioggia lo hai autocostruito tu. Avrai costruito un partitore di tensione con una resistenza nota e il tuo sensore varierà la sua resistenza a seconda di quanto è bagnato. La lettura la fai ai capi del tuo sensore o della resistenza? In altre parole valore alto = bagnato o asciutto? Le letture vanno effettivamente da 0 a 1023? o il range è più limitato? Quali sono valori tipici di asciutto? e quali valori tipici da pioggia? magari rovesciandoci sopra un bicchiere d’acqua, senza dover aspettare lo scravasso.

  2. Che distanza di tempo passa tra la prima lettura e la seconda? nanosecondi, secondi, minuti…?

  3. Presumo che questo aggeggio serva a ritrarre una tenda quando piove, quindi la funzione primaria dovrebbe essere identificare la pioggia, non la verifica del corretto funzionamento dei sensori che dovrebbe assumere valenza marginale.
    Nel codice dovrebbe essere ben definita la funzione primaria e isolata quella di check dei sensori, da quel che ho visto pare il contrario.

  4. C’è anche un sensore per il vento? perchè il problema maggiore per le tende è il vento.

  5. Il passaggio di stato da asciutto a lento potrebbe essere molto rapido, il contrario sicuramente è più lento.
    Una grossa goccia può bagnare il sensore facendolo variare istantaneamente di molto, mentre l’asciugatura sarebbe sicuramente più graduale.

  6. Il mio buonsenso (che potrebbe sbagliarsi) mi dice che una variazione meteorologica potrebbe produrre delta elevati in poco tempo, un malfunzionamento del sensore magari no. L’ossidazione è un processo lento.
    Magari avrebbe più senso testare certe condizioni border line non raggiungibili con la normale pioggia, ad es. un corto del sensore che fa scattare la lettura a fondo scala, cosa mai raggiunta normalmente.

  7. Per risolvere il problema di affidabilità del sensore, non è meglio metterne 2? Se uno segna gran secco e l’altro diluvio universale per più di tot tempo, forse uno dei due ha dei problemi.

  8. Quanto grande è il sensore? una goccia lo può bagnare tutto o serve una secchiata d’acqua per farlo?
    In altre parole, quanto sensibile è? Si riesce in base alle letture a ricavare, in modo ovviamente approssimativo, l’entità della pioggia?

Se la confusione è solo nella mia testa allora soddisferò solo una mia curiosità, se non lo è magari avrebbe senso ripartire da zero con le considerazioni alla base dell’intero progetto.

Lo spunto per quest’ultima ipotesi mi è venuto da questo:

simosere:
nel frattempo ho aggiunto una parte di ragionamento che non ho considerato nel ragionamento del codice sopra, ovvero che se comincia a piovere a goccioloni, siamo proprio sicuri che il valore analogico del sensore non passa magari da 1023 ad esempio a 700… umh…

ecco le risposte sotto:

per completezza di informazioni in questo momento sto usando solo questo controllo e mi ha salvato da un falso positivo… quello postato precedentemente è l’evoluzione con il controllo del funzionamento del sensore

controllaPIOGGIA();
if (misurazione < 700 && statoverificapioggia == false && pioggiaconfermata == false) {
  startingTimePIOGGIA = millis();
  statoverificapioggia = true;
  sogliapioggia = misurazione;
}
if (statoverificapioggia == true && ((millis() - startingTimePIOGGIA) < TIMEOUTPIOGGIA)) {
  if (misurazione <= (sogliapioggia - ((sogliapioggia * 10) / 100))) {
    pioggiaconfermata = true;
    statoverificapioggia = false;
    sogliapioggia = 0;
  }
}
if (statoverificapioggia == true && ((millis() - startingTimePIOGGIA) > TIMEOUTPIOGGIA)) {
  if (misurazione > sogliapioggia) {
    pioggiaconfermata = false;
    statoverificapioggia = false;
    sogliapioggia = 0;
  }
}
if (statoverificapioggia == true && ((millis() - startingTimePIOGGIA) > TIMEOUTPIOGGIA)) {
  if (misurazione <= sogliapioggia) {
    pioggiaconfermata = true;
    statoverificapioggia = false;
    sogliapioggia = 0;
  }
}
if (pioggiaconfermata == true && misurazione >= 700) {
  pioggiaconfermata = false;
}

maubarzi:
Posso farti alcune domande per chiarire alcuni punti?
Perchè mi sa che c’è un bel po’ di confusione, spero solo nella mia testa.

  1. Il sensore pioggia lo hai autocostruito tu. Avrai costruito un partitore di tensione con una resistenza nota e il tuo sensore varierà la sua resistenza a seconda di quanto è bagnato. La lettura la fai ai capi del tuo sensore o della resistenza? In altre parole valore alto = bagnato o asciutto? Le letture vanno effettivamente da 0 a 1023? o il range è più limitato? Quali sono valori tipici di asciutto? e quali valori tipici da pioggia? magari rovesciandoci sopra un bicchiere d’acqua, senza dover aspettare lo scravasso.

si il sensore è autocostruito con acciaio inox e uso questa schedina per comandarla(quella di fianco al sensore a pettine) https://www.dx.com/p/diy-raindrop-sensor-hl-01-module-w-jumper-wire-for-arduino-2052816#.XEtfiWl7nJg
bagnato = valori bassi
asciutto = valori alti
**le letture vanno da 999/1005 e il massimo che mi è arrivato con pioggia reale è sui 350 , le tende mi si chiudono se il valore raggiunge 600(mi chiude due tende e si riaaprone a 900) e 400(mi chiude la terza e si riapre a 850) **
i valori dipici sono intorno a 500-700 con pioggia normale
350-500 con nubifragio

  1. Che distanza di tempo passa tra la prima lettura e la seconda? nanosecondi, secondi, minuti…?

onestamente non ho pensato a misurarli,non saprei nemmeno come fare… parliamo cmq di nanosecondi… le misure sono veloci…

  1. Presumo che questo aggeggio serva a ritrarre una tenda quando piove, quindi la funzione primaria dovrebbe essere identificare la pioggia, non la verifica del corretto funzionamento dei sensori che dovrebbe assumere valenza marginale.
    Nel codice dovrebbe essere ben definita la funzione primaria e isolata quella di check dei sensori, da quel che ho visto pare il contrario.

questo sensore serve a srotolare delle tende per la pioggia per proteggermi il terrazzo, ma capita spesso che la signora di sopra tra piante annaffiate e schizzi mentre lava il terrazzo mi mandi l’acqua sul terrazzo, quindi mi serve qualcosa che mi escludi i falsi positivi…
per il controllo dei sensori potrei anche essere d’accordo… ma il motivo per cui ho fatto cosi è perchè se il sensore impazzisce improvvisamente per ossidazione,mi successe con il sensore che ho postato sopra(molto economico) le tende non mi si devono chiudere o aprire x volte prima di identificare il problema…

  1. C’è anche un sensore per il vento? perchè il problema maggiore per le tende è il vento.

si vento pioggia e temperatura con anche la temperatura percepita(nel terrazzo ci sono piante che vanno protette dal freddo e vento forte)

  1. Il passaggio di stato da asciutto a lento potrebbe essere molto rapido, il contrario sicuramente è più lento.
    Una grossa goccia può bagnare il sensore facendolo variare istantaneamente di molto, mentre l’asciugatura sarebbe sicuramente più graduale.

si è cosi come dici, dipende ovviamente da quanto piove e l’asciugatura dal vento e temperatura

  1. Il mio buonsenso (che potrebbe sbagliarsi) mi dice che una variazione meteorologica potrebbe produrre delta elevati in poco tempo, un malfunzionamento del sensore magari no. L’ossidazione è un processo lento.
    Magari avrebbe più senso testare certe condizioni border line non raggiungibili con la normale pioggia, ad es. un corto del sensore che fa scattare la lettura a fondo scala, cosa mai raggiunta normalmente.

l’unica esperienza che ho avuto con il malfunzionamento del sensore pioggia è questo:
pioveva veramente con valori intorno a 500, tende quindi chiuse a proteggermi, improvvisamente il valore saliva a 1023, quindi le tende mi si riaprivano per poi tornare nuovamente a valori intorno a 500 e quindi le tende mi si richiudevano…
mentre finora delta elevati a partire da zero pioggia a nubifragio improvviso non ho avuto modo di rilevari… o meglio non ero presente quando sono successi

  1. Per risolvere il problema di affidabilità del sensore, non è meglio metterne 2? Se uno segna gran secco e l’altro diluvio universale per più di tot tempo, forse uno dei due ha dei problemi.

ci ho pensato anche io… ma la vicina sopra sta sempre li… e potrebbe bagnarmi entrambi i sensori…

  1. Quanto grande è il sensore? una goccia lo può bagnare tutto o serve una secchiata d’acqua per farlo?
    In altre parole, quanto sensibile è? Si riesce in base alle letture a ricavare, in modo ovviamente approssimativo, l’entità della pioggia?

il sensore è 6x4 cm. una goccia non lo bagna quindi tutto. e risponde bene alla pioggia… per esempio se comincia a piovere pian piano per poi aumentare, il valore analogico diminuisce in maniera sensata rispetto all’intensità della pioggia reale.

Se la confusione è solo nella mia testa allora soddisferò solo una mia curiosità, se non lo è magari avrebbe senso ripartire da zero con le considerazioni alla base dell’intero progetto.

Lo spunto per quest’ultima ipotesi mi è venuto da questo:

Ok, allora procedo con le mie considerazioni:

Secondo me è importante distinguere tra bagnatura e asciugatura.
In modo da riconoscere anomalie che possono essere diverse nei due casi.

La discesa del valore può essere rapida, l'ascesa no.
Quindi se hai un'asciugatura rapida, è probabile che sia un'anomalia.

La lettura, io la farei su base statistica per evitare problemi puntuali di qualunque natura. Una foglia che si poggia sul sensore mandandolo in corto, un disturbo elettrico che sfalsa una singola lettura, ecc.
Ad es. una lettura al secondo per 5 volte per vedere se c'è un trend. Puoi scartare una lettura troppo distante dalla media ma subito corretta.

Non credo che la reattività delle tende debba essere troppo alta, cioè non deve funzionare come un airbag.
Quindi qualche secondo per decidere se chiudere le tende te lo puoi prendere.
L'apertura invece la farei dopo un periodo decisamente più lungo, anche 10 minuti o più, per evitare un apri/chiudi impazzito.
Male che vada hai una chiusura temporanea per un quarto d'ora nel caso di falso positivo.

Se i sensori li metti sullo stesso lato ma distanziati, e se ne bagna prima uno in modo rilevante e poi dopo qualche secondo l'altro, sempre in modo rilevante, potrebbe essere la vicina che lava. Difficile che uno scroscio improvviso interessi i due sensori in tempi diversi. Devono essere sullo stesso lato e con la stessa esposizione, altrimenti il ragionamento non vale.
Nei casi dubbi puoi prenderti qualche secondo di analisi in più per verificare meglio le condizioni prima di chiudere la tenda.
In genere uno scroscio improvviso è anche accompagnato da nuvolo e vento, quindi triangolando con una fotoresistenza per la luminosità e con il sensore vento dovresti poter individuare il caso.

Ovvio che hai una situazione complessa da gestire e quindi la soluzione da adottare non può essere banale.
Devi distinguere tra pioggia, vicina e malfunzionamenti.
Più riesci a triangolare i valori e più affidabile dovrebbe risultare il sistema.
La perfezione però, penso sia impossibile da raggiungere.
Però si può lavorare per mitigare i vari problemi.

La chiave, secondo me, è di interpretare le variazioni in un certo lasso di tempo per associare certi comportamenti ai giusti fenomeni che li possono aver causati.
E dare delle temporizzazioni di intervento che abbiano un senso logico e ponderato e un effetto accettabile.
Come ad es. quanto suggerito prima, cioè di non riaprire le tende prima che sia trascorso un certo numero di minuti dalla chiusura.

Queste le mie considerazioni.
Ti ho messo un po' di pulci all'orecchio?
Poi ci si può concentrare sulle cose che ti sembrano più sensate/percorribili e pattumare le altre.

Grazie mille per i consigli...

Ti spiego ora come é il funzionamento completo...

Le tende piu grandi si chiudono con valori di pioggia inf di 600... vento maggiore di 14km/h e con temp reale o percepita inf a 8 gradi

La tenda piccola si chiude con valori di pioggia inf di 400 con vento di 25 km/h e con temp reale o percepita inf a 6 gradi

Una volta chiuse per una di queste condizioni le tende rimangono chiuse per 25 minuti a prescindere delle condizioni esterne... quindi se il vento si placa ad esempio... sempre chiuse rimangono... questo vale solo per vento e temperatura...

Mentre le tende sono chiuse ogni qualvolta il vento e la temp raggiungono delle soglie leggermente più basse di quelle dette prima il timer dei 25 minuti so riavvia... in pratica per riaprirsi devono passare 25 minuti senza mai superare la soglia inpostata.

Per la pioggia invece passati i 25 minuti le tende si riaprono solo se il valore analogico del sensore raggiunge 850 perla tenda piccola e 900 per le grandi.

Questo al momento il funzionamento di massima...

Quello che cmq penso è che al di là del modo con cui verificare le tre varianti... (pioggia reale, vicina o malfunzionamento) il controllo vada fatto a prescindere prima del rilevamento del valore del sensore e interpretato prima in maniera che la logica sia in grado di prevedere prima di chiudure le tende per un falso positivo o un malfunzionamento.

Il codice che ho postato con la differenza delle letture tra un loop e l'altro sulle prove da banco ha sempre identificato correttamente quando gli creavo dei falsi positivi oppure dei finti malfunzionamenti... magari è sicuramente migliorabile,anzi certamente... ma sta facendo il suo lavoro...quello che però nn ho capito..

Scusate sono con il cell... ma quando mi dici:

Nel codice dovrebbe essere ben definita la funzione primaria e isolata quella di check dei sensori, da quel che ho visto pare il contrario.

Secondo me deve essere il contrario il check del sensore e lo stabilire se si tratta di una pioggia vera o altro deve essere per forza fatto prima della funzikne primaria... non voglio che mi srotoli prima le tende e poi capisca che è un falso positivo...

Grazie per i preziosi consigli

simosere:
Scusate sono con il cell... ma quando mi dici:

Nel codice dovrebbe essere ben definita la funzione primaria e isolata quella di check dei sensori, da quel che ho visto pare il contrario.

Quello che dici è corretto, non intendevo questo.
Semplicemente all'inizio hai postato solo il codice di questa parte che gestisce queste eccezioni, mancava tutta la parte che faceva il lavoro "normale", pareva che il codice girasse tutto attorno a questa.

Io non avevo minimamente capito che avevi già gestito tutto il resto nel modo che hai descritto negli ultimi due tuoi post e che è in linea con il 90% delle mie domande.

A questo punto, il ragionamento da fare è sulla mera descrizione delle varie condizioni che puoi incontrare (andamento delle letture dei vari sensori) e cercare un modo per distinguere se si tratta di una condizione reale o di una condizione anomala.
Una sorta di tavola della verità, un po' come si fa nella logica digitale.