Elaborazione segnali Piezoelettrici

Salve a tutti, spero di non aver commesso errori per la giusta esposizione del topic..

Ho intrapreso l'avventura arduino da poco e nelle varie prove qualche risultato l'ho già ottenuto..

Vista la soddisfazione mi sono catapultato in un nuovo progetto che mi permetterebbe di effettuare una protezione anticamminamento nel giardino di casa di un mio amico..

L'idea è la seguente:

Linea di sensori piezoelettrici ( i classici dischetti ) denominata linea X;

Linea di sensori piezoelettrici denominata linea Y;

Potenziometro per regolare la sensibilità delle singole linee X e Y;

Potenziometro per regolare una soglia di intervento sotto la quale i segnali vengono considerati nulli;

Led di indicazione segnale valido sia per linea X che Y;

Led indicazione (Pin 13) di avvenuta lettura condizione AND ( X+Y)....

Fin qui tutto abbastanza semplice... Il codice che allego è una elaborazione del KNOCK di arduino...

Sicuramente i professori troveranno una miriade di errori ( ma va bene così ), però per il mio inizio la cosa soddisfacente è che funziona.. Esegue la lettura dei sensori, conta gli impulsi AND e al raggiungimento degli impulsi programmati visualizza la situazione di allarme...

Veniamo al problema che mi toglie il sonno da 4 giorni :wink:

Avrei la necessità di strutturare 2 casistiche...

1 - Al verificarsi di n.AND entro un tempo prestabilito ( es. 4 o 5 secondi ) ho la segnalazione di allarme.

2 - Se entro quel tempo prestabilito non ho il numero di AND necessario, il timer e il conteggio devono resettarsi ( questo per eliminare la possibilità di falsi allarmi con disturbi generici ).

Ho fatto varie prove cimentandomi anche con i millis(), ma non sono riuscito a levarne le gambe..

Qualcuno di Voi ha per caso qualche consiglio su come potermi muovere??

Ringrazio tutti..

Allego il codice:

const int ledPin = 13;      //dichiaro pin 13
const int knockSensor = A0;// piezo linea X su Analog 0
const int knockSensor1 = A1; // piezo linea Y su Analog 1
int pot = A5; // potenziometro  sens piezo linea X su Analog 5
int pot1 = A4; //  potenziometro  sens piezo linea Y su Analog 4
int threshold1;// potenziometro  soglia allarme linea X su Analog 4
int threshold;// potenziometro  soglia allarme linea Y su Analog 4
int x=12; // Uscita led conferma superamento soglia linea X
int y=4; // Uscita led conferma superamento soglia linea X
int conta=0; // variabile per contare gli eventi AND


int sensorReading = 0; // valore di partenza dei sensori piezo linea X
int sensorReading1 = 0; // valore di partenza dei sensori piezo linea Y



int ledx = LOW;// imposto il valore 0 al led conferma superamento soglia linea X
int ledy = LOW;// imposto il valore 0 al led conferma superamento soglia linea Y

void setup() {
 pinMode(ledPin, OUTPUT);// imposto l'uscita per il led allarme 
 pinMode(x,OUTPUT);// imposto l'uscita per il led linea X
 pinMode(y,OUTPUT);// imposto l'uscita per il led linea Y
}

