Sensore vento/luce domotica

Ciao, ho inserito nel mio sketch un altro sketch trovato sul web che mi dia la possibilità di controllare la velocità del vento. Quello realizzato da me mi controlla la luminosità gestendo varie condizioni e scrivendole sul monitor seriale. Ora volevo inserire uno sketch per il controllo del vento ma i dati mi arrivano sporadici. Perchè ?

Questo è il programma completo, le due parti racchiuse tra gli asterischi sono lo sketch per il controllo vento che ho inserito.

int alzadx = 2;      // imposta il pin 2 alza tenda destra
int abbassadx = 3;   // imposta il pin 3 abbassa tenda destra
int alzasx = 4;      // imposta il pin 4 alza tenda sinistra
int abbassasx = 5;   // imposta il pin 5 abbassa tenda sinistra
boolean statoingresso = false;
boolean statocucina = false;
boolean statopioggia = false;
const int sensorValueingresso = 100;  //imposta il valore del sensore 970
const int sensorValuecucina = 108; // 1000
//const int sensorValuepioggia = 600;
String readString;
//********************************************************************************************
//BLOCCO CONTROLLO VELOCITA' DEL VENTO 
const float Pi = 3.141593; // Pigreco
const float raggio = 0.06; // raggio dell'anemometro in metri
const int reedPin = 2; // pin assegnato al contatto reed
int Statoreed = 0; // variabile per la lettura del contatto 
int Statoreed_old = 0; // variabile per evitare doppio conteggio
int Conteggio = 0;// variabile che contiene il conteggio delle pulsazioni
unsigned long int TempoStart = 0; // memorizza i  millisecondi dalla prima pulsazione conteggiata
unsigned long int Tempo = 0; // per conteggiare il tempo trascorso dalla prma pulsazione
unsigned long int TempoMax = 2000;// numero di millisecondi (2 seondi)
                  //per azzerare il conteggio e calcolare la Velocità
                  // così non si conteggiano brevi folate di vento
//********************************************************************************************
void setup() {
  Serial.begin(9600);
  pinMode(reedPin, INPUT);// mette in ascolto del reed il pin 2  pinMode(alzadx, OUTPUT);
  pinMode(abbassadx, OUTPUT);
  digitalWrite(alzadx, HIGH);
  digitalWrite(abbassadx, HIGH);
  pinMode(alzasx, OUTPUT);
  pinMode(abbassasx, OUTPUT);
  digitalWrite(alzasx, HIGH);
  digitalWrite(abbassasx, HIGH);
}

