Realizziamo una cornice digitale con ESP32 Miner Display LCD di Elecrow

Nel precedente articolo abbiamo analizzato il modulo ESP32 Miner Display TFT 2.8” di Elecrow, un dispositivo che si distingue per la perfetta integrazione tra potenza di calcolo e interfaccia grafica pronta all’uso, pensata per applicazioni rapide e versatili.
In questo nuovo progetto faremo un passo in avanti: trasformeremo questo display in una cornice digitale smart con ESP32 e Display LCD, capace di mostrare centinaia di fotografie in modo dinamico e ordinato.
L’obiettivo è quello di creare un dispositivo compatto e sempre aggiornabile, che sostituisca le tradizionali stampe fotografiche con un’esperienza digitale continua. Un modo semplice ma efficace per dare nuova vita ai ricordi, direttamente sulla scrivania o in casa, sfruttando tutta la flessibilità dell’ecosistema ESP32.

Disclaimer: ho ricevuto questo prodotto gratuitamente in cambio di una recensione. Tutte le opinioni espresse in questa recensione sono mie e si basano sulla mia esperienza personale con il prodotto.
Il mio feedback non è stato influenzato dall’azienda o da terze parti

Caratteristiche principali del display

Il display Elecrow ESP32 Mine LCD-2.8 “ è un modulo HMI (Human Machine Interface) dotato di un display TFT-LCD da 2,8″ con risoluzione 320 × 240 pixel e tecnologia touch resistiva.
Al suo interno è integrato un modulo ESP32-32E-N4 (spesso indicato come ESP32-WROOM-32E-N4) è un modulo microcontrollore dual-core prodotto da DOIT (o compatibile) basato sul chip Espressif ESP32-D0WD-V3.

Alcune Features

• Supporto multi-piattaforma per ambienti di sviluppo embedded, inclusi Arduino IDE, Espressif IDF, Lua RTOS, ESPHome (Home Assistant), PlatformIO e MicroPython.
• Compatibilità con la libreria grafica LVGL, con demo integrata e esempi applicativi per ambiente Arduino.
• Display TFT LCD da 2,8″ con risoluzione 320 × 240 pixel, controller grafico ILI9341V.
• Slot integrato per scheda TF (microSD) e numerose interfacce di espansione: USB, interfaccia audio per altoparlante, connettore per batteria e GPIO multipli, per applicazioni plug-and-play.

Riassunto caratteristiche

 Com’è fatto l’ESP32 Miner Display LCD-2.8″di Elecrow

L’ ESP32 Miner Display LCD-2.8″di Elecrow si presenta come un modulo delle dimensioni di 78 x 51 mm per uno spessore di 14 mm di altezza. Il PCB ha un case in acrilico per la protezione del display e dei componenti elettronici interni.

Non è necessario aprirlo poiché tutti i connettori, i pulsanti di Reset e di Boot, sono accessibili anche con il plexiglas montato, e la loro funzione è visibile attraverso il plexiglas trasparente

Dove trovare l’ ESP32 Miner Display LCD-2.8″

L’ ESP32 Miner Display LCD-2.8″ può essere acquistato presso il sito della Elecrow, il suo costo al momento della scrittura del post si aggira sui  26 €

Il display è arrivato ben confezionato in una scatola e avvolta a sua volta in un foglio millebolle.

Nella scatola  troviamo:

• n° 2 modulo ESP32 2.8” Miner LCD Display già assemblato avvolto in una foglio millebolle
• n° 2 cavi Crowtail/Grove a 4 pin per la connessione tramite UART/I²C
• n° 2 penne per pannello touch resistivo

NOTA: nelle foto del sito, la foto della confezione sono mostrati due piccoli cacciaviti per lo smontaggio della custodia in acrilico, non presenti nella confezione e comunque non citati nell’elenco.

Ambienti di sviluppo e librerie

