come gestire tolleranza valori adc?

CIAO A TUTTI,scusatemi la solita domanda,ma non so come si scrive il linguaggio… sto prendendo n2 valori di n2 adc e x gestire i valori ho scritto…ecco uno spezzone

if (valore1 < valore2 ) {
valore-- ;
}
if (valore1 > valore2 ) {
valore++ ;
}
if (valore1 == valore2 ) {
valore = valore ;

ecco quest ultimo valore1 == valore2 i 2 valori non sempre sono uguali tipo 500 == 500 ma tentennano tra 497==503 e 503==497 ecc
quindi la variabile valore non rimane mai ferma…
la mia domanda è…come posso gestire questi piccoli spostamenti di valore?cosa posso scrivere x gestire una tolleranza di 5 punti di differenza?

Potresti usare una logica di questo tipo:
se valore1 >= valore2 - 5 e valore1 <= valore2 + 5 …

io faccio così di solito:

mezzaTolleranza = 10;

if ( abs(valore1-valore2)<mezzaTolleranza){ 
    valore = valore  ;
}

che poi a cosa serva fare valore = valore… spero sia un errori di copia :slight_smile:
totare he l’errore è di ±10, quindi 20 “punti”

grazie menniti,stasera lo provo

valore=valore mi serve x indicare al servo di stare immobile
valore1 è l adc di un sensore di luce fotoresistenza
valore2 è l adc di un altro sensore di luce fotoresistenza

da principiante ho modificato alcuni programmi gia fatti in questo modo…scusate se fatto in modo elementare…ma non sono esperto

(seguitore solare elicottero78)

#include <Servo.h>

Servo myservo;

int sensoreluce1 = 0; // fotoresistenza 1
int sensoreluce2 = 1; // fotoresistenza 2
int valorex = 500 ; //??? ancora da capire bene x me
int valore = 90 ; // posizione centrale dell servo appena accendo il circuito,il pannello solare guarda il sud
int valore1; //valore fotoresistenza 1
int valore2; //valore fotoresistenza 2

void setup()
{
Serial.begin(9600); // controllo seriale x prove…se tutto funziona,questo viene eliminato
myservo.attach(9); // pin servo
}

void loop()
{
valorex = map(valore, 0, 1023, 0, 179); // valore in gradi x sevo 0-180
myservo.write(valore);

valore1 = analogRead(sensoreluce1); // legge valore fotoresistenza 1

valore2 = analogRead(sensoreluce2); // legge valore fotoresistenza 2

if (valore1 < valore2 ) {
valore-- ; // il pannello solare appena acceso il circuito guarda il sud,ma se trova piu luce verso est…allora ruota verso est
} // opppure il contrario,cioè ovest,i sensori sono uno a destra del pannello solare e l altro a sinistra,
if (valore1 > valore2 ) { // piegati leggermente verso l esterno,si muovono insieme al pannello solare
valore++ ; // se tutti e 2 i sensori leggono la stessa quantità di luce,allore il valore del servo non deve cambiare,
} // ma rimanere fermo verso il sole,man mano che il sole si sposta…il sensore piu illuminato aumenta di valore
// del servo verso la parte piu illuminata del cielo-sole

if (valore1 == valore2 ) { //da modificare causa continui tentennamenti dei 2 valori adc
valore = valore ;
}

Serial.print(“valore1 = " ); // controllo seriale x prove…se tutto funziona,questo viene eliminato
Serial.print(valore1);
Serial.print(” valore2 = " ); // controllo seriale x prove…se tutto funziona,questo viene eliminato
Serial.print(valore2);
Serial.print(" valore = " ); // controllo seriale x prove…se tutto funziona,questo viene eliminato
Serial.print(valore);
Serial.println( ); // controllo seriale x prove…se tutto funziona,questo viene eliminato
delay(500);
}

Figurati, in realtà dovresti seguire il suggerimento di lesto, tecnicamente è validissimo (d'altra parte è un esperto software), la funzione abs restituisce il valore assoluto (senza segno) della differenza tra le due variabili, quindi puoi sottrarle tra loro, verificando che il risultato sia minore della tolleranza che vuoi dare. Es. valore1= 496, valore2=500, tolleranza = 5 , diventa: abs(496-500) = abs(-4) = 4 che è minore di 5 quindi rientra nella tua tolleranza, per cui li consideri "uguali". Ciao.

o cavolo non ho dato molta attenzione al messaggio di lesto x la fretta .........

ma abs è un simbolo che si usaa nel linguaggio c o fa parte di arduino?

è un comando C definito dallo standard ANSI, quindi compatibile con praticamente tutti i compilatori C

lesto: è un comando C definito dallo standard ANSI,

abs() è una funzione e non un comando, è definita nella libreria stdlib del C ANSI, tutti i compilatori C la implementano. abs() è applicabile solo a valori interi, sia char che int, mentre non è applicabile ai float per i quali è necessario usare fabs(), occorre includere "math.h".

astrobeed: abs() è una funzione e non un comando, è definita nella libreria stdlib del C ANSI, tutti i compilatori C la implementano.

mea culpa, hai ragione

astrobeed: abs() è applicabile solo a valori interi, sia char che int, mentre non è applicabile ai float per i quali è necessario usare fabs(), occorre includere "math.h".

qusta non la sapevo, fabs() è sempre ansi?

Serve anche a me per gestire una tastiera tramite un canale ADC, vero fare la differenza risolve a patto di un po di chiamare una funzione in più.

Approposito, comando o funzione, mi sa che non ci avete preso tutte e due, perchè da questo codice si vede che è una macro.
File wiring.h

// undefine stdlib's abs if encountered
#ifdef abs
#undef abs
#endif

//! \ingroup Arduino_Macro
#define min(a,b) ((a)<(b)?(a):(b))

//! \ingroup Arduino_Macro
#define max(a,b) ((a)>(b)?(a):(b))

//! \ingroup Arduino_Macro
#define abs(x) ((x)>0?(x):-(x))

Il perchè debba essere ridefinita non mi appare lampante.
Chissa perchè?

Ciao.

Tralasciando il modo in cui viene definita (se con #define come macro o come normale routine) abs() è una funzione perché accetta dei parametri in ingresso e restituisce un valore come risultato. Un comando invece è una chiamata ad una porzione di codice che può accettare dei parametri in ingresso ma no restituisce nulla.

Sul perché venga ridefinita forse ciò viene fatto per avere una funzione unica per trattare diversi tipi di dati senza usare più versioni della funzione (la già citata fabs(), che non ho mai incrociato negli sketch Arduino).

Tralasciando il modo in cui viene definita (se con #define come macro o come normale routine) abs() è una funzione perché accetta dei parametri in ingresso e restituisce un valore come risultato. Un comando invece è una chiamata ad una porzione di codice che può accettare dei parametri in ingresso ma no restituisce nulla.

Si solo che può diventare importante sapere che è una macro che ti ritrovi nel codice così com'è, sarebbe il caso non usarla centinaia di volte perchè il risultato sarebbe un .elf gonfio senza motivo.

Ciao.