void loop() {

//CONTROLLO VELOCITA'
//***************************************************************************************
 Statoreed = digitalRead(reedPin); // legge il contatto reed
  if (Statoreed != Statoreed_old){// si verifica se è cambiato
      Statoreed_old = Statoreed;   // se SI si aggiorna lo stato
     if (Statoreed == HIGH){ // si controlla SE è alto ( passaggio magnete)
     if (Conteggio == 0){ TempoStart =  millis();} // se E' il primo passaggio si memorizza il tempo di partenza
      Conteggio = Conteggio + 1; // si aggiorna il contatore     
      Tempo = ( millis() - TempoStart); // si conteggia il tempo trascorso dallo start conteggio
      if (Tempo >=  TempoMax) {  // se il tempo trascorso è maggiore o uguale al tempo impostato si eseguono i calcoli e la stampa della velocità
           float deltaTempo = ( Tempo/1000.0); // si trasforma in secondi
           float Kmora = (3.6*Conteggio*Pi*raggio)/deltaTempo; //formula per il calcolo della velocità in Km/h
      
           Serial.print("Velocità Km/h = ");
           Serial.println(Kmora);
           Conteggio = 0; // azzeriamo il conteggio per nuova lettura
           delay(500);// attesa per altra lettura         
          }}}
//******************************************************************************************************

 // CONTROLLA SE PIOVE ALZA TUTTE LE TENDE 
/*  int sensorepioggia = analogRead (A2); 
  Serial.println(sensorepioggia);
  delay(1000);
  if (sensorepioggia < sensorValuepioggia) {  
    if (statopioggia == false) {
      delay(4000);
      Serial.println("C987789");
      delay(1000);
      digitalWrite(alzadx, LOW);
      digitalWrite(alzasx, LOW);
      delay(40000);
      digitalWrite(alzadx, HIGH);
      digitalWrite(alzasx, HIGH); 
      statopioggia = true;
      delay(4000);
    }  
  }
  if (sensorepioggia > sensorValuepioggia){
    statopioggia = false;
  }*/

  // CONTROLLA LA LUMINOSITà ESTERNA SE è NOTTE ALZA LE TENDE INGRESSO 
  int sensoringresso = analogRead(A4); // A0
    Serial.println(sensoringresso);
    delay(4000);
  if (sensoringresso < sensorValueingresso) {  
    if (statoingresso == false) {
      delay(1000);
      Serial.println("987789");
      delay(1000);
      digitalWrite(alzadx, LOW);
      digitalWrite(alzasx, LOW);
      delay(40000);//40000
      digitalWrite(alzadx, HIGH);
      digitalWrite(alzasx, HIGH); 
      statoingresso = true;
      delay(4000);
    }  
  }
  if (sensoringresso > sensorValueingresso){
    statoingresso = false;
  }
  
  // CONTROLLA LA LUMINOSITà ESTERNA SE è NOTTE ALZA LE TENDE CUCINA
  if (sensoringresso < sensorValuecucina) {  
    if (statocucina == false) {
      delay(1000);
      Serial.println("987789");// questo numero è inviato al tablet in seriale che lo idendifica mandando il 
                               // segnale alle tende in cucina di alzare
      delay(1000);
      statocucina = true;
      delay(4000);
    }  

  }
  if (sensoringresso > sensorValuecucina){
    statocucina = false;
  }  

  while (Serial.available()) {
    delay(3);  
    char c = Serial.read();
    readString += c;
  }
  if (readString.length() >0) {
    Serial.println(readString);
    if (readString == "ALZATENDAINGRESSO")     
    {
      digitalWrite(alzadx, LOW);
      digitalWrite(alzasx, LOW);
      delay(40000);//40000
      digitalWrite(alzadx, HIGH);
      digitalWrite(alzasx, HIGH);
    }
    
  // controlla la condizione se si possono abbassare le tende
  if (readString == "ABBASSATENDAINGRESSO" && sensoringresso <= 990 ){//990 è il controllo che se le due condizioni sono vere
                                                                       // abbassa le tende
      delay(2000);
      Serial.println("118");// codice in cui il tablet avvisa che le tende non si possono abbassare per scarsa luminosità
                            // esterna
  }

  if (readString == "ABBASSATENDAINGRESSO" && sensoringresso >= 995){//995
    digitalWrite(abbassadx, LOW);
    digitalWrite(abbassasx, LOW);
    delay(40000);//40000
    digitalWrite(abbassadx, HIGH);
    digitalWrite(abbassasx, HIGH);
  }
    if (readString == "ALZATENDATUTTO"){
      Serial.println("987789");
      delay(2000);
      digitalWrite(alzadx, LOW);
      digitalWrite(alzasx, LOW);
      delay(40000); //40000
      digitalWrite(alzadx, HIGH);
      digitalWrite(alzasx, HIGH); 
    }
    if (readString == "ABBASSATENDATUTTO" && sensoringresso >= 1000 ){//1000
      Serial.println("997997");
      delay(2000);
      digitalWrite(abbassadx, LOW);
      digitalWrite(abbassasx, LOW);
      delay(40000);//40000
      digitalWrite(abbassadx, HIGH);
      digitalWrite(abbassasx, HIGH);
    }
    if (readString == "ABBASSATENDATUTTO" && sensoringresso <= 1000 )//1000
    {
      Serial.println("119");
    }
    readString="";
  }
}

