Rocco... secondo me urge ripartire da zero, con tutto il discorso.
Primo punto, hai scelto un motore DC che per sua natura non si sposta mai a passi esatti (anche se ridotto), non ritorna mai esattamente nello stesso punto, e soprattutto si muove a velocità diverse a seconda del carico. Ma se per il tuo uso va bene, allora ok.
Secondo punto, dopo 50 post ancora non si è detto quale encoder si sta usando. Possiamo ipotizzare dal video del post #7 che si tratta di un normale encoder a 20 scatti quattro fronti per scatto? Che si comporta cioè come nella figura sottostante? Rispondere SI[ ] NO[ ]

Se si (altrimenti non si può proseguire), esiste un solo modo corretto per leggerlo, ed è quello di usare una macchina a sette stati per seguire le variazioni dei fronti CLK e DT, in modo da riconoscere esattamente tutti gli stati intermedi tra due posizioni stabili (indicate dalle tratteggiate). Tutti gli altri modi "semplificati" hanno dei difetti e bisogna conoscerne bene i limiti. Ad esempio la lettura che stai usando non controlla tutti i passaggi tra una posizione stabile e l'altra, anzi, genera "quattro scatti" (e non uno) per ogni singolo scatto della manopolina... può andare bene oppure no, ma devi essere tu a stabilirlo in base all'uso. Inoltre non effettua alcun debounce, per cui a meno di accorgimenti hardware (condensatori di filtro), un solo scatto della manopolina può produrre diversi passi avanti e indietro contemporaneamente.
Terzo punto, il più grave di tutti, si è detto di togliere le Serial.print per non rallentare il gestore degli interrupt (che si deve occupare SOLO di leggere l'encoder e nient'altro) e ci hai messo dentro delle delay 1000 e 5000... che vuol dire bloccare/sfalsare la lettura dell'encoder per 6 secondi ogni volta. Guarda solo questa parte che hai scritto... significa: leggi un pin dell'encoder, ma prima di leggere l'altro aspetta un secondo! Come si possono fare le decine (o centinaia) di letture al secondo necessarie per stare dietro al movimento della manopolina se si blocca tutto per un secondo ad ogni lettura? :o :o :o
int MSB = digitalRead(encoderPin1);
delay(1000);
int LSB = digitalRead(encoderPin2);
Va rivista completamente la logica a perché evidentemente non è chiaro come si usa un gestore di interrupt (ripetiamo: deve durare massimo pochi microsecondi, non secondi interi). Tutto quello che vuoi fare con i delay va fatto nel loop, mentre il gestore degli interrupt (cioè la funzione 'updateEncoder') deve solo comunicare al loop (tramite una variabile) che è stato fatto uno scatto avanti o indietro (poi è compito del loop starci dietro ma questo è il -grosso- problema successivo).
Quindi... prima di tutto sistemiamo questo benedetto encoder, le variabili necessarie:
const uint8_t tabT[7][4] = {
{ 0, 4, 1, 0 },
{ 2, 1, 1, 0 },
{ 2, 3, 1, 2 },
{ 2, 3, 3, 0 },
{ 5, 4, 4, 0 },
{ 5, 4, 6, 5 },
{ 5, 6, 6, 0 }
};
volatile byte onUp = 0;
volatile byte onDn = 0;
volatile byte faseEnc = 0;
La lettura sotto interrupt (e non si deve aggiungere niente altro):
void updateEncoder()
{
byte encoded = (digitalRead(encoderPin1) << 1) | digitalRead(encoderPin2);
if (3 == faseEnc && 3 == encoded) { onUp = 1; }
if (6 == faseEnc && 3 == encoded) { onDn = 1; }
faseEnc = tabT[faseEnc][encoded];
}
Quando la manopolina fa uno scatto viene messa a 1 la variabile 'onUp' oppure 'onDn'. Se va al contrario basta scambiare i due nomi 'onUp' con 'onDn' nella 'updateEncoder'.
E rimane (solo) la logica da scrivere nel loop, che dovrà prevedere degli 'if' per testare se 'onUp' o 'onDn' è andata a 1, e in quel caso riportarla a zero e fare quello che si vuole.