Nella pagina wiki dedicata al modulo viene riportata la compatibilità ai seguenti ambienti di sviluppo:  Arduino IDE, PlatformIO, ESPHome, MicroPython, ESP-IDF ed è compatibile con la libreria grafica LVGL .
Supporta anche openHASP , fornendo una soluzione efficiente e affidabile per il mining di criptovalute.

Arduino IDE

Arduino IDE, (Integrated Development Environment) è un ambiente di sviluppo open-source progettato per semplificare la programmazione e il caricamento di codice su microcontrollori Arduino e compatibili. È un software fondamentale per chiunque voglia lavorare con la piattaforma Arduino e con dispositivi di elettronica embedded. (Integrated Development Environment) è un ambiente di sviluppo open-source progettato per semplificare la programmazione e il caricamento di codice su microcontrollori Arduino e compatibili. È un software fondamentale per chiunque voglia lavorare con la piattaforma Arduino e con dispositivi di elettronica embedded.

Installazione e configurazione

Vediamo ora come avviene il flashing  tramite  l’IDE di Arduino.
Il dispositivo viene fornito con un firmware demo. Per cui appena collegato saranno mostrate le sue capacità.
Per effettuare i test e utilizzare il display è sufficiente seguire le indicazioni fornite da Elecrow.
Sul loro sito è possibile trovare:

• Pagina Wiki di Elecrow con guida all’installazione
• Pagina Wiki di Elecrow con esempi di utilizzo
• Repository GitHub con codice sorgente e documentazione

Per l’installazione eseguire questi passaggi:

1 – Scaricare i file di libreria già preparate da Elecrow in formato zip da questo link,  sarà poi necessario decomprimerle. Il mio consiglio è quello di creare un apposita cartella, per esempio:

C:\Users\vostronome\Documents\Arduino 2.8inch-ESP32-LCD-Display

in modo da non avere problemi con quelle che avete già caricato. Fatto questo sarà necessario indicare all’IDE la posizione delle librerie. Per tornare ad utilizzare le vostre librerie, sarà sufficiente indicare la precedente posizione. Ricordarsi di riavviare l’IDE, dopo la modifica per renderla attiva.

2 – Se non l’avete già fatto,  caricare tramite il Board Manager il pacchetto relativo alle schede ESP32

3 – Scegliere il modello di scheda tramite Arduino IDE , per cui apriremo uno sketch con la IDE di Arduino, e andremo nella scheda Strumenti -> Scheda e selezioneremo tra le esp32 la ESP32S3-WROOM-DA Module

3 – Colleghiamo quindi al PC  il display tramite il cavo ricevuto e indichiamo all’IDE la porta a cui è collegato il modulo

Come realizzare una cornice digitale con ESP32 e Display LCD

Quella che andremo a realizzare utilizzerà:

• l’ESP32
• Il display LCD-2.8″, TFT 320×240 (driver tipo ILI9341)
• l’Interfaccia per scheda MicroSD tramite bus SPI
• la GPIO A/D – Espansione porte a cui collegheremo un tasto Pulsante (su GPIO 25)  per cambiare immagine

Schema della TF Card (MicroSD)

Permette l’Interfaccia per scheda MicroSD tramite bus SPI. Consente storage esterno per log, file multimediali o dati applicativi, integrandosi facilmente con l’ESP32.
Formato dallo Slot TF Card, le linee SPI (CS, CLK, MOSI, MISO) collegate ai pin IO: 5, 23,18,19.
Troviamo poi le Resistenze di pull-up R16, 17, 23, 24, 67 da 10 KΩ e due condensatori di filtraggio sulle linee di alimentazione C10  sulla line 3.3V da 100 nF e C54 sulla linea GND da 4.7 μF.

Schema della GPIO A/D – Espansione porte

Circuito di espansione delle linee GPIO analogiche/digitali dell’ESP32 verso l’esterno.
Permette di accedere direttamente agli ingressi analogici dell’ESP32, Pin IO25 e IO32, utili per sensori esterni o segnali di controllo, con filtraggio base per ridurre il rumore. I suoi componenti principali sono : Connettore GPIO, Linee ADC dedicate, condensatori di filtro C13 da 100 nF.