Il tuo sketch è pieno zeppo di delay che bloccano il proseguirsi del programma. La fusione di due sketch può essere un impresa ardua, in molti casi conviene quasi riscrivere tutto da zero.
Esistono però degli approcci ponderati per sviluppare un software di controllo di un MCU che debba svolgere diverse funzioni.
Non esiste un sistema unico che funziona sempre, ma suddividere il programma in step fondamentali può essere una buona base di partenza.
Un esempio, ho 3 sensori generici, 2 servo motori inoltre ho una connessione seriale su cui inviare i dati raw dei sensori.
Posso pensare di scrivere 3 routine per la raccolta dati, ognuna si occuperà di leggere dati da un singolo sensore e salvarli nella memoria di Arduino, una routine di aggiornamento dei servi e una per l’invio dei dati via seriale. Se questa fase preliminare non ha presentato particolari problemi posso dedicarmi alla fase di scheduling, ovvero compiere manualmente il lavoro che fa uno sheduler su un normale PC, non so se hai presente, il computer può fare solo un operazione alla volta, ma se è abbastanza veloce ed intelligente può farti credere di fare più cose contemporaneamente(furbacchione :grinning: ). Quindi inizio a far lavorare la testa e penso alle precedenze, inviare un dato prima di averlo acquisito non si puo fare, quindi sicuramente prima di richiamare la routine di invio dati dovrò eseguire le 3 routine dei sensori. Discorso simile per i servo, quindi inizio a delineare un grafo delle precedenze e un ordine preliminare.
-Leggo sensore 1
-Leggo sensore 2
-Leggo sensore 3
-Aggiorno i servi
-Invio i dati
Poi ci penso su e riflettendo sul sensore 1 che è un NTC, rispetto agli altri due sensori che sono sensori di prossimità capisco che un aggiornamento dei dati alla medesima velocità ha poco senso, quindi posso dire, i sensori 2 e 3 si aggiornano ogni ciclo di loop, il sensore 1 solo ogni 4 cicli. Posso fare anche un confronto tra i servi e l’invio dei dati. Magari l’invio dei dati è solo di debug, invece l’aggiornamento dei servi è un controllo attivo, quindi potrei dire, i servi li aggiorno ad ogni ciclo, i dati li invio ogni 10(tanto io sono lento a leggerli).
Cosi ho delineato una schedulazione soddisfacente e sensata. Vorrei farti notare una cosa, non ho mai parlato di aspettare, generalmente tutte le operazioni che eseguo dovrebbero occupare il micro il minor tempo possibile, cosi da farci credere che sappia fare piu cose contemporaneamente. I delay sono il male, impara a lavorare con la funzione mills(), che permette di sviluppare sistemi di timing non bloccanti.
Spero di esserti stato utile.

generalmente tutte le operazioni che eseguo dovrebbero occupare il micro il minor tempo possibile, cosi da farci credere che sappia fare piu cose contemporaneamente. I delay sono il male, impara a lavorare con la funzione mills(), che permette di sviluppare sistemi di timing non bloccanti.

Non potevi essere più chiaro, a prescindere dal millis che anche lui fa perdere cicli macchina, il micro va spremuto al massimo anche 1 ciclo clock è importante.

Grazie mille, Si lo so che lo sketch è pieno di delay(); ma sinceramente il lavoro che deve fare lo fa molto bene e non sbaglia un dato. E da quando ho inserito il tutto sulle tende non mi preoccupo più di alzare e abbassare, fa tutto lui. Il tablet e arduino comunicano alla perfezione " per il momento :slight_smile: " Ora Tornando alla tua risposta Roberto, non ti offendere ma per me è fantascienza quello che dici materiale per la NASA. Io uso arduino per divertirmi non sono un programmatore esperto, più delle volte prendo spunti da altri sketch li studio e li adatto ai miei progetti, penso come fanno tutti o la magior parte delle persone che sono sul Forum, lo seguo molto lo leggo perchè prendo spunti. Chi lo gestisce fa un grande lavoro complimenti.
A me servirebbe un aiuto nel senso cosa devo modificare o cambiare nello skecth per poterlo far funzionare. Avvolte nell'attesa delle risposte riesco da solo.
Comunque Grazie ancora e scusa se ti sei in qualche modo offeso non era nelle mie intenzioni, era solo per spiegarti come uso Arduino.

Prima di tutto c'è un errore: il reedPin è assegnato al pin 2 che però è già assegnato a alzadx.

Tra l'altro, il primo è di INPUT ed il secondo è di OUTPUT!

A parte questo, non funzionerà a meno che tu non usi lo external interrupt.

Infatti, a causa di tutti ritardi presenti, c'è il rischio che l'impulso reed non sia letto poiché il processore è impegnato in un'altra parte della routine di loop.

Lo external interrupt funziona per la UNO solo con il pin 2 e 3, quindi assegna il pin 2 (od il 3) al reedPin e alzadx ad altro pin.

