Il 2.8-inch ESP32 Solo Miner LCD Display di Elecrow è un modulo integrato compatto che combina un touchscreen TFT a colori con un microcontrollore ESP32-WROOM-32 per fornire sia un’interfaccia utente sia capacità di elaborazione standalone su un’unica scheda.
Il display resistivo da 320 × 240 pixel è gestito da un controller ILI9341V e dal processore dual-core LX6 ESP32 integrato. Integra inoltre Wi-Fi 2.4 GHz e Bluetooth. La scheda dispone anche di uno slot per schede TF, molteplici porte I/O, interfacce USB-C e UART, e un connettore per altoparlante/batteria.
Quando utilizzato con firmware di mining compatibili come NMMiner o NerdMiner, il dispositivo può partecipare al mining di criptovalute in modalità solo a scopo didattico. Non aspettarti di generare alcun guadagno con esso ; )
In questo tutorial ci concentreremo sulla programmazione del display con Arduino IDE usando la libreria grafica TFT_eSPI. Imparerai anche come usare la porta GPIO, l’altoparlante e il lettore di schede SD.
Componenti necessari
I componenti necessari includono il display e, se vuoi collegare hardware esterno, alcuni cavi, resistori, LED e una breadboard saranno utili.
Display LCD 2.8″ ESP32 Solo Miner
Set di cavi Dupont
Breadboard
Kit di resistori e LED
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Caratteristiche del display 2.8″ ESP32 Solo Miner LCD
Il 2.8″ ESP32 Solo Miner è costruito attorno al sistema su modulo ESP32-WROOM-32-N4, che integra un microprocessore dual-core Xtensa LX6 capace di raggiungere fino a 240 MHz. Il core ESP32 fornisce connettività Wi-Fi (802.11 b/g/n, 2.4 GHz) e Bluetooth (Bluetooth 5.0/BLE) nativamente sul chip.
Display e interfaccia touch
Il modulo presenta un pannello TFT-LCD da 2.8 pollici con risoluzione 320 × 240 pixel e tipo di display TN (Twisted Nematic). Il display utilizza un driver ILI9341V che comunica con l’ESP32 tramite interfaccia SPI, responsabile del controllo dei pixel, della resa dei colori e dell’illuminazione retroilluminata. L’immagine sotto mostra il fronte del modulo display:
Un overlay touch resistivo è laminato sulla superficie LCD, permettendo l’input di coordinate tramite pressione. Il pannello resistivo accetta sia stilo che dito e si interfaccia con l’ESP32 tramite linee analogiche/digitali dedicate gestite da un controller touch onboard (XPT2046).
Alimentazione e specifiche fisiche
La scheda può essere alimentata tramite una fonte esterna DC da 5 V fino a 2 A per un funzionamento stabile sotto carico, oppure con una batteria Li-ion/LiPo da 3.7–4.2 V collegata al connettore batteria integrato. Include pulsanti fisici BOOT e RESET per il controllo utente durante lo sviluppo o il flashing del firmware.
L’area attiva del display misura circa 43.2 mm per 56.7 mm, e il peso netto della scheda è di circa 61 g, rendendola compatta per applicazioni embedded o portatili.
Interfacce periferiche e I/O
Oltre al display e al touch, la scheda espone molteplici interfacce periferiche. Uno slot per schede TF (microSD) consente lo storage locale o il caricamento di firmware/dati. Le interfacce di comunicazione includono I2C, UART0 e UART1 per integrazione seriale con sensori o controller esterni.
Il connettore USB-C (UART0) funziona sia come ingresso di alimentazione sia come interfaccia USB-to-TTL per il flashing del firmware e il debug seriale.
Un header GPIO generico espone ulteriori linee digitali I/O, mentre una porta dedicata per altoparlante supporta semplici segnali audio. I connettori usano pin header standard e micro-connettori PH2.0/HY2.0. La tabella seguente riassume quali pin GPIO sono assegnati alle interfacce IO, all’altoparlante e al lettore di schede SD:
| Display | GPIO |
|---|---|
| GPIO_D | IO25; IO32 |
| UART | RX(IO16); TX(IO17) |
| I2C | SDA(IO22); SCL(IO21) |
| SPK | IO26 |
| Slot scheda SD (SPI) | MOSI(IO23); MISO(IO19); SDK(IO18); CS(IO5) |
Supporto allo sviluppo
La scheda supporta diversi ambienti di sviluppo come Arduino IDE, Espressif IDF, Lua RTOS e Micro Python, ed è compatibile con il LVGL graphics library. Tuttavia, in questo tutorial ci concentreremo su Arduino IDE e la TFT_eSPI graphics library.
Specifiche tecniche
La tabella seguente riassume le specifiche tecniche del display 2.8″ ESP32 Solo Miner LCD:
| Categoria | Specifiche |
|---|---|
| Controller principale | ESP32-WROOM-32-N4 |
| Architettura CPU | Dual-core Xtensa LX6 |
| Frequenza massima di clock | Fino a 240 MHz |
| Connettività wireless | Wi-Fi 802.11 b/g/n (2.4 GHz), Bluetooth 5.0 / BLE |
| Dimensione display | TFT LCD da 2.8 pollici |
| Risoluzione display | 320 × 240 pixel |
| Tipo di display | TN TFT |
| Driver display IC | ILI9341V |
| Pannello touch | Touchscreen resistivo (controller XPT2046) |
| Interfaccia display | SPI |
| Storage esterno | Slot per schede MicroSD (TF) |
| Alimentazione (via cavo) | 5 V DC tramite USB-C |
| Alimentazione (batteria) | 3.7–4.2 V Li-ion / LiPo |
| Controlli utente | Pulsanti BOOT e RESET |
| Interfaccia audio | Connettore altoparlante (amplificatore SC8002B) |
| Interfacce di comunicazione | UART0, UART1, I2C, GPIO |
| Interfaccia di programmazione | USB-C (USB-to-TTL) |
| Piattaforme di sviluppo supportate | Arduino IDE, ESP-IDF, PlatformIO, MicroPython, Lua RTOS, ESPHome |
| Temperatura di esercizio | −20 °C a +70 °C |
| Temperatura di stoccaggio | −30 °C a +80 °C |
| Area attiva display | 43.2 mm × 56.7 mm |
| Peso approssimativo | ~61 g |
Installare il core ESP32
Il display 2.8″ ESP32 Solo Miner LCD si basa sull’ESP32. Per programmarlo devi installare il core ESP32 nel tuo Arduino IDE.
Inizia aprendo la finestra Preferenze selezionando “Preferences…” dal menu “File”. Si aprirà la finestra Preferenze mostrata sotto.
Nella scheda Settings troverai una casella di testo in fondo alla finestra etichettata “Additional boards manager URLs“:
In questo campo incolla il seguente URL:
https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json
Questo permetterà all’Arduino IDE di sapere dove trovare le librerie core ESP32. Successivamente installeremo le schede ESP32 tramite il Boards Manager.
Apri il Boards Manager tramite “Tools -> Boards -> Board Manager”. Vedrai il Boards Manager apparire nella barra laterale sinistra. Digita “ESP32” nel campo di ricerca in alto e dovresti vedere due tipi di schede ESP32; le “Arduino ESP32 Boards” e le schede “esp32 by Espressif”. Vogliamo le “esp32 libraries by Espressif”. Clicca sul pulsante INSTALL e attendi che il download e l’installazione siano completati.
Sto usando la versione 3.3.5 qui, ma qualsiasi altra versione 3.x dovrebbe funzionare per questo progetto. Se hai bisogno di più informazioni leggi il nostro Install ESP32 core in Arduino IDE tutorial.
Selezione della scheda
Devi anche selezionare una scheda ESP32. Nel caso del display 2.8″ ESP32 Solo Miner LCD, puoi scegliere la scheda generica “ESP32S3 Dev Module”. Per farlo, clicca sul menu a tendina e poi su “Select other board and port…”:
Si aprirà una finestra dove puoi digitare “esp32s3 dev” nella barra di ricerca. Vedrai la scheda “ESP32S3 Dev Module” sotto Boards. Cliccaci sopra, seleziona la porta COM per attivarla e poi clicca OK:
Nota che devi collegare la scheda tramite cavo USB al computer prima di poter selezionare una porta COM.
Testare i GPIO
La scheda Solo Miner espone due pin GPIO sulla porta GPIO_D. In questo esempio implementiamo un semplice Blink programma per testare la porta GPIO.
Poiché il display non ha LED integrati, collegheremo e controlleremo due LED esterni. Lo schema di collegamento sotto mostra come connettere i due LED alla porta:
I pin della porta GPIO_D sono IO25; IO32, 3.3V, GND. Non ci serve l’uscita 3.3V, solo i due pin GPIO e la massa. Quando costruisci il circuito, non dimenticare i resistori da 220Ω per limitare la corrente ai LED e assicurati che la massa sia collegata correttamente.
Dopo puoi caricare il seguente codice che fa lampeggiare i due LED in modo alternato. Stampa anche sul monitor seriale, così se ci sono problemi di collegamento puoi almeno verificare che il programma stia girando. Assicurati che la velocità del monitor seriale sia impostata a 115200.
const int led1 = 25;
const int led2 = 32;
void setup() {
Serial.begin(115200);
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
}
void loop() {
Serial.println("on");
digitalWrite(led1, HIGH);
digitalWrite(led2, LOW);
delay(1000);
Serial.println("off");
digitalWrite(led1, LOW);
digitalWrite(led2, HIGH);
delay(1000);
}
Configurare la libreria TFT_eSPI
Se vuoi mostrare qualcosa sul display ti servirà una libreria grafica. Useremo la libreria TFT_eSPI di Bodmer. Per installarla, apri il LIBRARY MANAGER, digita “TFT_eSPI” nella barra di ricerca e clicca sul pulsante INSTALL. L’immagine sotto mostra come appare un’installazione riuscita:
Successivamente dobbiamo creare un file chiamato tft_setup.h con i parametri corretti per il display. Questo file deve far parte di ogni progetto Arduino che usa il display.
Ecco come funziona nel dettaglio. Prima crea un nuovo progetto Arduino e salvalo come “tft_test“, per esempio. Questo creerà una cartella tft_test con un file tft_test.ino al suo interno:
In questa cartella, crea un file chiamato “tft_setup.h“. Il nome deve essere esatto! La tua cartella progetto dovrebbe apparire così:
tft_setup.hNel tuo Arduino IDE ora dovresti vedere due tab; tft_test.ino e tft_setup.h su cui puoi cliccare per modificare i file.
tft_test.ino and tft_setup.hNel file tft_setup.h copia le seguenti impostazioni dei parametri:
#define ILI9341_DRIVER #define TFT_WIDTH 320 #define TFT_HEIGHT 240 #define TFT_BACKLIGHT_ON HIGH #define TFT_BL 27 #define TFT_MISO 4 #define TFT_MOSI 13 #define TFT_SCLK 14 #define TFT_CS 15 #define TFT_DC 2 #define TFT_RST -1 #define TOUCH_CS 33 #define SPI_FREQUENCY 27000000 #define SPI_TOUCH_FREQUENCY 2500000 #define SPI_READ_FREQUENCY 16000000 #define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH #define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters #define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters #define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm #define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:-. #define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-. #define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts #define SMOOTH_FONT
Nel file tft_test.ino
#include "tft_setup.h"
#include"TFT_eSPI.h"
TFT_eSPI tft = TFT_eSPI();
void setup(void) {
tft.init();
tft.setRotation(3);
tft.fillScreen(TFT_BLACK);
}
void loop() {
tft.setTextColor(TFT_WHITE, TFT_BLACK);
tft.setTextSize(2);
tft.setTextDatum(MC_DATUM);
tft.drawString("Makerguides", tft.width() / 2, tft.height() / 2);
delay(5000);
}
Nota che tft_setup.h è incluso in cima al programma. Il codice è semplice da capire. Creiamo un oggetto TFT_eSPI e lo inizializziamo nella funzione setup(). Nella funzione loop impostiamo il colore del testo, la dimensione, l’allineamento e disegniamo la stringa “Makerguides” al centro del display TFT.
Se compili e carichi questo programma, dovresti vedere il seguente output sul display:
Nelle sezioni successive imparerai come leggere i dati touch.
Rilevare eventi touch
Il codice seguente mostra come rilevare eventi touch. Disegna un piccolo cerchio giallo ovunque tocchi lo schermo:
#include "tft_setup.h"
#include "TFT_eSPI.h"
TFT_eSPI tft = TFT_eSPI();
uint16_t cal[5] = { 210, 3484, 285, 3511, 7 };
void setup() {
tft.begin();
tft.setRotation(3);
tft.setTouch(cal);
tft.fillScreen(TFT_BLACK);
}
void loop() {
static uint16_t x = 0, y = 0;
if (tft.getTouch(&x, &y)) {
tft.fillCircle(x, y, 5, TFT_YELLOW);
}
delay(100);
}
Come prima includiamo tft_setup.h e la libreria TFT_eSPI. Successivamente creiamo l’oggetto display e un array con i dati di calibrazione. L’array cal contiene essenzialmente le coordinate degli angoli e l’orientamento del touchscreen. Ti mostrerò nella prossima sezione come trovare i dati di calibrazione, ma quelli forniti qui dovrebbero funzionare per iniziare.
Nella funzione setup inizializziamo lo schermo, impostiamo l’orientamento, i dati di calibrazione touch e riempiamo lo schermo di nero.
Nella funzione loop chiamiamo continuamente getTouch() per ottenere le coordinate di un evento touch. La funzione restituisce true se è stato rilevato un tocco. In tal caso disegniamo un cerchio giallo con raggio di 5 pixel alle coordinate del tocco. Ecco un esempio di come appare sullo schermo:
Calibrare il touchscreen
Il touchscreen è posizionato sopra il display e ha una risoluzione, posizione e orientamento diversi rispetto al display. Per far corrispondere la posizione degli eventi touch con quella sul display dobbiamo calibrare il touchscreen misurando le coordinate degli angoli e l’orientamento.
Queste impostazioni sono memorizzate nell’array di calibrazione. Esegui il seguente programma per estrarre i parametri di calibrazione e stamparli sul Monitor Serial:
#include "tft_setup.h"
#include "TFT_eSPI.h"
TFT_eSPI tft = TFT_eSPI();
void setup() {
Serial.begin(115200);
tft.begin();
tft.setRotation(3);
}
void loop() {
static uint16_t cal[5];
tft.fillScreen(TFT_BLACK);
tft.setCursor(20, 0);
tft.setTextFont(2);
tft.setTextSize(1);
tft.setTextColor(TFT_WHITE, TFT_BLACK);
tft.print("Touch corners ... ");
tft.calibrateTouch(cal, TFT_YELLOW, TFT_BLACK, 15);
tft.println("done.");
Serial.printf("cal: {%d, %d, %d, %d, %d}\n",
cal[0], cal[1], cal[2], cal[3], cal[4]);
delay(10000);
}
Quando esegui questo programma ti chiederà di toccare i quattro angoli dello schermo e poi stamperà i cinque parametri di calibrazione (coordinate degli angoli e orientamento dello schermo). Durante la calibrazione il display dovrebbe apparire così:
Sul Monitor Serial dovresti vedere qualcosa di simile stampato dopo aver toccato i quattro angoli:
cal: { 210, 3484, 285, 3511, 7 }
La calibrazione si ripete ogni 10 secondi, così puoi fare più tentativi per ottenere i parametri più precisi. Usa poi questi parametri per inizializzare il display nella funzione setup:
...
uint16_t cal[5] = { 210, 3484, 285, 3511, 7 };
void setup() {
...
tft.setTouch(cal);
...
}
Nelle prossime due sezioni ti mostrerò rapidamente come generare suoni e come usare il lettore di schede SD.
Riprodurre suoni sull’altoparlante
Il codice seguente mostra come riprodurre un suono sull’altoparlante. Produce un tono a 440Hz per un secondo con una pausa di un secondo:
const int speakerPin = 26;
void setup() {
pinMode(speakerPin, OUTPUT);
}
void loop() {
tone(speakerPin, 440); // 440Hz tone
delay(1000);
noTone(speakerPin);
delay(1000);
}
Nota che dovrai collegare un altoparlante esterno (3W, 4-8 Ohm) al connettore altoparlante della scheda display, poiché la scheda non ha altoparlante o buzzer integrati.
Rilevare il tipo di scheda SD
Questo ultimo esempio di codice mostra come usare il lettore di schede SD integrato nel display per rilevare una scheda SD:
#include "FS.h"
#include "SD.h"
#include "SPI.h"
void setup() {
Serial.begin(115200);
if (!SD.begin()) {
Serial.println("Card Mount Failed");
return;
}
uint8_t cardType = SD.cardType();
if (cardType == CARD_NONE) {
Serial.println("No SD card attached");
} else if (cardType == CARD_MMC) {
Serial.println("MMC Card");
} else if (cardType == CARD_SD) {
Serial.println("Standard SD Card");
} else if (cardType == CARD_SDHC) {
Serial.println("SDHC Card");
} else {
Serial.println("Unknown Card Type");
}
}
void loop() { }
Se ti servono più informazioni ed esempi sui lettori di schede SD dai un’occhiata al SD Card Module with ESP32 tutorial.
Schema elettrico
Per comodità ecco le parti più importanti del Schematics per la scheda display 2.8″ ESP32 Solo Miner LCD:
Conclusione
Questo tutorial ti ha mostrato come usare il display, il touchscreen, l’altoparlante e il lettore di schede SD del 2.8-inch ESP32 Solo Miner LCD Display. Per informazioni aggiuntive consulta il Github repo e il Wiki su Elecrow.
La scheda Solo Miner ESP32 Display include praticamente tutto il necessario per un progetto con display. Comprende un touchscreen TFT, un ESP32, uno slot per schede TF, un connettore batteria con caricatore, un’interfaccia altoparlante e un’interfaccia I2C.
Tuttavia, questo significa anche che i pin GPIO liberi sono limitati a soli due. Ma dato che c’è un’interfaccia I2C, puoi usare un espansore GPIO per aggiungere più GPIO. Dai un’occhiata al nostro tutorial Using GPIO Expander MCP23017 With Arduino.
L’hardware del display 2.8″ ESP32 Solo Miner è essenzialmente identico a quello del CrowPanel 2.8″ ESP32 Display. Consulta il CrowPanel 2.8″ ESP32 Display : Easy Setup Guide tutorial per maggiori informazioni.
Per esempi di applicazioni degli ESP32 Display vedi i nostri tutorial Digital Clock with CrowPanel 3.5″ ESP32 Display, Parking sensor with CrowPanel ESP32 Display e Digital Timer Switch with CrowPanel ESP32 Display.
Se hai domande sentiti libero di lasciarle nella sezione commenti.
Buon divertimento con il tinkering ; )
