motore dc controllo con encoder

Copiate bene senza cambiare i valori negli if e credo funzionerà al primo colpo.

void updateEncoder(){
 int MSB = digitalRead(encoderPin1); //MSB = most significant bit
 int LSB = digitalRead(encoderPin2); //LSB = least significant bit

 int encoded = (MSB << 1) |LSB; //converting the 2 pin value to single number
 int sum  = (lastEncoded << 2) | encoded; //adding it to the previous encoded value

 if(sum == 0b1101 || sum == 0b0100 || sum == 0b0010 || sum == 0b1011) encoderValue ++;
 if(sum == 0b1110 || sum == 0b0111 || sum == 0b0001 || sum == 0b1000) encoderValue --;

 lastEncoded = encoded; //store this value for next time
}

http://www.giuseppecaccavale.it/arduino/rotary-encoder-arduino/

Allora savoriano con l'ultimo listato partenza 0, prima rotazione orario -1 e si stabilizza a 2, seconda rotazione orario 5, terza rotazione orario 8, quarta rotazione orario 11, prima rotazione antiorario 7, seconda rotazione antiorario 3, terza rotazione antiorario -1, quarta rotazione antiorario -5

Mi è venuto il dubbione che @roccoStragapede ci ha dato l valori di "encodeValue" e non quelli di "sum"!

allora il problema si sta rivelando più grande di me, non so se ho dato i valori di sum opp encodeValue, ma veramente che non ci stò capendo più niente, comunque ho cambiato encoder con uno serio e sia in orario che antiorario l'incremento è di 1, quindi partenza 0 ruoto orario va a 1 nuova rotazione va a 2 e così via, stessa cosa nell'antiorario partenza 0 ruoto antiorario va a -1 nuova rotazione va a -2 e così via, l'unica cosa è rimasto il rimbalzo anche includendo la libreria encoder di Paul Stofferegen, tra l'altro nel listato ho semplicemente incluso la libreria all'inizio (credo che basti solo questo), comunque il mio problema rimane sempre il pilotaggio dei due IN della scheda L298N, come devo fare?

Con la libreria AccelStepper? :smiley: :smiley: :smiley:

PS: di che rimbalzo parli?

La libreria encoder di Paul Stofferegen da te consigliatami, il rimbalzo che io chiamo così è: superata una certa frequenza di rotazione inizia a fare Ping pong avanti indietro e non è più regolare, spero di essermi spiegato perché non conosco i termini tecnici.

Probabilmente vuol dire che il software non sta più dietro alle variazioni dell'encoder, e comincia a saltarne qualcuna con risultati imprevedibili. Di che frequenza di variazione parliamo?

(credo che basti solo questo),

#include serve per poter utilizzare la libreria e quindi tutte le sue funzioni nel tuo codice.
Questo implica a dover sapere come si utilizza la libreria.

comunque il mio problema rimane sempre il pilotaggio dei due IN della scheda L298N, come devo fare?

Comincia a risolvere il problema del encoder.

RoccoStragapede:
La libreria encoder di Paul Stofferegen da te consigliatami, il rimbalzo che io chiamo così è: superata una certa frequenza di rotazione inizia a fare Ping pong avanti indietro e non è più regolare, spero di essermi spiegato perché non conosco i termini tecnici.

Posta il codice per vedere come stai utilizzando la libreria

Concordo con quanto appena affermato da @Claudio_FF oppure ci potrebbe essere un problema di contatti, sicuro che i cavetti che collegano l'encoder alla scheda non abbiano falsi contatti? (tipo spinette che ballano, fili in corto ecc.?

ora non so quantificare la frequenza di rotazione, posso ipotizzare 10/20 scatti al secondo tutto qui, nei prodotti consumer che dispongono di encoder, e ne ho qualcuno io, li ruoto a frequenze maggiori e vanno benissimo

comunque i cavi sono buoni, tra l'altro cambiando l'encoder ho risolto il problema adesso, come spiegavo nel penultimo messaggio, la sequenza adesso è giusta cioè partenza 0, cw 1, cw 2, cw3, ccw 2, ccw 1, ccw 0, ccw -1 ecc.

