Visualizzare solo valori crescenti

Il ragionameno fila.
Tuttavia, nel momento in cui legge 2, credo dovrebbe ricominciare.
Ho sistemato il programma. Lo posto.Sono alle prime armi, pian pianino imparero'.

int gradi_prec;
int gradi;

void setup() pinMode (13,OUTPUT);
Serial.begin(9600);
gradi_prec = gradi;

}

void loop() {

int valore = analogRead(A1);
int gradi = valore*0.3529411720;
if (gradi > (gradi_prec))  {Serial.println(gradi);
gradi_prec = gradi;}

}

Il problema del blocco al salto giro rimane. `

Ho provato questo. Sembra funzionare.

int gradi_prec;
int gradi;

void setup() 
{
pinMode (13,OUTPUT);
Serial.begin(9600);
gradi_prec = gradi;

}

void loop() {

int valore = analogRead(A1);
int gradi = valore*0.3529411720;
if (gradi > (gradi_prec))  {Serial.println(gradi);
gradi_prec = gradi;}

if(gradi_prec == 360) {Serial.println (0); gradi_prec=0;}
}

Ora mi trovo un altro problema. A volte l'ultima lettura cambia.
Puo' essere 359,360 e a volte 361.
Credo si tratti delle scillazioni della corrente, come posso stabilizzare?

Se da 361, banalmente qui:
if(gradi_prec >= 360) {Serial.println (0); gradi_prec=0;}

Se il calcolo però ti da 359.360 quando dovrebbe essere 360, è un problema. gradi è int quindi non può essere 359.360. Come fai a dire che a volte fa poco meno di 360 ?? Che valori da "valore" ovvero analogRead ?

Dato in pasto ad excel il calcolo, da 1000 a 1023 (i valori più alti dell'analogRead) da:

0,352941172
1000 352,941 352
1001 353,294 353
1002 353,647 353
1003 354,000 353
1004 354,353 354
1005 354,706 354
1006 355,059 355
1007 355,412 355
1008 355,765 355
1009 356,118 356
1010 356,471 356
1011 356,824 356
1012 357,176 357
1013 357,529 357
1014 357,882 357
1015 358,235 358
1016 358,588 358
1017 358,941 358
1018 359,294 359
1019 359,647 359
1020 360,000 359
1021 360,353 360
1022 360,706 360
1023 361,059 361

Tieni anche conto che un float a 32 bits non memorizza com precisione quella costante:

In quella frase la virgola non è il separatore decimale

Ma indica la semplice elencazione:

359 , 360 , 361

Direi che qui manca un po' di analisi del problema

Da parte di O P , intendo

Aggiungo:

Ma se il potenziometro non ha limiti esiste una zona dove non segna, e quindi non c'è lettura affidabile

Quindi un giro è più largo dello spazio tra zero e trecentosessanta

Mandando all'aria le misurazioni

Secondo me serve un encoder

Credo che il suggerimento dell'encoder sia interessante. Devo però capire bene il funzionamento. Mi cimentero' nella lettura.
L'encoder permette misure più precise? E può distinguere il primo giro dal secondo? L

Con l'encoder incrementale si ottiene un conteggio Up/Down e quindi una quota di solito su una variabile a 32bit intera con segno , per sapere in che giro si è basta dividere la quota per i cpr count per revolution dell'encoder

Concordo con @C1P8 al 100%

Se c'è necessità di misurare l'angolo di un albero motore, encoder o resolver senza alcun dubbio.

Per quanto riguarda il range dei valori angolari 0-360 basta fare l'operazione modulo %

Ok. Cercherò di muovermi nella direzione dell'encoder. Forse pian piano dovrei capire come fare. Credo che utilizzare un resolver sia oltre la mia portata.

Tranquillo era solo per citare il tipo di sensori di posizione che tipicamente si usano associati ai motori.

L'encoder è la scelta più sensata ed è semplice da implementare.
Esistono anche degli encoder "magnetici" (ad effetto hall) che potresti "incollare" direttamente al motore, ma è necessario applicare un magnete sull'albero quindi è da valutare caso per caso.

Potresti anche fare un partitore con il potenziometro, ottenendo da 0 a 4,5V durante l'escursione e 5V quando il contatto si interrompe. Se escono 4,6V o più, capisci che sta ricominciando il giro.

Non è una soluzione

Durante l'interruzione tu non hai letture valide, non potresti aggiornare la tabella dell'alzata valvole

Inoltre

Tu non sai quanto è lunga l'interruzione e quindi non sai a quale angolo comincia

E quindi non sai quale sia il massimo angolo indicato

Va buttato via il potenziometro e usato un encoder
Fine della storia

Ho deciso di optare per L'encoder.Arriverà in settimana.
Mi metterò a capire come fare.
Pian pianino, con le dovute letture, dovrei riuscirci.
Postero' le novità. Intanto grazie a tutti per i suggerimenti.

Un altra soluzione è il sensore angolare magnetico ad esempio as5600 , funziona benissimo con le sue librerie, costa poco ed è immune alla polvere, per il numero giro però devi contarlo da te

Ciao a tutti.
Dopo varie letture ho scritto un programma che sembra funziinare bene.
Ho utilizzato un encoder per l'albero motore ed un sensore analogico per l'alzata della valvola d'aspirazione. L'unico neo e' che avrei voluto i gradi interi, ma sono riuscito a visualizzare solo i vari step dell'encoder,che, trasformati in gradi, danno valori a crescere di 0.3, ma va benissimo anche cosi'. Ho utilizzato parallax per portare i valori in excel e costruire un grafico. Il prossimo obiettivo sara' implementare con un sensore per la valvola di scarico, ed eventualmente un passo passo, con il dovuto rapporto di demoltiplicazione, per far girare l'albero motore da solo. Per ora posto il programma che ho fatto, utilizzando varie parti di programmi presi qui e la'. Ringrazio tutti per i preziosi consigli che mi avete dato e vi auguro buone feste. Alla prossima. Mauro

volatile unsigned int temp,counter = 0 ;
int alzata;


void setup() {
Serial.begin(9600);
pinMode(13,OUTPUT);
pinMode (2,INPUT_PULLUP);
pinMode (3,INPUT_PULLUP);
attachInterrupt (0,ai0,RISING);
attachInterrupt (1,ai1,RISING);

Serial.println("CLEARSHEET");
Serial.println("LABEL,gradi,alzata");
}

void loop() {
int alzata;alzata = analogRead(A0);

if(counter > temp){ 
  Serial.print("DATA");
  Serial.print(",");
  Serial.print(counter*(0.3));
  Serial.print(",");
  Serial.println(alzata*0.009775171065);

temp = counter;};

delay(100);

}
void ai0(){if(digitalRead (3)==LOW){counter++;};}

void ai1(){if(digitalRead(2)==HIGH){counter++;};}

Diciamo che funzionicchia, ma in realtà l'algoritmo che hai implementato è impreciso perché ad ogni inversione della rotazione perdi uno step a causa del fatto che le isr vengono eseguite solo sul fronte di salita.

Va bene creare il firmware da zero per capirne il funzionamento di base, ma se il risultato deve essere "mediocre" allora tanto vale usare una delle tante librerie disponibili per encoder in quadratura.

Se invece vuoi approfondire, secondo me il metodo migliore è quello che fa uso di una tabella di stato e l'interrupt sull'evento CHANGE.

// Tabella di lookup per determinare il movimento
const int8_t stateTable[16] = {
  0,  -1,  1,  0,  // 00 -> 01 (anti-orario), 00 -> 10 (orario)
  1,   0,  0, -1,  // 01 -> 11 (orario), 01 -> 00 (anti-orario)
 -1,   0,  0,  1,  // 10 -> 00 (orario), 10 -> 11 (anti-orario)
  0,   1, -1,  0   // 11 -> 10 (anti-orario), 11 -> 01 (orario)
};

Io normalmente faccio così:
[Vedi alla ISR (PCINT0_vect) (Poiché non è stato premuto il pulsante) // E' stato ruotato l'encoder]:

Leggo lo stato dell'encoder trasformandolo in una sequenza 0-1-2-3-0 oppure 0-3-2-1-0 e rilevo il passaggio da 1 a 2 oppure da 3 a 2, evitando ogni problema di rimbalzi.

Lì c'è anche il pulsante sul Pin Change Interrupt, perciò se c'è stato un cambiamento e non viene dal pulsante deve venire dall'encoder.

Ma non penso che stia usando quel tipo di encoder... o almeno lo spero.

Avrebbe una risoluzione angolare ridicola visto che quegli affari se non sbaglio sono da 20 impulsi per giro.

Uhmm... Hai ragione... Quelli senza scatti producono una sequenza continua. Comunque il concetto si può applicare ugualmente, modificando il programma, ma alla fine probabilmente si arriva alla tua tabella...

E' comunque un codice Gray che può essere convertito in valori decimali da 0 a 3. Tu fai una tabella con i valori precedenti e quelli correnti?
Mi viene così:

P C
r o
e r
c r
. .
ABAB
1101: +1
0100: +1
0010: +1
1011: +1

1110: -1
1000: -1
0001: -1
0111: -1

Ma quale inversione?

Può contare solo a più
Le inversioni non le considera proprio

Algoritmo molto più semplice di quelli proposti è semplicemente mettere un interrupt (salita o discesa non importa) su un canale (quale non importa) e all'linterrupt semplicemente leggere l'altro canale
Se alto fare ++, altrimenti--

Se conta rovescio si scambiano 2 fili

Banale e brutale, ma funziona
Senza tabelle della verità o contare fino a tre o altri utensili da falegname

KISS, KISS sempre; anche di fronte all'evidenza (che invariabilmente da ragione al bacio)

Buona giornata