Encoder incrementale

 

Contenuti:
1

Utilizzare un encoder rotativo con Arduino
2

Utilizzare un encoder rotativo con libreria e Arduino 
3

Tutorial Arduino ITA 32: encoder rotativo (menu sul display LCD) - OK
4

Elettronica digitale con Arduino 13: L'encoder rotativo

 

 

Si tratta di un interruttore encoder rotativo continuo; Tipo: codice encoder con interruttore; Metodo di regolazione: rotativo a 360 gradi; Numero di cifre: 20 cifre; Pin: 5.

Diametro dell'albero: 6 mm; Lunghezza dell'albero: 20 mm.

Questo è di tipo meccanico. Esiste anche una versione ottica che si distingue per essere alimentata.

 

Schema di collegamento:

  • OUT A → Pin digitale 2 di Arduino (con interrupt)

  • OUT B → Pin digitale 3 di Arduino

  • GND (destro) → GND di Arduino

  • SWITCH → Pin digitale 4 di Arduino (con INPUT_PULLUP)

  • GND (sinistro) → GND di Arduino

 

Esiste anche una versione ottica che si distingue per essere alimentata.

Useremo questa perchè più pratca da montare.

 

 

Schema di collegamento:

  • CLK → Pin digitale 2 di Arduino (con interrupt)

  • DT → Pin digitale 3 di Arduino

  • SW → Pin digitale 4 di Arduino (con INPUT_PULLUP)

  • + → +5V Arduino

  • GND → GND di Arduino

Codice:

 

#include <Encoder.h>
#define DT_PIN 2
#define CLK_PIN 3
#define BUTTON_PIN 4

Encoder encoder(DT_PIN, CLK_PIN);

int lastEncoderValue = 0;
int lastButtonState = LOW;

void setup() {
  Serial.begin(115200);
  pinMode(BUTTON_PIN, INPUT_PULLUP);
}

void loop() {
  int encoderValue = encoder.read() / 4;
  
  // Limita il valore tra 0 e 255
  if (encoderValue < 0) {
    encoder.write(0);
    encoderValue = 0;
  } 
  else if (encoderValue > 255) {
    encoder.write(255 * 4); // Riporta il valore a 255
    encoderValue = 255;
  }

  if (encoderValue != lastEncoderValue) {
    Serial.println("Encoder: " + String(encoderValue));
  }
  lastEncoderValue = encoderValue;

  // Gestione del pulsante per resettare il valore
  int buttonState = !digitalRead(BUTTON_PIN);
  if (buttonState != lastButtonState && buttonState == HIGH) {
    encoder.write(0);
    lastEncoderValue = 0;
    Serial.println("Encoder resettato a 0");
    delay(200);
  }
  lastButtonState = buttonState;
}

 

Stesso codice ma commentato passopasso:

  

// Inclusione della libreria Encoder per gestire l'encoder rotativo
#include <Encoder.h>

// Definizione dei pin a cui sono collegati i segnali dell'encoder e il pulsante
#define DT_PIN 2        // Pin per il segnale DT dell'encoder
#define CLK_PIN 3       // Pin per il segnale CLK dell'encoder
#define BUTTON_PIN 4    // Pin per il pulsante

// Creazione dell'oggetto encoder utilizzando i pin definiti sopra
Encoder encoder(DT_PIN, CLK_PIN);

// Variabili per memorizzare lo stato precedente dell'encoder e del pulsante
int lastEncoderValue = 0;
int lastButtonState = LOW;

void setup() {
  Serial.begin(115200); // Inizializzazione della comunicazione seriale a 115200 baud
  // Imposta il pulsante come input con resistenza di pull-up interna
  pinMode(BUTTON_PIN, INPUT_PULLUP);}

void loop() {
  // Legge il valore attuale dell'encoder e lo divide per 4 per ottenere un conteggio più stabile
  int encoderValue = encoder.read() / 4;

  // Controllo per limitare il valore tra 0 e 255
  if (encoderValue < 0) {
    encoder.write(0);      // Se il valore è inferiore a 0, lo imposta a 0
    encoderValue = 0;
  } 
  else if (encoderValue > 255) {
     // Se il valore supera 255, lo imposta al massimo (255 * 4 per adattarlo alla scala dell'encoder)
    encoder.write(255 * 4);   encoderValue = 255;
  }

  // Se il valore dell'encoder è cambiato, lo stampa sulla seriale
  if (encoderValue != lastEncoderValue) {
    Serial.println("Encoder: " + String(encoderValue));
  }
  lastEncoderValue = encoderValue; // Aggiorna la variabile con il nuovo valore dell'encoder

  // Lettura dello stato del pulsante (invertito perché usiamo INPUT_PULLUP)
  int buttonState = !digitalRead(BUTTON_PIN);

  // Controlla se il pulsante è stato premuto (cambio di stato da LOW a HIGH)
  if (buttonState != lastButtonState && buttonState == HIGH) {
    encoder.write(0);      // Resetta il valore dell'encoder a 0
    lastEncoderValue = 0;  // Aggiorna la variabile di controllo
    Serial.println("Encoder resettato a 0"); // Messaggio sulla seriale
    delay(200); // Piccola pausa per evitare rimbalzi del pulsante
  }

  lastButtonState = buttonState; // Aggiorna lo stato precedente del pulsante
}

 

Spiegazione del funzionamento

  1. Librerie e definizioni:

    • Includiamo la libreria Encoder.h per gestire l'encoder.

    • Definiamo i pin utilizzati dall'encoder e il pulsante.

  2. Creazione dell'oggetto encoder:

    • Inizializziamo l'encoder con i pin DT e CLK.

  3. Setup:

    • Avviamo la comunicazione seriale a 115200 baud.

    • Configuriamo il pulsante come input con pull-up interna (quindi normalmente sarà HIGH e andrà a LOW quando premuto).

  4. Loop principale:

    • Leggiamo il valore dell'encoder e lo dividiamo per 4 per rendere il conteggio più stabile.

    • Se il valore è inferiore a 0, lo forziamo a 0.

    • Se il valore supera 255, lo forziamo a 255.

    • Se il valore è cambiato rispetto all'ultima lettura, lo stampiamo sulla seriale.

  5. Gestione del pulsante:

    • Controlliamo se il pulsante è stato premuto (da HIGH a LOW).

    • Se viene premuto, resettiamo l'encoder a 0 e stampiamo un messaggio sulla seriale.

    • Aggiungiamo un piccolo ritardo di 200 ms per evitare che il pulsante venga rilevato più volte per un singolo click.

Ora il codice permette di:
✔ Contare gli impulsi dell'encoder, mantenendo i valori tra 0 e 255.
✔ Stampare il valore solo quando cambia.
✔ Resettare il valore a 0 premendo il pulsante.