Modulo display OLED da 1,3 pollici, SH1106, encoder rotativo EC11, I2C

Il modulo combina su un'unica scheda un display OLED da 1.3 pollici con driver SH1106 e un encoder rotativo EC11 con pulsante incorporato, oltre a due pulsanti tattili aggiuntivi CONFIRM e BACK. È pensato per interfacce utente in progetti con microcontrollore, dove è necessario visualizzare un menu o un valore e dove l'utente deve navigare e confermare una selezione senza tastiera o touchscreen.

Il tutorial utilizza una scheda Arduino Uno, perché il modulo comunica tramite I2C e tramite ingressi digitali semplici, interfacce che Arduino Uno ha già disponibili, senza bisogno di WiFi o di memoria aggiuntiva.

Come funziona:

Il display è controllato dal driver SH1106, che gestisce una memoria interna di pixel organizzata su 128 x 64 punti e riceve comandi e dati tramite il protocollo I2C, sulle linee SDA e SCL, all'indirizzo 0x3C. Il microcontrollore non disegna direttamente sul pannello, ma invia blocchi di byte che rappresentano le pagine di memoria del display, operazione svolta automaticamente da una libreria compatibile SH1106.

L'encoder EC11 ha due contatti interni sfasati, TRA e TRB, che si chiudono a turno durante la rotazione. L'ordine in cui i due segnali passano dallo stato alto allo stato basso indica il senso di rotazione, e ogni coppia di transizioni corrisponde a un singolo passo meccanico, il modulo avendo 20 posizioni per una rotazione completa, ovvero circa 18 gradi per ogni passo, 360 gradi diviso 20 posizioni. Il codice legge queste transizioni tramite una routine di interrupt collegata a TRA e determina se TRB si trova nello stesso stato di TRA o in stato opposto, per sapere se la rotazione avviene in senso orario o antiorario.

Il pulsante incorporato dell'encoder, sul pin PSH, così come i pulsanti indipendenti CON e BAK, funzionano come semplici ingressi digitali che passano a livello basso quando vengono premuti, il modulo avendo già resistenze di pull-up integrate, e il codice legge il loro stato a brevi intervalli e applica un debounce software per eliminare le pressioni false causate dal contatto meccanico.

Cosa ti serve:

• 1 x Modulo display OLED da 1.3 pollici, SH1106, encoder rotativo EC11, I2C
• 1 x Scheda di sviluppo Uno R3 con WiFi ESP8266, compatibile Arduino
• 1 x Fili jumper maschio-femmina

Collegamento:

Il modulo si alimenta tra 3.3 V e 5 V, e i segnali I2C e gli ingressi digitali sono già compatibili con il livello logico di Arduino Uno, quindi non serve un convertitore di livello né resistenze di pull-up esterne per i pulsanti. Collegate prima l'alimentazione e la massa, poi le linee I2C, poi i segnali dell'encoder e dei pulsanti.

Librerie:

Installate dal Library Manager la libreria Adafruit SH110X, di Adafruit, per il controllo del display OLED con driver SH1106, insieme ad Adafruit GFX Library, di Adafruit, da cui dipende per disegnare testo e forme.

Il codice:

Il programma qui sotto mostra un menu con tre opzioni sul display OLED, che potete navigare ruotando l'encoder, confermare premendo PSH o CON e azzerare al primo elemento premendo BAK, mostrando allo stesso tempo messaggi di debug sul monitor seriale.

