Arduino, istruzione if fra due valori.

Bisognerebbe vedere il codice ma supponiamo che l'esecuzione del loop sia abbastanza veloce, e quell'istruzione "if" venga eseguita molto spesso. Se il valore di t cade nell'intervallo nel momento sbagliato

l'intenzione. Per questo occorre sempre o un debounce efficiente via hardware oppure tutte le varie precauzioni che "giassai" ^_^

ma quale codice per rilevare t ? te ne hanno scritte di tutti i colori :)

t lo cambi nell'interrupt?

prova:

t2=t; // anche se dubito tantissimo che te lo possa cambiare durante il confronto. Ci saranno altri errori.

if (t2 >= 100 && t2

Il 07/10/2019 13:03, Drizzt do'Urden ha scritto:

he he he, scusate la mancanza :-)

il pulsante, funziona bene ma becca i rimbalzi, speravo che l'if scritto in quella maniera mi permettesse di escludere i rimbalzi ma immagino che

int stato; int conteggio;

const int PREMUTO = 1; const int RILASCIATO = 0; const int ON = HIGH; const int OFF = LOW;

long t0; long t;

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

stato = RILASCIATO; conteggio = OFF; }

void loop(){ int tasto = digitalRead(8);

if ((conteggio == OFF) && (tasto == HIGH)) { conteggio = ON; t0 = millis(); digitalWrite(12, HIGH);

Serial.println("Premiuto tasto"); }

if ((conteggio == ON) && (tasto == LOW)) { conteggio = OFF; t = millis() - t0;

{ if ((t >= 100) && (t 1000) digitalWrite (12, LOW); }

Serial.print("tempo="); Serial.println(t); } }

Possibile che non ci sia una funzione che elimini il tempo da 0 a 100mS?

Nel suo scritto precedente, Drizzt do'Urden ha sostenuto :

Il 07/10/2019 17:32, Franz_aRTiglio ha scritto:

Perfetto ma, come hai detto tu, non mi risolve il problema...

nonostante la limitazione del >100, esiste una maniera per far leggere solo l'intervallo richiesto?

in pratica scrivere if (t > 100 && t

Drizzt do'Urden ha spiegato il 07/10/2019 :

lo saranno negli effetti del tuo programma ma non sono la stessa cosa, andando a naso, MOLTO a naso il tuo problema e' come gestisci t: per capirci, non e' che quel codice, una volta che T ha raggiunto il valore richiesto viene eseguito piu volte ?

esempio:

premo il bottone, T inizia a incrementare: T arriva al valore soglia di 100, il mio codice che prima non eseguiva "digitalWrite(12, HIGH)" esegue, T sta continuando ad aumentare, e il mio codice diligentemente attiva nuovamente digitalWrite(12, HIGH) per tutte le volte che esegue il blocco di istruzioni.

imo devi metter un "antirimblazo" anche nel software, che valuti T SOLO quando t e' stato rilasciato e SOLO se nessun altro controllo su T e' stato fatto:

premo il pulsante: inizio ad incrementare T e contemporaneamente XY. (T e XY hanno lo stesso valore a pulsante premuto), quando rilascio il pulsante, azzero SOLO T, eseguo il controllo del valore di XY SOLO quando T e' a 0 e una volta fatto il controllo azzero anche XY.

tipo:

if (pulsante premuto) { t++ xy++ }

if (pulsante NON premuto) { t = 0 }

if (t = 0 && xy != 0) { // esegui il controllo solo dopo il rilascio if (xy > 100) { // solo se superiore a 100 if (xy < 1000) { digitalWrite(12, HIGH); // meno di un secondo } else { digitalWrite(12, HIGH); // piu di un secondo } } // in ogni caso, avendo fatto il controllo // si deve azzerare l' "antirimbalzo" software xy xy = 0 }

implicazioni che al momento non vedo. Con i float io sono

della variabile abbia una qualche imprecisione per cui definisco un TOL tipicamente dieci alla meno qualcosa, formulo la condizione in termini di differenza e tutti i miei confronti sono tipo if( fabs(x-xo)

"Archaeopteryx" ha scritto nel messaggio news:qnfp0u$84h$ snipped-for-privacy@gioia.aioe.org...

"stretta"

infatti non la fa- :-)

se una cosa deve valere da 0 a 100 compresi e' molto piu' chiaro scrivere t>=0 && t

Nel suo scritto precedente, Archaeopteryx ha sostenuto :

Se fossimo ancora ai tempi dello z80 significherebbe anche qualche preziosissimo ciclo macchina in meno ma come ho detto e' "solo" piu pulito da leggere e non fa vera differenza; ciononostante evitare istruzioni ridondanti o superflue e' sempre buona pratica.

Il 07/10/19 17:03, Drizzt do'Urden ha scritto:

Da quello che vedo nel codice hai questo comportamento:

- appena premi il tasto il pin 12 va' HIGH;

"protetta" dal debouncing)

appena rilasci il pulsante, sempre per effetto del bouncing, ti viene reimpostato a HIGH nel primo if

int stato; int conteggio;

const int PREMUTO = 1; const int RILASCIATO = 0; const int ON = HIGH; const int OFF = LOW;

long t0; long t;

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

stato = RILASCIATO; conteggio = OFF; }

void loop(){

int tasto = digitalRead(8);

if ((conteggio == OFF) && (tasto == HIGH)) {

conteggio = ON; t0 = millis();

if ((conteggio == ON) && (tasto == LOW)) {

conteggio = OFF; t = millis() - t0;

if (t >= 100) {

Serial.print("tempo="); Serial.println(t);

if (t 1000) digitalWrite(12, LOW);

Il 07/10/2019 19:41, marimbarza ha scritto:

Ciao e grazie per l'interessamento, il mio sketch funziona bene, solamente qualche volta, in base ai rimbalzi del pulsante, prende il tempo basso e di conseguenza lascia attiva l'uscita 12. Praticamente se il pulsante non avesse rimbalzi, il tutto sarebbe

Ho provato anche in questa maniera ma quando avviene il rimbalzo lo

rimbalza in apertura legge sempre meno di 1000 e lascia attiva l'uscita.

Il 07/10/2019 18:11, Franz_aRTiglio ha scritto:

pulsante, esegue quello che deve fare, e lo fa bene, chiaramente il loop legge sempre lo stato del pulsante e durante i rimbalzi il loop riesce a fare anche qualche ciclo quindi se legge un valore basso (tipicamente un rimbalzo l'ho sempre letto da 1 a 10mS) esegue quello che deve fare col valore basso.

L'istruzione if scritta in quella maniera non delimita la lettura tra

tutto fino a zero. Questo ho capito, speravo esistesse una funzione che permettesse realmente di utilizzare un valore ben delimitato.

semplice) altrimenti sto provando a costruire con la stampante 3D un pulsante con sensore hall, vediamo come viene :-)

apertura non cambia nulla ma come ho detto non sono in grado di valutarlo, mi ci vuole ancora un po di tempo e di esperimenti :-)

"Drizzt do'Urden" ha scritto nel messaggio news:qng0v0$1do5$ snipped-for-privacy@gioia.aioe.org...

tutto

no, vuol dire tutto fino a 100. la "if" scritta come l'hai scritta tu fa veramente quello che vorresti, sono

realmente

hai capito male. come ti hanno gia' spiegato e' il resto del tuo codice che non va bene, non la "if" in se stessa.

Il 07/10/2019, Drizzt do'Urden ha detto :

il punto e' che se consideri solo i 2 status

A pulsante non premuto contatore =0 B pulsante premuto contatore ++1

rischi di non poter distinguere se il pulsante sta rimbalzando o e' una singola pressione continua, ma se consideri:

A pulsante premuto X msec fa e ancora premuto

C pulsante non piu premuto

dovresti "intrappolare" sia l'evento "premo il pulsante" che l'evento "ho rilasciato il pulsante", nell'esempio che ti ho fatto se consideri T e XY come eventi le combinazioni possibili sono le 4 sopra descritte.

t !=1 e xy !=1 ? --> condizione A t =0 ma xy !=1 ? --> condizione B t =0 e xy = 0 ? --> condizione C

ho visto il tuo codice ora e forse ho identificato un errore di logica legato al non azzerare mai i contatori, ora devo mettere letto il pupo ma ci do un'occhiata stanotte, tempo permettendo che ho un po' di lavoro da fare.

Il 07/10/2019 21:00, alfio ha scritto:

Il 07/10/2019 21:30, Franz_aRTiglio ha scritto:

Buona notte al pupo :-)

analogica che mi ritrovo la vedo dura, grazie per l'aiuto :-)

Dopo dura riflessione, Drizzt do'Urden ha scritto :

const int PREMUTO = 1; const int RILASCIATO = 0;

quindi PREMUTO ha valore' 1 e RILASCIATO ha valore zero, qua tutto ok ma poi prosegui con:

const int ON = HIGH; const int OFF = LOW;

cos'e' HIGH ? se non gli hai dato valore prima allora HIGH e' uguale a zero o peggio void (non conosco cosi bene il dialetto di arduino) quindi come per OFF e' come se scrivessimo

const int ON = 0; const int OFF = 0;

Franz_aRTiglio ci ha detto :

funzioni/istruzioni come fosse un valore, non mi stupirei di scoprire che se il risultato non e' zero e' il risultato di un confronto logico tra l'ultima lettura del pin e l'implicito true/false del tipo:

--> ultima lettura del pin ritorna HIGH

const int ON = HIGH //stato del pin = high quindi TRUE quindi ON = true

--> ultima lettura del pin ritorna LOW

const int ON = HIGH //stato del pin = low quindi FALSE quindi ON = false