Grazie mille. Si l’errore del pin l’ho visto stamattina e l’ho corretto. Cavolo ero convito che external interrupt funzionasse su tutte le Board Arduino. Sto usando una NANO, ma se tu mi dici che devo usare la UNO allora cambio la scheda. In effetti i test prima del montaggio li faccio con una MEGA e poi trasferisco i sketch sulle varie board.
Provo subito la modifica e ti faccio sapere.
Ancora grazie mille.

La NANO funziona con gli stessi pin della UNO (2 e 3), mentre per la MEGA puoi usare i pin 2, 3, 18, 19, 20, 21:

https://www.arduino.cc/en/Reference/AttachInterrupt

Ho provato a modificare e fare varie prove, ma sempre stessa situazione. Come si nota nell’immagine i dati alla seriale mi vengono inseriti in tempi differenti. Mentre i valori luce e acqua sono continui. Quello che vorrei che i valori mi vengano visualizzati in sequenza, LUCE-ACQUA-VENTO. LUCE-ACQUA-VENTO. e cosi via.
Continuo a fare delle prove. Ho notato che anche se separo solo lo sketch del vento alla seriale i dati mi vengono inviati in tempi sfalsati.

Ma hai modificato lo sketch usando l'external interrupt?

Non ancora, sto cercando di capire come inserirlo nello sketch. Sto leggendo alcuni esempi. Ho visto un esempio che accende e spegne dei LED in sequenza e con un interruttore nello stesso tempo accende un altro LED. vorrei inserire questo esempio.

nulla ho provato a inserirlo.