void loop() {


  sensorReading = analogRead(knockSensor); //Imposto la variabile per l'entrata analogica per la linea piezoelettrica X
  sensorReading1 = analogRead(knockSensor1); //Imposto la variabile per l'entrata analogica per la linea piezoelettrica Y

   int threshold = analogRead(pot)  ;  //Imposto la variabile per l'entrata analogica per potenziometro linea X
   int threshold1 = analogRead(pot1)  ;  //Imposto la variabile per l'entrata analogica per potenziometro linea Y

// Se i sensori superano il valore di soglia i led segnalano il superamento
  if(sensorReading >= threshold) {
    digitalWrite (x,HIGH);}
    else { digitalWrite (x,LOW);}
  
  if(sensorReading1 >= threshold1) {
    digitalWrite (y,HIGH);}
    
    else{ digitalWrite (y,LOW);}

/* Qui arrivano le dolenti note....

  In pratica da qui inizia la parte dove dovrei leggere la condizione AND in un tempo determinato e se 
  la condizione di verifica nel tempo determinato visualizzo l'allarme; altrimenti azzero il conta come
  ho messo e rimetto in ascolto la scheda come se nulla fosse successo.
  il codice che segue mi permette di contare i 5 eventi AND e al sesto mi illumina per 2,5 secondi il led
  e resetta il contatore...
*/
  if ((sensorReading >= threshold)&&(sensorReading1 >= threshold1)) {
 
    digitalWrite(ledPin,HIGH);
    conta++;}
    else{digitalWrite(ledPin,LOW);}

  if (conta>5){
    digitalWrite(ledPin,HIGH);
    delay(2500);
    digitalWrite(ledPin,LOW);
    delay(500);
   conta=0;}
}

prova a riflettere su questa soluzione

   premillis = millis()
  while(sensorReading >= threshold && sensorReading1 >= threshold1 && stato == 1) 
  {
    if((millis() - premillis) > pausa)
    {
    digitalWrite(ledPin, HIGH); 
 stato = 0;  //per uscire dal while() 
    }
   }
   
   delay(500);
   digitalWrite(ledPin, LOW);
stato = 1 ;

stefa24:
prova a riflettere su questa soluzione

   premillis = millis()

while(sensorReading >= threshold && sensorReading1 >= threshold1 && stato == 1)
 {
   if((millis() - premillis) > pausa)
   {
   digitalWrite(ledPin, HIGH);
stato = 0;  //per uscire dal while()
   }
  }
 
  delay(500);
  digitalWrite(ledPin, LOW);
stato = 1 ;

Grazie mille per la risposta celerissima ALE...

Ci stò ragionando, ma praticamente sono in un loop mentale..

Vediamo se riesco a capirci qualcosa..

Con l'istruzione premillis = millis() si imposta un punto di riferimento nel tempo totale di millis....

L'istruzione While sostituisce il mio If se non ho capito male?