posto il listato così potrete consigliarmi meglio

#include <Encoder.h>

#define pwmPin 11

int IN1 = 9;
int IN2 = 10;
int fccw = 12;
int fcccw = 13;

int encoderPin1 = 2;
int encoderPin2 = 3;
int cw = 4;
int ccw = 5;
int ledPin5 = 6;
int ledPin6 = 7;
int buttonPin3 = 8;

int ledState5 = LOW;
int ledState6 = HIGH;
int buttonState3;
int lastButtonState3 = HIGH;

long lastDebounceTime3 = 1;
long debounceDelay3 = 50;

volatile int lastEncoded = 0;
volatile long encoderValue = 0;

long lastencoderValue = 0;

int lastMSB = 0;
int lastLSB = 0;

void setup() {

  pinMode(pwmPin, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(fccw, INPUT_PULLUP);
  pinMode(fcccw, INPUT_PULLUP);

  pinMode(buttonPin3, INPUT_PULLUP);
  pinMode(ledPin5, OUTPUT);
  pinMode(ledPin6, OUTPUT);

  Serial.begin (9600);

  pinMode(encoderPin1, INPUT_PULLUP);
  pinMode(encoderPin2, INPUT_PULLUP);
  
  pinMode (cw, OUTPUT);
  pinMode (ccw, OUTPUT);

  attachInterrupt(digitalPinToInterrupt(2), updateEncoder, CHANGE);
  attachInterrupt(digitalPinToInterrupt(3), updateEncoder, CHANGE);

  digitalWrite(cw, LOW);
  digitalWrite(ccw, LOW);

  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, HIGH);

  digitalWrite(ledPin5, ledState5);
  digitalWrite(ledPin6, ledState6);
}

void loop() {

  int reading3 = digitalRead(buttonPin3);
  if (reading3 != lastButtonState3) {
    lastDebounceTime3 = millis();
  }
  if ((millis() - lastDebounceTime3) > debounceDelay3) {
    if (reading3 != buttonState3) {
      buttonState3 = reading3;
      if (buttonState3 == HIGH) {
        ledState5 = !ledState5;
        ledState6 = !ledState6;
        if (ledState5 == HIGH) {
          analogWrite(pwmPin, 64);
        }
        if (ledState6 == HIGH) {
          analogWrite(pwmPin, 191);
        }
      }
    }
  }
  digitalWrite(ledPin5, ledState5);
  digitalWrite(ledPin6, ledState6);
  lastButtonState3 = reading3;

  Serial.println(encoderValue);
}

void updateEncoder() {

  int MSB = digitalRead(encoderPin1);
  //delay(100);
  int LSB = digitalRead(encoderPin2);
  //delay(100);
  int encoded = (MSB << 1) | LSB;
  int sum  = (lastEncoded << 2) | encoded;
  Serial.print("Sum: ");
  Serial.println(sum);
  if (sum == 0b1101 || sum == 0b0100 || sum == 0b0010 || sum == 0b1011)
  {
    encoderValue ++;
    digitalWrite(cw, HIGH);
    digitalWrite(IN1, HIGH);
    digitalWrite(IN2, LOW);
  }
   else {
    digitalWrite(cw, LOW);
    digitalWrite(IN1, HIGH);
    digitalWrite(IN2, HIGH);
  }
  if (sum == 0b1110 || sum == 0b0111 || sum == 0b0001 || sum == 0b1000)
  {
    encoderValue --;
    digitalWrite(ccw, HIGH);
    digitalWrite(IN1, LOW);
    digitalWrite(IN2, HIGH);
  }
  else {
    digitalWrite(ccw, LOW);
    digitalWrite(IN1, HIGH);
    digitalWrite(IN2, HIGH);
  }
  lastEncoded = encoded;
}

fccw e fcccw sono dei finecorsa che non ho ancora implementato
cw e ccw sono due led che per il momento mi servono per vedere come si comporta l'encoder

Togli

  Serial.print("Sum: ");
  Serial.println(sum);

che come già spiegato ferma l'esecuzione della routine di interrupt per troppo tempo!!!!!!!!!!!!