void loop() {
interrCount++;
//CONTROLLO VELOCITA'
//***************************************************************************************
 
 if (interrCount == 3);{
 Statoreed = digitalRead(reedPin); // legge il contatto reed
  
  if (Statoreed != Statoreed_old){// si verifica se è cambiato
      Statoreed_old = Statoreed;   // se SI si aggiorna lo stato
     if (Statoreed == HIGH){ // si controlla SE è alto ( passaggio magnete)
        if (Conteggio == 0){ TempoStart =  millis();} // se E' il primo passaggio si memorizza il tempo di partenza
            Conteggio = Conteggio + 1; // si aggiorna il contatore     
            Tempo = ( millis() - TempoStart); // si conteggia il tempo trascorso dallo start conteggio
              if (Tempo >=  TempoMax) {  // se il tempo trascorso è maggiore o uguale al tempo impostato si eseguono i calcoli e la stampa della velocità
                 float  deltaTempo = ( Tempo/1000.0); // si trasforma in secondi
                 float  Kmora = (3.6*Conteggio*Pi*raggio)/deltaTempo; //formula per il calcolo della velocità in Km/h
      
           Serial.print("Velocità Km/h = ");
           Serial.println(Kmora);
           Conteggio = 0; // azzeriamo il conteggio per nuova lettura
           delay(500);// attesa per altra lettura         
  /*  if (Kmora > sensoreVento) {  
      if (statovento == false) {
      delay(1000);
      Serial.println("987789");
      delay(1000);
      digitalWrite(alzadx, LOW);
      digitalWrite(alzasx, LOW);
      delay(40000);//40000
      digitalWrite(alzadx, HIGH);
      digitalWrite(alzasx, HIGH); 
      statoingresso = true;
      delay(4000);
    }}
  if (Kmora < sensoreVento){
    statovento = false;
  }*/}}}}

Dopo tre letture Acqua-Luce non inserisce Vento. Anche tenendo l’anemometro sempre sotto vento. Nel mio caso forse è meglio che compro un anemometro con segnale Analogico, tipo che all’uscita mi dia una differenza di potenziale tipo una resistenza variabile, in modo che le pale più girano veloci e più è alta la resistenza. cosi forse ho una lettura più comoda da gestire e continua. ho letto un po di esempi su interrupt ma non vanno. Sicuramente sono io che non riesco a inserirlo nel mio sketch.
Grazie comunque, ho imparato un altra funzione che potrebbe servirmi su altri progetti.

Forse non hai ben compreso il funzionamento del external interrupt.

Innanzitutto devi dichiarare volatile la variabile contatore:

volatile int interrCount = 0;

Poi, in setup devi dichiarare il pin sottoposto ad interrupt indicando anche la modalità che desideri e la routine di interrupt:

pinMode(reedPin, INPUT_PULLUP);  // attiva pull up interno

attachInterrupt(digitalPinToInterrupt(reedPin), CONTA, FALLING);  // richiame routine CONTA quando il pin diventa LOW

La routine sarà

void CONTA() {
  interrCount ++;  // incrementa la variabile ad ogni impulso ricevuto
}

Nel loop dovrai controllare ogni secondo (oppure ogni 10 secondi nel caso di vento debole) il valore di interrCount, fare il calcolo della velocità del vento (Kmora) ed azzerare la variabile interrCount

lo sketch. Sicuramente sbaglio,

int alzadx = 6;      // imposta il pin 2 alza tenda destra
int abbassadx = 3;   // imposta il pin 3 abbassa tenda destra
int alzasx = 4;      // imposta il pin 4 alza tenda sinistra
int abbassasx = 5;   // imposta il pin 5 abbassa tenda sinistra
boolean statoingresso = false;
boolean statocucina = false;
boolean statopioggia = false;
const int sensorValueingresso = 100;  //imposta il valore del sensore 970
const int sensorValuecucina = 108; // 1000
const int sensorValuepioggia = 600;
volatile int interrCount =0;

String readString;
//********************************************************************************************
//BLOCCO CONTROLLO VELOCITA' DEL VENTO 
const float Pi = 3.141593; // Pigreco
const float raggio = 0.06; // raggio dell'anemometro in metri
const int reedPin = 2; // pin assegnato al contatto reed
int Statoreed = 0; // variabile per la lettura del contatto 
int Statoreed_old = 0; // variabile per evitare doppio conteggio
int Conteggio = 0;// variabile che contiene il conteggio delle pulsazioni
unsigned long int TempoStart = 0; // memorizza i  millisecondi dalla prima pulsazione conteggiata
unsigned long int Tempo = 0; // per conteggiare il tempo trascorso dalla prma pulsazione
unsigned long int TempoMax = 2000;// numero di millisecondi (2 seondi)
                  //per azzerare il conteggio e calcolare la Velocità
                  // così non si conteggiano brevi folate di vento
boolean statovento = false;
const int sensoreVento = 0.01;

void setup() {
  Serial.begin(9600);
  
  pinMode(reedPin, INPUT_PULLUP);// mette in ascolto del reed il pin 2  pinMode(alzadx, OUTPUT);
  attachInterrupt(digitalPinToInterrupt(reedPin), CONTA, FALLING);
 
 pinMode(abbassadx, OUTPUT);
  digitalWrite(alzadx, HIGH);
  digitalWrite(abbassadx, HIGH);
  pinMode(alzasx, OUTPUT);
  pinMode(abbassasx, OUTPUT);
  digitalWrite(alzasx, HIGH);
  digitalWrite(abbassasx, HIGH);
}
void CONTA(){
  interrCount ++;}
void loop() {

//CONTROLLO VELOCITA'

 
 if (interrCount == 3);{
 Statoreed = digitalRead(reedPin); // legge il contatto reed
  
  if (Statoreed != Statoreed_old){// si verifica se è cambiato
      Statoreed_old = Statoreed;   // se SI si aggiorna lo stato
     if (Statoreed == HIGH){ // si controlla SE è alto ( passaggio magnete)
        if (Conteggio == 0){ TempoStart =  millis();} // se E' il primo passaggio si memorizza il tempo di partenza
            Conteggio = Conteggio + 1; // si aggiorna il contatore     
            Tempo = ( millis() - TempoStart); // si conteggia il tempo trascorso dallo start conteggio
              if (Tempo >=  TempoMax) {  // se il tempo trascorso è maggiore o uguale al tempo impostato si eseguono i calcoli e la stampa della velocità
                 float  deltaTempo = ( Tempo/1000.0); // si trasforma in secondi
                 float  Kmora = (3.6*Conteggio*Pi*raggio)/deltaTempo; //formula per il calcolo della velocità in Km/h
      
           Serial.print("Velocità Km/h = ");
           Serial.println(Kmora);
           Conteggio = 0; // azzeriamo il conteggio per nuova lettura
           delay(500);// attesa per altra lettura         
  /*  if (Kmora > sensoreVento) {  
      if (statovento == false) {
      delay(1000);
      Serial.println("987789");
      delay(1000);
      digitalWrite(alzadx, LOW);
      digitalWrite(alzasx, LOW);
      delay(40000);//40000
      digitalWrite(alzadx, HIGH);
      digitalWrite(alzasx, HIGH); 
      statoingresso = true;
      delay(4000);
    }}
  if (Kmora < sensoreVento){
    statovento = false;
  }*/}}}}
         


 // CONTROLLA SE PIOVE ALZA TUTTE LE TENDE 
  int sensorepioggia = analogRead (A2); 
  Serial.println(sensorepioggia);
  delay(1000);
  if (sensorepioggia < sensorValuepioggia) {  
    if (statopioggia == false) {
      delay(4000);
      Serial.println("C987789");
      delay(1000);
      digitalWrite(alzadx, LOW);
      digitalWrite(alzasx, LOW);
      delay(40000);
      digitalWrite(alzadx, HIGH);
      digitalWrite(alzasx, HIGH); 
      statopioggia = true;
      delay(4000);
    }  
  }
  if (sensorepioggia > sensorValuepioggia){
    statopioggia = false;
  }

  // CONTROLLA LA LUMINOSITà ESTERNA SE è NOTTE ALZA LE TENDE INGRESSO 
  int sensoringresso = analogRead(A4); // A0
    Serial.println(sensoringresso);
  
    delay(4000);

   
  if (sensoringresso < sensorValueingresso) {  
    if (statoingresso == false) {
      delay(1000);
      Serial.println("987789");
      delay(1000);
      digitalWrite(alzadx, LOW);
      digitalWrite(alzasx, LOW);
      delay(40000);//40000
      digitalWrite(alzadx, HIGH);
      digitalWrite(alzasx, HIGH); 
      statoingresso = true;
      delay(4000);
    }  
  }
  if (sensoringresso > sensorValueingresso){
    statoingresso = false;
  }
  
  // CONTROLLA LA LUMINOSITà ESTERNA SE è NOTTE ALZA LE TENDE CUCINA
  if (sensoringresso < sensorValuecucina) {  
    if (statocucina == false) {
      delay(1000);
      Serial.println("987789");// questo numero è inviato al tablet in seriale che lo idendifica mandando il 
                               // segnale alle tende in cucina di alzare
      delay(1000);
      statocucina = true;
      delay(4000);
    }  

  }
  if (sensoringresso > sensorValuecucina){
    statocucina = false;
  }  

  while (Serial.available()) {
    delay(3);  
    char c = Serial.read();
    readString += c;
  }
  if (readString.length() >0) {
    Serial.println(readString);
    if (readString == "ALZATENDAINGRESSO")     
    {
      digitalWrite(alzadx, LOW);
      digitalWrite(alzasx, LOW);
      delay(40000);//40000
      digitalWrite(alzadx, HIGH);
      digitalWrite(alzasx, HIGH);
    }
    
  // controlla la condizione se si possono abbassare le tende
  if (readString == "ABBASSATENDAINGRESSO" && sensoringresso <= 990 ){//990 è il controllo che se le due condizioni sono vere
                                                                       // abbassa le tende
      delay(2000);
      Serial.println("118");// codice in cui il tablet avvisa che le tende non si possono abbassare per scarsa luminosità
                            // esterna
  }

  if (readString == "ABBASSATENDAINGRESSO" && sensoringresso >= 995){//995
    digitalWrite(abbassadx, LOW);
    digitalWrite(abbassasx, LOW);
    delay(40000);//40000
    digitalWrite(abbassadx, HIGH);
    digitalWrite(abbassasx, HIGH);
  }
    if (readString == "ALZATENDATUTTO"){
      Serial.println("987789");
      delay(2000);
      digitalWrite(alzadx, LOW);
      digitalWrite(alzasx, LOW);
      delay(40000); //40000
      digitalWrite(alzadx, HIGH);
      digitalWrite(alzasx, HIGH); 
    }
    if (readString == "ABBASSATENDATUTTO" && sensoringresso >= 1000 ){//1000
      Serial.println("997997");
      delay(2000);
      digitalWrite(abbassadx, LOW);
      digitalWrite(abbassasx, LOW);
      delay(40000);//40000
      digitalWrite(abbassadx, HIGH);
      digitalWrite(abbassasx, HIGH);
    }
    if (readString == "ABBASSATENDATUTTO" && sensoringresso <= 1000 )//1000
    {
      Serial.println("119");
    }
    readString="";
  }
}

error: ‘digitalPinToInterrupt’ cannot be used as a function

Sforzati di capire come funziona la tecnica con interrupt.

Lo sketch contiene ancora parti che non servono:

if (Statoreed != Statoreed_old){// si verifica se è cambiato
      Statoreed_old = Statoreed;   // se SI si aggiorna lo stato
     if (Statoreed == HIGH){ // si controlla SE è alto ( passaggio magnete)
...

Una Giornata per studiare e capire come fare ma alla fine ci sono riuscito.

const int reedPin  = 2;     // Pin sensore anemometro
const float VelocitaVento = 3000;
float Statoreed;
int Conteggio;

void setup() {
Serial.begin(9600);
  pinMode(reedPin, INPUT); 
}
void loop() {
     Statoreed = pulseIn(reedPin,HIGH);
    
     Conteggio = abs(250000000/Statoreed);
     Serial.print("ANEMOMETRO: ");
     Serial.println(Conteggio);
     // check Anemometro
     
     
 delay (2000);
}

Come lo volevo io, devo solo tarare il valore giusto in base a quando voglio far alzare le tende.
modificato da un esempio di un gioco e ora funziona per il mio anemometro.
Grazie mille per le tue risposte comunque.

Perché mai dovrei offendermi? Nessuno mi obbliga ad aiutare qualcuno su questo o altri forum, lo faccio perché mi piace condividere la mia esperienza, ogni tanto non mi dispiace spingermi un po' oltre e cercare di passare delle meccaniche di sviluppo serio(non uso volontariamente la parola professionale) qualche volta è apprezzato e rende il destinatario un po' più consapevole altre volte no, io non ci perdo mai nulla. :slight_smile:
Il discorso che porti avanti tu su "io ragiono cosi e molti altri sul forum fanno lo stesso", lo capisco a pieno, infatti un messaggio del genere non lo avrei mai scritto per una persona con 5 post in totale, che finito il weekend Arduino non lo vedrà per almeno 6 mesi. Non finirò mai di ripeterlo ma Arduino nell'essere una delle invenzioni più geniali ed eccezionali nate nel nostro paese ha fatto un danno enorme all'idea dello sviluppatore in MCU, dando la falsa idea che programmare microcontrollori sia una attività banale, cosa che assolutamente non è, anche nella semplice attività di fondere due applicativi.
Sono comunque contento che tu sia riuscito a risolvere il tuo problema :slight_smile:

grazie mille!! buona giornata

const int anemometro = 7; //anemometro collegato al pin 7 di arduino

int statoPrecedente; //variabile per memorizzare lo stato precedente letto dall'anemometro

unsigned long durata;
unsigned long startime;

float velocita;

void setup()
{
Serial.begin (9600);
pinMode (anemometro, INPUT);
}

void loop()
{
if(digitalRead (anemometro) == LOW)
{
statoPrecedente = 0;
}

if(digitalRead (anemometro) == 1 && statoPrecedente == 0)
{
durata = millis() - startime;
startime = millis();
delay(200);
}

velocita = 2500000.0/durata;
Serial.print ("km/h :");
Serial.println (velocita);
}

salve, nel forum sono una persona totalmente nuova ma anche nel campo arduino e vorrei molto ampliare le mie conoscenze =).
Qui sopra ho postato il mio sketch che ho provato a realizzare per calcolare la velocità del vento, osservando vari metodi su internet. Però come immaginate non funziona del tutto. Il problema avviene sopratutto in due casi:

  1. quando l'anemometro è fermo non mi stampa lo zero;
  2. l'anemometro raggiunto una certa velocità si blocca il suo valore (anche se non dovrebbe secondo me).
    Sicuramente ho sbagliato la modalità di calcolo ma non so dove. Mi potreste aiutare mi fareste un grande piacere, vi ringrazio e vi auguro una buona giornata!!.

Presentati nell'apposita sezione e leggi il regolamento:D