Successivamente faccio fare la sottrazione (dal tempo trascorso totale) del periodo che è intercorso dal premillis = millis e vado a controllare se è maggiore di pausa ( che ho impostato all'inizio così: unsigned long pausa=5000 ).

Se è maggiore di pausa allora eseguo le istruzioni successive relative al led..

Dimmi se qualcosa l'ho azzeccata!! Prima di proseguire nelle mie domande :slight_smile:

Grazie di nuovo..

si l'interpretazione è corretta, aggiungo che stato = 1 serve per uscire dal while(), inoltre dopo un delay(500) il led si spegne ma su questa parte bisogna riflettere, aggiungo questa discussione
http://forum.arduino.cc/index.php?topic=285940.0
nel post #1 ci sono dei link per lo studio di millis()

Buongiorno Stefa24...

Allora, i tutorial sui millis li ho spulciati rigo per rigo, ma da quello che sono riuscito a capire ( sicuramente sono Io limitato celebralmente he he he), non posso fare la funzione che mi occorre.. O meglio; ho provato ( sicuramente sbagliando ) ma non riesco ad avere una temporizzazione dall'inizio della prima condizione AND fino al 5° conteggio degli AND... Soprattutto no riesco a renderla ciclica, ovvero che si ripeta all'infinito al verificarsi della condizione AND; l'impianto quando viene inserito lavora anche per 2-3/7-8 mesi ininterrottamente, ed io riesco a malapena a fare un ciclo dopodichè non conteggio più..

Ho provato a mettere il riferimento del tempo prima dell'istruzione di AND ma niente.. addirittura mi salta il conteggio e mi da subito la condizione di allarme..

Da quello che ho capito nei tutorial dei millis che mi hai consigliato, utilizzando tali funzioni si avrà sempre una condizione ti tempo maggiore ai calcoli che si effettuano ( millis() - tempo_precedente > tempo_prestabilito )..

Io invece avrei bisogno della condizione ( se gli impulsi sono 5 nel tempo di x secondi, allora segnala l'allarme, altrimenti resetta il contatore degli impulsi anche se ne hai contati solo 2 ).

Accetto bacchettate sulle mani per le mie castronerie sia chiaro.. :slight_smile:

Chiedo venia ai Maestri, ma stò cercando di imparare sbagliando...

Grazie mille a tutti per l'interessamento e l'aiuto..

Io invece avrei bisogno della condizione ( se gli impulsi sono 5 nel tempo di x secondi, allora segnala l'allarme, altrimenti resetta il contatore degli impulsi anche se ne hai contati solo 2 ).

questo non lo avevo capito, quindi a te serve è un calcolo di frequenza se hai una frequenza di almeno 5 impulsi nel tempo che indichi tu allora scatta allarme se minore no, è corretto?

questo è un estratto di uno sketch di tempo fa:

...
if (statosensore1 == LOW)       
  {
switch(i)
{
case 0:
tempo[0] = millis();  //memorizzazione dell'istante di tempo
break;

case 4:
tempo[1] = millis();  //memorizzazione dell'istante di tempo
break;
}
   i++; //incremento del contatore
    if(i == 5)
    {
      freq[0] = 5 * 1000 / (tempo[1] - tempo[0]);//calcolo della frequenza
      i = 0;
      // Serial.println(freq[0]); //per debug
    }
    statosensore1 = HIGH;
  }

  deltatempo1 = millis() - tempo[1];  //tempo trascorso 
  //Serial.println(deltatempo1);
  if (deltatempo1 > 2000)
  {
    freq[0] = 0;  //azzeramento della frequenza dopo attesa di 2 sec
  }
...

stefa24:
questo non lo avevo capito, quindi a te serve è un calcolo di frequenza se hai una frequenza di almeno 5 impulsi nel tempo che indichi tu allora scatta allarme se minore no, è corretto?

Si Stefa...

Allora faccio un po' di chiarezza sul tipo di rilevazione e sulle funzioni che stò cercando di far lavorare:

Il sistema ha n-sensori collegati sulla linea analogica 0 e n-sensori collegati sulla linea analogica 1..

Normalmente i sensori rilevano segnali di ogni genere, dalla pioggia, al calpestio di qualche animale selvatico etc..

Nella normalità delle rilevazioni si possono verificare 1 o 2 o 3 condizioni AND in un arco di tempo prestabilito ( solitamente da 4 a 8 secondi )e poi niente altro.. In quel caso il sistema resetta il numero conteggiato e si rimette in ascolto..

Nel caso invece che le rilevazioni arrivino ad un conteggio impostabile da utente ( sempre tramite potenziometro o dipswitch.... fuzione che ancora non ho affrontato ) e che comunque nelle mie domande precedenti era impostato a 5 sempre nel tempo prestabilito in programmazione i soliti ( da 4 a 8 secondi ), allora ho l'accensione del led 13 nonchè la segnalazione di allarme su una uscita. Dopo tale allarme si azzera nuovamente il conteggio e si riparte da capo..

Stasera provo il codice che mi hai inserito e vediamo se riesco a fare qualche passo in più... Ti aggiorno con i risultati..

Grazie ancora Stefa...

Buona serata!

calcolare una frequenza può quindi essere una soluzione, numero di impulsi/tempo= frequenza, se frequenza maggiore di... fai qualcosa se no fai altro

Si Stefa, potrebbe essere valida... Mi metto a lavorare sul codice che mi hai passato e vediamo cosa riesco a tirar fuori... ti riaggiorno con i risultati..

Un piacere, se ti è possibile...

potresti passarmi ( se non è un problema sia chiaro ), il link del codice completo da dove hai estrapolato quello precedente??

Magari leggendolo e vedendo cosa fa riesco a tirar fuori qualcosa per il mio..

Grazie mille ancora Stefa...

A prestissimo

in questo codice utilizzo l'interrupt

/*
modifica del 20130525 ottimizzazione dell'uso del vettore tempo
versione con interrupt, per due elementi e 1 solo shiftout

//#include <LiquidCrystal.h>  // include the library code
//LiquidCrystal lcd(9,8,7,6,5,4); // initialize the library with the numbers of the interface pins
//int sensorPin_max=A0;    // select the input pin for the potentiometer
//  int sensorPin_min=A1;    // select the input pin for the potentiometer
*/
//shiftout
#define dataPinOUT 5  //DS di 74HC595  pin 14
#define clockPinOUT 6  //SH_CP di 74HC595 pin 11
#define latchPinOUT 7  //ST_CP di 74HC595 pin 12

float Fmax=20.0;  //frequenza massima di lavoro
float Fmin=1.0;  //frequenza minima di lavoro

int statosensore1=HIGH;  //stato iniziale del sensore 1
int statosensore2=HIGH;  //stato iniziale del sensore 2

int i,j,k,x;

float freq[2]={0,0};//per la frequenza degli eventi di interrupt

//int count[2]={0,0};//conteggio degli eventi per il calcolo del tempo

unsigned long tempo[2][2]={{0,0},{0,0}};//memorizza l'istante di tempo in cui accade l'evento
unsigned long deltatempo1;//tempo di attesa in mancanza di eventi sensore 1
unsigned long deltatempo2;//tempo di attesa in mancanza di eventi sensore 2

byte led=B00000000; //matrice 3x2 di led 

void setup() 
{
  
  //lcd.begin(16,4);  // set up the LCD's number of columns and rows:
  i=0;
  j=0;
  k=0;

  attachInterrupt(0,sensore1,FALLING); //sensore collegato al pin 2
  attachInterrupt(1,sensore2,FALLING); //sensore collegato al pin 3

  pinMode(2,INPUT);
  pinMode(3,INPUT);

  digitalWrite(2, HIGH);
  digitalWrite(3, HIGH);

  //--------------------------shiftout
  pinMode(latchPinOUT, OUTPUT);
  pinMode(clockPinOUT, OUTPUT);
  pinMode(dataPinOUT, OUTPUT);

    led=B11111111; //matrice 3x2 di led 
 //   for(i=0;i<8;i++)
 //   {
    digitalWrite(latchPinOUT,LOW);     //Pull latch LOW to start sending data
    shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, led);    //Send the data byte led
    digitalWrite(latchPinOUT,HIGH);                      //Pull latch HIGH to stop sending data
  //  }
  
  // Serial.begin(9600); //per debug
  delay(5000);
}

void loop()
{
  //------------------------sensore 1
  if (statosensore1==LOW)       
  {
switch(i)
{
case 0:
tempo[0][0]=millis();  //memorizzazione dell'istante di tempo
break;
case 9:
tempo[0][1]=millis();  //memorizzazione dell'istante di tempo
break;
}
   i++; //incremento del contatore
    if(i==10)
    {
      freq[0]=(10)*1000/(tempo[0][1]-tempo[0][0]);//calcolo della frequenza
      i=0;
      // Serial.println(freq[0]); //per debug
    }
    statosensore1=HIGH;
  }

  deltatempo1=millis()-tempo[0][1];  //tempo trascorso 
  //Serial.println(deltatempo1);
  if (deltatempo1>2000)
  {
    freq[0]=0;  //azzeramento della frequenza dopo attesa di 2 sec
  }

  //---------------------------sensore 2
  if (statosensore2==LOW)        
  { 
switch(j)
{
case 0:
tempo[0][0]=millis();  //memorizzazione dell'istante di tempo
break;
case 9:
tempo[0][1]=millis();  //memorizzazione dell'istante di tempo
break;
} 
    j++; //incremento del contatore 
    if(j==10)
    {
      freq[1]=(10)*1000/(tempo[1][1]-tempo[1][0]); //calcolo della frequenza
      j=0;  //azzeramento del contatore
      // Serial.println(freq[1]);  //per debug
    }
    statosensore2=HIGH;
  }

  deltatempo2=millis()-tempo[1][1];  //tempo trascorso
  //Serial.println(deltatempo2);
  if (deltatempo2>2000)
  {
    freq[1]=0;  //azzeramento della frequenza dopo attesa di 2 sec
  }

  //sezione di output sui led
  for(k=0;k<=1;k++)
  {
    //  Serial.println("freq[0] ");//debug
    // Serial.println(freq[0]);//debug
    //  Serial.println("freq[1] ");//debug
    //  Serial.println(freq[1]);//debug

    if(freq[k]>Fmin && freq[k]<Fmax)  //frequenza normale di lavoro
    {   
      bitWrite(led,4+k,0);
      bitWrite(led,2+k,1);// accensione del led centrale
      bitWrite(led,k,0);

      // Serial.println(freq[0]); 
      //Serial.println(bitRead(ledVerdi,k));
    }

    if(freq[k]<=Fmin)  //frequenza bassa di lavoro
    {
      bitWrite(led,4+k,0);
      bitWrite(led,2+k,0);
      bitWrite(led,k,1);// accensione del led inferiore
    }

    if(freq[k]>=Fmax)  //frequenza alta di lavoro
    { 
      bitWrite(led,4+k,1);// accensione del led superiore
      bitWrite(led,2+k,0);
      bitWrite(led,k,0);
    }

    digitalWrite(latchPinOUT,LOW);     //Pull latch LOW to start sending data
    shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, led);    //Send the data byte led
    digitalWrite(latchPinOUT,HIGH);                      //Pull latch HIGH to stop sending data

  }
}

void sensore1() //pin 2 a cui attaccare il fotosensore
{
  statosensore1=LOW;
}
void sensore2() //pin 3 a cui attaccare il fotosensore
{
  statosensore2=LOW;
}

Grazie Stefa... Veramente molto gentile..

Beh.. se ci sono gli interrupt, mi studio anche quelli... Penso non mi scomodino anche per altri progetti che ho in mente..

Ci lavoro sopra e ti aggiorno sui risultati..

Un augurio di buone feste..

A presto..

Grazie di nuovo

nello sketch fornito lo puoi studiare solo metà, a te non servono gli interrupt puoi sostituire con i digital read, ne cancelli la metà e con poche modifiche puoi adattarlo

auguri e buon lavoro

Ciao Stefa, allora sono andato avanti con gli studi e le prove e sembra che sia arrivato alla conclusione...

Sembra funzionare..

Ti allego il codice, se ne hai voglia, dagli una sbirciatina per vedere se ho fatto ( quasi sicuramente ) qualche cavolata..

L'unico dubbio che mi viene, dopo aver letto di tutto sui millis, è quando passano più di 49 giorni... Ho cercato di seguire le istruzioni ed ho inserito il comando " previous=current".. Domanda!!: Basta quello che scavallare i 49 giorni e continuare ad avere il conteggio regolare??

Ti allego il codice.. Ci sono delle sporcature ancora da ripulire ( variabili dichiarate ma non utilizzate ) ma quelo lo considero dopo.....

Grazie della pazienza...

const int ledPin = 13;
const int ledAllarme = 11;
const int knockSensor = A0;
const int knockSensor1 = A1;
int pot = A5;
int pot1 = A4;
int imp = A2;
int threshold1;
int threshold;

int x=12;
int y=2;
unsigned long contaAnd=0;
unsigned long contaOr=0;
unsigned long allarme=5000;
unsigned long previousMillis=0;
int impulso=0;
int impulsi;


// Imposto la variazione di funzione per l'AND e l'OR
int funzione = 8;
int funzioneState = 1;

// Imposto le variabili per i DipSwitch
int dip1 = 3;
int dip2 = 4;
int dip3 = 5;
int dip4 = 6;

int dipswitchA;
int dipswitchB;
int dipswitchC;
int dipswitchD;


//Lettura Sensori Piezoelettrici
int sensorReading = 0;
int sensorReading1 = 0;

//Imposto gli stati delle uscite
int ledStatex = 0;
int ledStatey = 0;
int ledState = 0;
int ledx = LOW;
int ledy = LOW;
const long intervallo=1500;


void setup() {
 pinMode(ledPin, OUTPUT);
 pinMode(ledAllarme, OUTPUT);
 pinMode(x,OUTPUT);
 pinMode(y,OUTPUT);  
 
 pinMode(funzione,INPUT_PULLUP);
 
 pinMode(dip1,INPUT_PULLUP);
  pinMode(dip2,INPUT_PULLUP);
   pinMode(dip3,INPUT_PULLUP);
    pinMode(dip4,INPUT_PULLUP);
 


 Serial.begin(9600); 
}

void loop() {
  // Controllo gli stati dei DipSwitch per poter impostare il numero binario per il conteggio impulsi
      funzioneState = digitalRead(funzione);

      dipswitchA = digitalRead(dip1);
      dipswitchB = digitalRead(dip2);
      dipswitchC = digitalRead(dip3);
      dipswitchD = digitalRead(dip4);
      
      
  if((dipswitchA==HIGH)&&(dipswitchB==HIGH)&&(dipswitchC==HIGH)&&(dipswitchD==HIGH)){
    impulso=0;}
      
  if((dipswitchA==LOW)&&(dipswitchB==HIGH)&&(dipswitchC==HIGH)&&(dipswitchD==HIGH)){
    impulso=1;}

  if((dipswitchA==HIGH)&&(dipswitchB==LOW)&&(dipswitchC==HIGH)&&(dipswitchD==HIGH)){
    impulso=2;}
    
  if((dipswitchA==LOW)&&(dipswitchB==LOW)&&(dipswitchC==HIGH)&&(dipswitchD==HIGH)){
    impulso=3;}

  if((dipswitchA==HIGH)&&(dipswitchB==HIGH)&&(dipswitchC==LOW)&&(dipswitchD==HIGH)){
    impulso=4;}

  if((dipswitchA==LOW)&&(dipswitchB==HIGH)&&(dipswitchC==LOW)&&(dipswitchD==HIGH)){
    impulso=5;} 

  if((dipswitchA==HIGH)&&(dipswitchB==LOW)&&(dipswitchC==LOW)&&(dipswitchD==HIGH)){
    impulso=6;}
  
  if((dipswitchA==LOW)&&(dipswitchB==LOW)&&(dipswitchC==LOW)&&(dipswitchD==HIGH)){
    impulso=7;}
  
  if((dipswitchA==HIGH)&&(dipswitchB==HIGH)&&(dipswitchC==HIGH)&&(dipswitchD==LOW)){
    impulso=8;} 
   
  if((dipswitchA==LOW)&&(dipswitchB==HIGH)&&(dipswitchC==HIGH)&&(dipswitchD==LOW)){
    impulso=9;}
   
  if((dipswitchA==HIGH)&&(dipswitchB==LOW)&&(dipswitchC==HIGH)&&(dipswitchD==LOW)){
    impulso=10;}
   
  if((dipswitchA==LOW)&&(dipswitchB==LOW)&&(dipswitchC=HIGH)&&(dipswitchD==LOW)){
    impulso=11;}
   
  if((dipswitchA=HIGH)&&(dipswitchB==HIGH)&&(dipswitchC==LOW)&&(dipswitchD==LOW)){
    impulso=12;} 
    
  if((dipswitchA==LOW)&&(dipswitchB==HIGH)&&(dipswitchC==LOW)&&(dipswitchD==LOW)){
    impulso=13;}
    
  if((dipswitchA==HIGH)&&(dipswitchB==LOW)&&(dipswitchC==LOW)&&(dipswitchD==LOW)){
    impulso=14;}
    
  if((dipswitchA==LOW)&&(dipswitchB==LOW)&&(dipswitchC==LOW)&&(dipswitchD==LOW)){
    impulso=15;}

      
  
unsigned long currentMillis=millis();

  sensorReading = analogRead(knockSensor); 
    sensorReading1 = analogRead(knockSensor1); 

   int threshold = analogRead(pot)  ;
      int threshold1 = analogRead(pot1)  ;
   


// Controllo il funzionamento dei sensori e accendo il led specifico per ogni evento rilevato

if(sensorReading >= threshold) {
    digitalWrite (x,!ledStatex);}
    else { digitalWrite (x,ledStatex);}
  
  if(sensorReading1 >= threshold1) {
    digitalWrite (y,!ledStatey);}
    
    else{ digitalWrite (y,ledStatey);}
     
    if(funzioneState==LOW){

  // Funzione AND
      
    if ((sensorReading >= threshold)&&(sensorReading1 >= threshold1)){
      digitalWrite(ledPin,HIGH);
      digitalWrite(ledAllarme,HIGH);
      delay(100);
      digitalWrite(ledPin,LOW);
      digitalWrite(ledAllarme,LOW);
    contaAnd++;
      Serial.println("contaAnd");
      Serial.println(contaAnd);

            conteggioImpulsiAnd();
            }
         }   
    if(funzioneState==HIGH){

// Funzione OR      
      
    if ((sensorReading >= threshold) || (sensorReading1 >= threshold1)){
      digitalWrite(ledPin,HIGH);
      digitalWrite(ledAllarme,HIGH);
      delay(100);
      digitalWrite(ledPin,LOW);
      digitalWrite(ledAllarme,LOW);
      contaOr++;
      Serial.println("contaOr");
      Serial.println(contaOr);
      conteggioImpulsiOr();
      }
    }   
  }      



void conteggioImpulsiOr() {        
    unsigned long currentMillis;
currentMillis=millis();

      Serial.println(impulso);
      
      
    if ((contaOr<=impulso && (millis() - previousMillis) > allarme)){
    previousMillis=millis();
    contaOr=0; } 

    if ((contaOr>=impulso && (millis() - previousMillis) <= allarme)){
    previousMillis=currentMillis;
    digitalWrite(ledPin,HIGH);
      digitalWrite(ledAllarme,HIGH);
    delay(2500);
    digitalWrite(ledPin,LOW);
      digitalWrite(ledAllarme,LOW);
    delay(500);
    contaOr=0;}
}

void conteggioImpulsiAnd() {        
    unsigned long currentMillis;
currentMillis=millis();

      Serial.println(impulso);

    if ((contaAnd<=impulso && (millis() - previousMillis) > allarme)){
    previousMillis=millis();
  contaAnd=0;}  

    if ((contaAnd>=impulso && (millis() - previousMillis) <= allarme)){
    previousMillis=currentMillis;

    digitalWrite(ledPin,HIGH);
    delay(2500);
    digitalWrite(ledPin,LOW);
    delay(500);
  contaAnd=0;}
}

ciao
per le informazioni sul millis() ti rimando al link del post #3, se sei soddisfatto bene, adesso va testato per bene

Grazie Stefa... Si per il link l'ho letto..

La domanda era per avere un controllo da uno esperto su come lo avevo impostato...

In pratica per vedere se avevo capito bene...

Oramai il link me lo stò leggendo e rileggendo per riuscire a farlo mio e non dover sempre rileggere prima di scrivere qualcosa...

Grazie comunque per l'aiuto Stefa..

purtroppo non sono un programmatore professionista, e faccio un po fatica a seguire lo sketch, inoltre diverse possono essere le soluzioni, da quello che ho letto su millis() questo dopo ricomincia da capo quindi un controllo tra l'ultimo e il successivo penso sia sufficiente, ma come detto adesso devi testare tutto per bene e vedi come si comporta

Grazie Stefa... Sicuramente sei molto più esperto di me... :slight_smile:

Comunque i test sono già partiti...

E poi proverò a modificare i tempi di arduino come spiegato sempre nei tutorial del professore..

Grazie di nuovo..

Buon lavoro e buon proseguimento..

Ci sentiamo con i progressi del progetto..

Ciao..