ho modificato il listato togliendo i vari serialprint sum e ho implementato i due finecorsa, però rimane sempre il discorso dell'encoder che rimbalza anche usando la libreria e non mi piace come funziona.

ecco il listato

#include <Encoder.h>

#define pwmPin 11
#define fccw 12
#define fcccw 13
#define IN1 9
#define IN2 10
#define encoderPin1 2
#define encoderPin2 3
#define cw 4
#define ccw 5
#define ledPin5 6
#define ledPin6 7
#define buttonPin3 8

int ledState5 = LOW;
int ledState6 = HIGH;
int buttonState3;
int lastButtonState3 = HIGH;

long lastDebounceTime3 = 2;
long debounceDelay3 = 50;

volatile int lastEncoded = 0;
volatile long encoderValue = 0;

long lastencoderValue = 0;

int lastMSB = 0;
int lastLSB = 0;

void setup() {

  pinMode(pwmPin, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(fccw, INPUT_PULLUP);
  pinMode(fcccw, INPUT_PULLUP);

  pinMode(buttonPin3, INPUT_PULLUP);
  pinMode(ledPin5, OUTPUT);
  pinMode(ledPin6, OUTPUT);

  Serial.begin (9600);

  pinMode(encoderPin1, INPUT_PULLUP);
  pinMode(encoderPin2, INPUT_PULLUP);

  pinMode (cw, OUTPUT);
  pinMode (ccw, OUTPUT);

  attachInterrupt(digitalPinToInterrupt(2), updateEncoder, CHANGE);
  attachInterrupt(digitalPinToInterrupt(3), updateEncoder, CHANGE);

  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, HIGH);

  digitalWrite(ledPin5, ledState5);
  digitalWrite(ledPin6, ledState6);
}

void loop() {

  int reading3 = digitalRead(buttonPin3);
  if (reading3 != lastButtonState3) {
    lastDebounceTime3 = millis();
  }
  if ((millis() - lastDebounceTime3) > debounceDelay3) {
    if (reading3 != buttonState3) {
      buttonState3 = reading3;
      if (buttonState3 == HIGH) {
        ledState5 = !ledState5;
        ledState6 = !ledState6;
        if (ledState5 == HIGH) {
          analogWrite(pwmPin, 64);
        }
        if (ledState6 == HIGH) {
          analogWrite(pwmPin, 191);
        }
      }
    }
  }
  digitalWrite(ledPin5, ledState5);
  digitalWrite(ledPin6, ledState6);
  lastButtonState3 = reading3;

  Serial.println(encoderValue);
}

void updateEncoder() {

  int MSB = digitalRead(encoderPin1);
  delay(1000);
  int LSB = digitalRead(encoderPin2);
  delay(1000);
  int encoded = (MSB << 1) | LSB;
  int sum  = (lastEncoded << 2) | encoded;

  if (sum == 0b1101 || sum == 0b0100 || sum == 0b0010 || sum == 0b1011)
  {
    if (!digitalRead(fccw)) {}
    else {
      encoderValue ++;

      digitalWrite(cw, HIGH);
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, LOW);
      delay(5000);
      digitalWrite(cw, LOW);
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, HIGH);

    }
  }
  if (sum == 0b1110 || sum == 0b0111 || sum == 0b0001 || sum == 0b1000)
  {
    if (!digitalRead(fcccw)) {}
    else {
      encoderValue --;
      digitalWrite(ccw, HIGH);
      digitalWrite(IN1, LOW);
      digitalWrite(IN2, HIGH);
      delay(5000);
      digitalWrite(ccw, LOW);
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, HIGH);
    }
  }
  lastEncoded = encoded;
}

Vorrei anche che quando IN2 va LOW deve rimanere basso per un certo tempo regolabile da implementare in questa sezione

if (sum == 0b1101 || sum == 0b0100 || sum == 0b0010 || sum == 0b1011)
  {
    if (!digitalRead(fccw)) {}
    else {
      encoderValue ++;

      digitalWrite(cw, HIGH);
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, LOW);
      delay(1000000);
      digitalWrite(cw, LOW);
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, HIGH);
    }
  }