Materiale occorrente

Il materiale occorrente per la nostra cornice ESP32 con Display LCD è riportato sotto:

Display Elecrow ESP32 Mine LCD-2.8	Modulo digitale (pulsante) Codice Ks0029
Cavo jumper divisibile da 4 pin Crowtail a femmina	Scheda MicroSD

Schema dei collegamenti

Descrizione del programma

Lo sketch che segue permette di trasformare il nostro ESP32 con Display LCD TFT 320×240 in una semplice cornice digitale.
Le immagini in formato JPG vengono caricate dalla scheda SD e visualizzate sul display in modalità slideshow automatico, con la possibilità di passare manualmente all’immagine successiva tramite un pulsante.
NOTA: per il funzionamento del programma sono utilizzate alcune librerie. Queste, come altre , utilizzate dalla scheda ESP32 con Display LCD possono essere scaricate dal sito Elecrow a questo link.

Funzionamento
All’avvio il programma:

1. Include le librerie per il funzionamento del programma.
2. Inizializza la comunicazione seriale per eventuali messaggi di debug.
3. Configura il pulsante collegato al pin GPIO 25 utilizzando la resistenza di pull-up interna.
4. Attiva la retroilluminazione del display tramite il pin GPIO 27.
5. Inizializza il display TFT e lo imposta in modalità orizzontale.
6. Inizializza l’interfaccia SPI e monta la scheda microSD.
7. Scansiona la directory principale della SD alla ricerca di file con estensione .jpg o .jpeg.
8. Memorizza i nomi delle immagini trovate in un array e visualizza la prima immagine disponibile.

Visualizzazione delle immagini
La funzione drawJPEG() utilizza la libreria JPEGDecoder per decodificare l’immagine JPG e trasferirla sul display TFT.

Al termine della visualizzazione viene aggiunta una riga informativa nella parte inferiore dello schermo:

 WWW.ADRIROBOT.IT – VAULT 31

Il programma può essere facilmente esteso aggiungendo effetti di transizione, visualizzazione casuale delle immagini, orologio, informazioni ambientali.

Cambio immagine manuale
Premendo il pulsante collegato al GPIO 25 viene visualizzata immediatamente l’immagine successiva presente nella scheda SD.
Un piccolo ritardo di 200 ms viene utilizzato per eliminare eventuali rimbalzi meccanici del pulsante (debounce).

Slideshow automatico
In assenza di pressione del pulsante, il programma cambia automaticamente immagine ogni 5 secondi (SLIDESHOW_INTERVAL).
Una volta raggiunta l’ultima immagine disponibile, la visualizzazione riparte dalla prima.

Formato immagini consigliato
Per ottenere le migliori prestazioni si consiglia di utilizzare immagini:

• Formato JPG/JPEG
• Risoluzione 320×240 pixel
• Modalità colore RGB a 24 bit
• Compressione JPEG standard (non progressiva)

In questo modo il caricamento delle immagini risulta più rapido e l’utilizzo della memoria dell’ESP32 viene ridotto.

Scarica immagini di test

Codice programma

#include 
#include 
#include 
#include 

#define SD_MOSI 23
#define SD_MISO 19
#define SD_SCK  18
#define SD_CS   5

#define BUTTON_PIN 25
#define TFT_BL     27      // Retroilluminazione

#define SLIDESHOW_INTERVAL 5000  // 5 secondi

TFT_eSPI tft = TFT_eSPI();

File root;
String fileList[50];
int fileCount = 0;
int currentImage = 0;
unsigned long lastSlideChange = 0;

// ----- Funzioni -----
void listFiles() {
  root = SD.open("/");
  File file = root.openNextFile();

  while (file) {
    String name = file.name();
    name.toLowerCase();
    if (name.endsWith(".jpg") || name.endsWith(".jpeg")) {
      fileList[fileCount++] = "/" + String(file.name());
    }
    file = root.openNextFile();
  }
}