/*
 Tutorial sketch for the SH1106 1.3 inch OLED module with EC11 rotary encoder
 Board: Arduino Uno
 Wiring:
   Module VCC  -> Arduino 3.3V
   Module GND  -> Arduino GND
   Module SDA  -> Arduino A4
   Module SCL  -> Arduino A5
   Module TRA  -> Arduino D2 (interrupt pin)
   Module TRB  -> Arduino D3
   Module PSH  -> Arduino D4
   Module CON  -> Arduino D5
   Module BAK  -> Arduino D6
 Libraries (Library Manager):
   Adafruit SH110X by Adafruit
   Adafruit GFX Library by Adafruit
*/
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH110X.h>
#define OLED_ADDRESS 0x3C
#define OLED_WIDTH   128
#define OLED_HEIGHT  64
Adafruit_SH1106G display(OLED_WIDTH, OLED_HEIGHT, &Wire, -1);
const int PIN_TRA = 2;
const int PIN_TRB = 3;
const int PIN_PSH = 4;
const int PIN_CON = 5;
const int PIN_BAK = 6;
volatile int encoderDelta = 0;
volatile uint8_t lastStateA = 0;
const char *menuItems[] = {"Status", "Settings", "About"};
const uint8_t menuCount = sizeof(menuItems) / sizeof(menuItems[0]);
int menuIndex = 0;
unsigned long lastPshTime = 0;
unsigned long lastConTime = 0;
unsigned long lastBakTime = 0;
const unsigned long debounceDelay = 180;
// Interrupt routine, called on every change of PIN_TRA
void encoderISR() {
  uint8_t stateA = digitalRead(PIN_TRA);
  if (stateA == lastStateA) return;
  lastStateA = stateA;
  uint8_t stateB = digitalRead(PIN_TRB);
  if (stateB != stateA) {
    encoderDelta++;
  } else {
    encoderDelta--;
  }
}
// Generic debounced button check
bool buttonPressed(int pin, unsigned long &lastTime) {
  if (digitalRead(pin) == LOW) {
    unsigned long now = millis();
    if (now - lastTime > debounceDelay) {
      lastTime = now;
      return true;
    }
  }
  return false;
}
// Draws the menu with the current selection highlighted
void drawMenu() {
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SH110X_WHITE);
  display.setCursor(0, 0);
  display.print("Sigmanortec Demo");
  display.drawLine(0, 10, 127, 10, SH110X_WHITE);
  int y = 16;
  for (uint8_t i = 0; i < menuCount; i++) {
    if (i == menuIndex) {
      display.fillRect(0, y - 1, 128, 9, SH110X_WHITE);
      display.setTextColor(SH110X_BLACK);
    } else {
      display.setTextColor(SH110X_WHITE);
    }
    display.setCursor(4, y);
    display.print(menuItems[i]);
    y += 10;
  }
  display.display();
}
void setup() {
  Serial.begin(9600);
  pinMode(PIN_TRA, INPUT_PULLUP);
  pinMode(PIN_TRB, INPUT_PULLUP);
  pinMode(PIN_PSH, INPUT_PULLUP);
  pinMode(PIN_CON, INPUT_PULLUP);
  pinMode(PIN_BAK, INPUT_PULLUP);
  lastStateA = digitalRead(PIN_TRA);
  attachInterrupt(digitalPinToInterrupt(PIN_TRA), encoderISR, CHANGE);
  if (!display.begin(OLED_ADDRESS, true)) {
    Serial.println("OLED not found at address 0x3C");
    while (true) delay(1000);
  }
  Serial.println("OLED SH1106 + EC11 encoder demo ready");
  drawMenu();
}
void loop() {
  noInterrupts();
  int delta = encoderDelta;
  encoderDelta = 0;
  interrupts();
  if (delta > 0) {
    menuIndex = (menuIndex + 1) % menuCount;
    Serial.println("Encoder turned clockwise");
    drawMenu();
  } else if (delta < 0) {
    menuIndex = (menuIndex - 1 + menuCount) % menuCount;
    Serial.println("Encoder turned counter-clockwise");
    drawMenu();
  }
  if (buttonPressed(PIN_PSH, lastPshTime) || buttonPressed(PIN_CON, lastConTime)) {
    Serial.print("Selected menu item: ");
    Serial.println(menuItems[menuIndex]);
  }
  if (buttonPressed(PIN_BAK, lastBakTime)) {
    Serial.println("Back button pressed");
    menuIndex = 0;
    drawMenu();
  }
}

Come funziona il codice:

All'inizio del codice sono definiti l'oggetto display della classe Adafruit_SH1106G, l'indirizzo OLED_ADDRESS e i pin PIN_TRA, PIN_TRB, PIN_PSH, PIN_CON e PIN_BAK, insieme all'array menuItems che contiene le tre opzioni di menu e alla variabile menuIndex che memorizza l'opzione attualmente selezionata.