Vorrei anche che quando IN1 va LOW deve rimanere basso per un certo tempo regolabile da implementare in quest'altra sezione

if (sum == 0b1110 || sum == 0b0111 || sum == 0b0001 || sum == 0b1000)
  {
    if (!digitalRead(fcccw)) {}
    else {
      encoderValue --;
      digitalWrite(ccw, HIGH);
      digitalWrite(IN1, LOW);
      digitalWrite(IN2, HIGH);
      delay(1000000);
      digitalWrite(ccw, LOW);
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, HIGH);
      
    }
  }

e mi devono funzionare i finecorsa che al momento non funzionano

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[ ]

encoder2.png

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.

encoder2.png

allora l'encoder che stavo utilizzando all'inizio era questo

https://www.aliexpress.com/snapshot/0.html?spm=a2g0s.9042311.0.0.76c14c4dA4pOpT&orderId=3003646441128599&productId=32589351620

poi avendo risultati inaspettati ed essendo una cinesata ho messo questo

https://www.mouser.it/Search/Refine?Keyword=ECW0D-C24-BD0009&FS=True&Ns=Series|0

con evidenti miglioramenti e credo però che siano leggermente differenti, alla fine mi stanno arrivando altri ec11 nuovi così da poter fare il confronto, magari quello che avevo era malfunzionante a seguito di tante prove fatte.

riguardo ai ritardi sono solo prove per arrivare a determinati risultati ma mi rendo conto che anche qui i risultati non sono accettabili

in grandi linee però, quello che ottengo, per l'uso che devo fare, va bene anche con i ritardi sparati a 1000/5000. chiedo per ovviare a questi ritardi e far funzionare il debounce, come posso fare? cioè ad ogni passo avere per esempio l'uscita IN1 LOW per x secondi (regolabili) affinchè il motore ruoti per gli stessi x secondi tutto qui.

Provo comunque a riscrivere il codice con i tuoi consigli e ti faccio sapere

grazie tantissimo

una domanda ma f sta per?

onUp = (3 == f && 3 == encoded);

#include <Encoder.h>

#define pwmPin 11
#define fccw 12
#define fcccw 13
#define IN1 9
#define IN2 10
#define encoderPin1 2
#define encoderPin2 3
#define cw 4
#define ccw 5
#define ledPin5 6
#define ledPin6 7
#define buttonPin3 8

int ledState5 = LOW;
int ledState6 = HIGH;
int buttonState3;
int lastButtonState3 = HIGH;

long lastDebounceTime3 = 2;
long debounceDelay3 = 50;

volatile int lastEncoded = 0;
volatile long encoderValue = 0;

long lastencoderValue = 0;

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;

void setup() {

  pinMode(pwmPin, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(fccw, INPUT_PULLUP);
  pinMode(fcccw, INPUT_PULLUP);

  pinMode(buttonPin3, INPUT_PULLUP);
  pinMode(ledPin5, OUTPUT);
  pinMode(ledPin6, OUTPUT);

  Serial.begin (9600);

  pinMode(encoderPin1, INPUT_PULLUP);
  pinMode(encoderPin2, INPUT_PULLUP);

  pinMode (cw, OUTPUT);
  pinMode (ccw, OUTPUT);

  attachInterrupt(digitalPinToInterrupt(2), updateEncoder, CHANGE);
  attachInterrupt(digitalPinToInterrupt(3), updateEncoder, CHANGE);

  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, HIGH);

  digitalWrite(ledPin5, ledState5);
  digitalWrite(ledPin6, ledState6);
}