void drawJPEG(const char *filename) {
  tft.fillScreen(TFT_BLACK);
  JpegDec.decodeSdFile(filename);

  uint16_t *pImg;
  uint16_t mcu_w = JpegDec.MCUWidth;
  uint16_t mcu_h = JpegDec.MCUHeight;

  uint32_t max_x = JpegDec.width;
  uint32_t max_y = JpegDec.height;

  while (JpegDec.read()) {
    pImg = JpegDec.pImage;
    int mcu_x = JpegDec.MCUx * mcu_w;
    int mcu_y = JpegDec.MCUy * mcu_h;

    if (mcu_x + mcu_w <= max_x && mcu_y + mcu_h <= max_y) 
       tft.pushImage(mcu_x, mcu_y, mcu_w, mcu_h, pImg); }
 
// Overlay HUD testo tft.setTextSize(1); 
tft.setTextColor(TFT_GREEN, TFT_BLACK); 
tft.setCursor(5, 220); 
tft.println("WWW.ADRIROBOT.IT - VAULT 31"); 
} 
void showImage(int index) { 
if (fileCount == 0) return; 
drawJPEG(fileList[index].c_str());
 } 

void nextImage() { 
currentImage++; 
if (currentImage >= fileCount) currentImage = 0;
  showImage(currentImage);
}

// ----- Setup -----
void setup() {
  Serial.begin(115200);

  // Pin
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(TFT_BL, OUTPUT);
  digitalWrite(TFT_BL, HIGH);  // accende retroilluminazione

  // Display
 tft.init();
tft.setRotation(1);
tft.setSwapBytes(true);   // FONDAMENTALE per JPEG
tft.fillScreen(TFT_BLACK);

  // SD
  SPI.begin(SD_SCK, SD_MISO, SD_MOSI);
  if (!SD.begin(SD_CS, SPI)) {
    tft.drawString("SD ERROR", 100, 120);
    while (1);
  }

  listFiles();

  if (fileCount == 0) {
    tft.drawString("NO JPG FOUND", 80, 120);
    while (1);
  }

  showImage(currentImage);
  lastSlideChange = millis();
}

// ----- Loop -----
void loop() {
  // ----- Pulsante manuale -----
  static bool lastState = HIGH;
  bool currentState = digitalRead(BUTTON_PIN);

  if (lastState == HIGH && currentState == LOW) {
    delay(200); // debounce
    nextImage();
    lastSlideChange = millis(); // reset timer slideshow
  }
  lastState = currentState;

  // ----- Slideshow automatico -----
  if (millis() - lastSlideChange >= SLIDESHOW_INTERVAL) {
    nextImage();
    lastSlideChange = millis();
  }
}

Idee per il futuro

Per completare il progetto della nostra cornice ESP32 con Display LCD , si potrebbe realizzare una pratica custodia con supporto utilizzando una stampante 3D. Il contenitore potrebbe ospitare non solo il display e il pulsante di controllo, ma anche una batteria ricaricabile con relativo circuito di gestione e ricarica (ad esempio basato su TP4056). In questo modo il dispositivo diventerebbe completamente portatile e assumerebbe l’aspetto di una vera e propria cornice digitale, capace di visualizzare immagini senza la necessità di un’alimentazione esterna continua.

Per la progettazione della custodia è possibile utilizzare diversi software gratuiti e di facile utilizzo, tra cui:

• FreeCAD – CAD parametrico open source, ideale per progettare componenti tecnici e custodie.
• Tinkercad – applicazione web gratuita particolarmente adatta ai principianti.
• Onshape Free Plan – potente CAD cloud-based disponibile gratuitamente per progetti pubblici.
• Fusion for Personal Use – versione gratuita per uso personale e hobbistico del noto software CAD Autodesk.
• OpenSCAD – ambiente di modellazione 3D basato su codice, molto apprezzato dai maker per la progettazione parametrica.

Una custodia personalizzata permetterebbe inoltre di integrare supporti da tavolo, sistemi di aggancio a parete e vani dedicati all’elettronica, migliorando sia l’estetica sia la praticità del progetto finale.

Altri prodotti Elecrow recensiti