La funzione encoderISR è collegata come interrupt sul cambiamento di stato del pin PIN_TRA, confronta il nuovo stato con lastStateA e, se è cambiato, verifica lo stato di PIN_TRB per decidere se la variabile encoderDelta aumenta o diminuisce, accumulando così i passi di rotazione tra due passaggi attraverso loop.

La funzione buttonPressed riceve il pin da verificare e applica un debounce basato su millis, restituendo vero solo se il pin è a livello basso ed è trascorso abbastanza tempo dall'ultima pressione letta per quel pin.

La funzione drawMenu cancella lo schermo, scrive un titolo e una linea separatrice, poi scorre menuItems e disegna ogni opzione, evidenziando con un rettangolo pieno l'opzione che si trova nella posizione menuIndex.

Nel setup si inizializza la porta seriale, si configurano i pin come ingressi con pull-up, si legge lo stato iniziale di PIN_TRA in lastStateA, si collega l'interrupt encoderISR e si inizializza il display con display.begin usando OLED_ADDRESS, dopodiché viene disegnato il menu iniziale.

Nel loop si legge e si azzera encoderDelta in una zona protetta da noInterrupts e interrupts, si aggiorna menuIndex e si ridisegna il menu a ogni passo di rotazione, poi si verifica buttonPressed per PIN_PSH, PIN_CON e PIN_BAK per mostrare sul seriale l'opzione selezionata oppure il ritorno al primo elemento.

Risultato:

Aprite il monitor seriale a 9600 baud, ruotate l'encoder per vedere sullo schermo come si sposta la selezione tra le opzioni di menu, premete PSH o CON per confermare un'opzione e BAK per tornare alla prima opzione, osservando i messaggi corrispondenti sul monitor seriale.

OLED SH1106 + EC11 encoder demo ready
Encoder turned clockwise
Encoder turned clockwise
Selected menu item: Settings
Encoder turned counter-clockwise
Selected menu item: Status
Encoder turned clockwise
Encoder turned clockwise
Selected menu item: About
Back button pressed

Problemi frequenti:

Lo schermo rimane spento oppure display.begin restituisce falso, situazione in cui verificate prima i collegamenti SDA e SCL e l'alimentazione VCC e GND, poi confermate tramite scansione I2C che il modulo risponda all'indirizzo 0x3C.

Il menu salta più posizioni con una sola rotazione leggera dell'encoder, caso in cui TRA o TRB non sono collegati correttamente oppure i fili sono troppo lunghi e captano rumore, usate fili corti e verificate che entrambi i segnali arrivino sui pin digitali indicati.

Un pulsante sembra essere premuto più volte con una sola pressione, segno che l'intervallo di debounce è troppo piccolo per quel contatto meccanico, aumentate leggermente il valore di debounceDelay nel codice.

La rotazione dell'encoder non produce alcuna reazione, verificate che l'interrupt sia collegato correttamente sul pin PIN_TRA e che questo sia un pin capace di interrupt sulla scheda utilizzata, su Arduino Uno solo D2 e D3 offrono questa funzione.

Nulla appare sul monitor seriale, confermate che la velocità scelta nel monitor sia 9600 baud, la stessa impostata in Serial.begin, e che la scheda sia collegata sulla porta corretta.

Limitazioni e consigli:

Lo schermo monocromatico da 1.3 pollici e la risoluzione di 128 x 64 pixel limitano il numero di righe di menu visualizzate chiaramente contemporaneamente, per menu più lunghi è utile lo scorrimento o la suddivisione su più pagine. L'encoder offre 20 posizioni per rotazione, sufficienti per regolazioni fini di parametri, ma senza sensore di posizione assoluta, quindi all'avvio il valore corrente deve essere inizializzato dal codice o letto da una memoria non volatile se si desidera conservare l'ultima impostazione. Partendo da questo esempio si può costruire un menu con più livelli, la visualizzazione di valori letti da sensori o il controllo di moduli esterni tramite selezioni confermate con PSH o CON.