void loop() {

  int reading3 = digitalRead(buttonPin3);
  if (reading3 != lastButtonState3) {
    lastDebounceTime3 = millis();
  }
  if ((millis() - lastDebounceTime3) > debounceDelay3) {
    if (reading3 != buttonState3) {
      buttonState3 = reading3;
      if (buttonState3 == HIGH) {
        ledState5 = !ledState5;
        ledState6 = !ledState6;
        if (ledState5 == HIGH) {
          analogWrite(pwmPin, 64);
        }
        if (ledState6 == HIGH) {
          analogWrite(pwmPin, 191);
        }
      }
    }
  }
  digitalWrite(ledPin5, ledState5);
  digitalWrite(ledPin6, ledState6);
  lastButtonState3 = reading3;

  Serial.println(encoderValue);

  if (digitalRead(onUp == HIGH)) {
    if (!digitalRead(fccw)) {}
    else {
      digitalWrite(cw, HIGH);
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, LOW);
      delay(1000);
      digitalWrite(cw, LOW);
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, HIGH);
    }
  }
  if (digitalRead(onDn == HIGH)) {
    if (!digitalRead(fcccw)) {}
    else {
      digitalWrite(ccw, HIGH);
      digitalWrite(IN1, LOW);
      digitalWrite(IN2, HIGH);
      delay(1000);
      digitalWrite(ccw, LOW);
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, HIGH);
    }
  }
}

void updateEncoder()
{
  byte encoded = (digitalRead(encoderPin1) << 1) | digitalRead(encoderPin2);
  onUp = (3 == f  &&  3 == encoded);
  onDn = (6 == f  &&  3 == encoded);
  faseEnc = tabT[faseEnc][encoded];
}

questo è il codice modificato con i tuoi suggerimenti potresti dargli un'occhiata? ovviamente mi da errore per via dalla "f" non dichiarata

La 'f' è un refuso dimenticato, è 'faseEnc'
Ma 'onUp e 'onDn' sono variabili, non pin da leggere con digitalRead.

ok quindi devo modificare solo il loop per il resto è tutto ok?

Ho modificato leggermente la 'updateEncoder' per essere più adatta al caso in questione.
Per il resto c'è da lavorare solo nel loop (controllando se 'onUp' o 'onDn' vanno a 1 e riportandole a zero).

if (onUp == HIGH) {
    if (!digitalRead(fccw)) {}
    else {
      digitalWrite(cw, HIGH);
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, LOW);
      delay(10);
      digitalWrite(cw, LOW);
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, HIGH);
    }

questo è il primo if modificato

if (onDn == HIGH) {
    if (!digitalRead(fcccw)) {}
    else {
      digitalWrite(ccw, HIGH);
      digitalWrite(IN1, LOW);
      digitalWrite(IN2, HIGH);
      delay(10);
      digitalWrite(ccw, LOW);
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, HIGH);
    }

questo è il secondo if modificato

come faccio a portare onUp e on Dn LOW?

RoccoStragapede:
però rimane sempre il discorso dell'encoder che rimbalza anche usando la libreria

La libreria NON la stai usando dato che continui ad usare una tua funzione per controllare la posizione dell'encoder.

Come già detto, ma forse non l'ho scritto in modo chiaro, se NON leggi lo stato dei pin dell'encoder all'accensione il controllo non saprà mai qual'è la posizione dell'encoder dopo il reset e quindi prenderà per buona la posizione "00" (entrambi i bit a zero), in setup() leggi i pin e vedrai che non rimbalza più.

OT: Chiedo, è tanto difficile copiare dall'esempio della libreria?

/* Encoder Library - Basic Example
 * http://www.pjrc.com/teensy/td_libs_Encoder.html
 *
 * This example code is in the public domain.
 */

#include <Encoder.h>

// Change these two numbers to the pins connected to your encoder.
//   Best Performance: both pins have interrupt capability
//   Good Performance: only the first pin has interrupt capability
//   Low Performance:  neither pin has interrupt capability
Encoder myEnc(5, 6);
//   avoid using pins with LEDs attached

void setup() {
  Serial.begin(9600);
  Serial.println("Basic Encoder Test:");
}

long oldPosition  = -999;

void loop() {
  long newPosition = myEnc.read();
  if (newPosition != oldPosition) {
    oldPosition = newPosition;
    Serial.println(newPosition);
  }
}

Buonasera a tutti
Allora scusate la mia assenza ma mi stavano arrivando lo schedino L298N e i due motoriduttori con motorino a 12V e finalmente oggi sono arrivati, subito ho montato il tutto e con pochissime modifiche al listato funziona tutto come volevo, quindi ho modificato i due pwm per avere le due velocità uno a 125 e l'altro a 255, poi ho preso solo (sum == 0b1101) per l'avanzamento orario e (sum == 0b1110) per l'avanzamento antiorario dell'encoder per avere un controllo meno sensibile e abbassato i delay a valori più accettabili e cioè a 500 msec, per quanto riguarda il rimbalzo dell'encoder nemmeno si nota quindi mi va bene così.
A conti fatti ho che se ruoto l'encoder l'albero del motoriduttore segue la rotazione ovviamente nel verso in cui ruoto, ho ottenuto la funzione (con mia piacevole sorpresa) che se aumento la frequanza di rotazione dell'encoder aumenta lo spostamento dell'alberino in proporzione!!!
Quindi morale della favola si può effetuare il posizionamento di una x cosa anche con i motori a spazzole e non necessariamente utilizzare i motori passo passo utilizzando ovviamente i motori in accoppiamento hai motoriduttori.

#define pwmPin 11
#define fccw 7
#define fcccw 8
#define IN1 5
#define IN2 6
#define encoderPin1 2
#define encoderPin2 3
#define ledPin5 9
#define ledPin6 10
#define buttonPin3 4

int ledState5 = LOW;
int ledState6 = HIGH;
int buttonState3;
int lastButtonState3 = HIGH;

long lastDebounceTime3 = 2;
long debounceDelay3 = 50;

volatile int lastEncoded = 0;
volatile long encoderValue = 0;

long lastencoderValue = 0;

int lastMSB = 0;
int lastLSB = 0;

void setup() {

  pinMode(pwmPin, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(fccw, INPUT_PULLUP);
  pinMode(fcccw, INPUT_PULLUP);

  pinMode(buttonPin3, INPUT);
  pinMode(ledPin5, OUTPUT);
  pinMode(ledPin6, OUTPUT);

  Serial.begin (9600);

  pinMode(encoderPin1, INPUT);
  pinMode(encoderPin2, INPUT);

  attachInterrupt(digitalPinToInterrupt(2), updateEncoder, CHANGE);
  attachInterrupt(digitalPinToInterrupt(3), updateEncoder, CHANGE);

  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, HIGH);

  digitalWrite(ledPin5, ledState5);
  digitalWrite(ledPin6, ledState6);
}

void loop() {

  int reading3 = digitalRead(buttonPin3);
  if (reading3 != lastButtonState3) {
    lastDebounceTime3 = millis();
  }
  if ((millis() - lastDebounceTime3) > debounceDelay3) {
    if (reading3 != buttonState3) {
      buttonState3 = reading3;
      if (buttonState3 == HIGH) {
        ledState5 = !ledState5;
        ledState6 = !ledState6;
        if (ledState5 == HIGH) {
          analogWrite(pwmPin, 125);
        }
        if (ledState6 == HIGH) {
          analogWrite(pwmPin, 255);
        }
      }
    }
  }
  digitalWrite(ledPin5, ledState5);
  digitalWrite(ledPin6, ledState6);
  lastButtonState3 = reading3;

  Serial.println(encoderValue);
}

void updateEncoder() {

  int MSB = digitalRead(encoderPin1);
  int LSB = digitalRead(encoderPin2);
  int encoded = (MSB << 1) | LSB;
  int sum  = (lastEncoded << 2) | encoded;

  if (sum == 0b1101){
    if (!digitalRead(fccw)) {}
    else {
      encoderValue ++;
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, LOW);
      delay(500);
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, HIGH);
      delay(500);
    }
  }
  if (sum == 0b1110){
    if (!digitalRead(fcccw)) {}
    else {
      encoderValue --;
      digitalWrite(IN1, LOW);
      digitalWrite(IN2, HIGH);
      delay(500);
      digitalWrite(IN1, HIGH);
      digitalWrite(IN2, HIGH);
      delay(500);
    }
  }
  lastEncoded = encoded;
}

Un però c'è, mi rendo conto che per far ruotare da un estremo all'altro il mio variac ho bisogno di ruotare, ipotesi, "10000" volte l'encoder anche alla massima velocità di 255, secondo voi cosa potrei fare avendo a disposizione solo l'encoder e lo switch dell'encoder senza poter mettere pulsanti aggiuntivi?