El 2.8-inch ESP32 Solo Miner LCD Display de Elecrow es un módulo integrado compacto que combina una pantalla táctil TFT a color con un microcontrolador ESP32-WROOM-32 para ofrecer tanto interfaz de usuario como capacidad de procesamiento independiente en una sola placa.
La pantalla táctil resistiva de 320 × 240 píxeles está controlada por un controlador ILI9341V y el CPU dual-core LX6 del ESP32 a bordo. También integra Wi-Fi de 2.4 GHz y Bluetooth. Además, la placa dispone de una ranura para tarjeta TF, múltiples puertos I/O, interfaces USB-C y UART, y un conector para altavoz/batería.
Cuando se usa con firmware de minería compatible como NMMiner o NerdMiner, el dispositivo puede participar en minería de criptomonedas en modo solo con fines educativos. No esperes generar ingresos con él ; )
En este tutorial nos centraremos en programar la pantalla con Arduino IDE usando la biblioteca gráfica TFT_eSPI. También aprenderás a usar el puerto GPIO, el altavoz y el lector de tarjetas SD.
Partes necesarias
Las partes necesarias incluyen la pantalla y, si quieres conectar hardware externo, algunos cables, resistencias, LEDs y una placa de pruebas serán útiles.
Pantalla LCD 2.8″ ESP32 Solo Miner
Juego de cables Dupont
Placa de pruebas
Kit de resistencias y LEDs
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.
Características de la pantalla LCD 2.8″ ESP32 Solo Miner
La 2.8″ ESP32 Solo Miner está construida alrededor del sistema en módulo ESP32-WROOM-32-N4, que integra un microprocesador Xtensa LX6 de doble núcleo capaz de alcanzar hasta 240 MHz. El núcleo ESP32 ofrece conectividad Wi-Fi (802.11 b/g/n, 2.4 GHz) y Bluetooth (Bluetooth 5.0/BLE) de forma nativa en el chip.
Pantalla e interfaz táctil
El módulo cuenta con un panel TFT-LCD de 2.8 pulgadas con resolución de 320 × 240 píxeles y tipo de pantalla TN (Twisted Nematic). La pantalla utiliza un controlador ILI9341V que se comunica con el ESP32 mediante una interfaz SPI, responsable del control de píxeles, renderizado de color y operación de la retroiluminación. La imagen a continuación muestra el frontal del módulo de pantalla:
Una capa táctil resistiva está laminada sobre la superficie del LCD, permitiendo la entrada de coordenadas mediante contacto por presión. El panel resistivo admite el uso de un stylus o dedo y se conecta con el ESP32 a través de líneas analógicas/digitales dedicadas gestionadas por un controlador táctil a bordo (XPT2046).
Especificaciones de alimentación y físicas
La placa puede alimentarse mediante una fuente externa de 5 V DC hasta 2 A para operación estable bajo carga, o con una batería Li-ion/LiPo de 3.7–4.2 V conectada al puerto integrado para batería. Incluye botones físicos BOOT y RESET para control del usuario durante el desarrollo o flasheo de firmware.
El área activa de la pantalla mide aproximadamente 43.2 mm por 56.7 mm, y el peso neto total de la placa es de alrededor de 61 g, haciéndola compacta para aplicaciones embebidas o portátiles.
Interfaces periféricas y de E/S
Además de la pantalla y el táctil, la placa ofrece múltiples interfaces periféricas. Una ranura para tarjeta TF (microSD) permite almacenamiento local o carga de firmware/datos. Las interfaces de comunicación incluyen I2C, UART0 y UART1 para integración serial con sensores o controladores externos.
El conector USB-C (UART0) funciona tanto como entrada de alimentación como interfaz USB a TTL para flasheo de firmware y depuración serial.
Un header GPIO de propósito general expone líneas digitales adicionales, mientras que un puerto dedicado para altavoz soporta señalización de audio simple. Los conectores usan headers estándar y microconectores PH2.0/HY2.0. La siguiente tabla resume qué pines GPIO están asignados a las interfaces IO, al altavoz y al lector de tarjeta SD:
| Pantalla | GPIO |
|---|---|
| GPIO_D | IO25; IO32 |
| UART | RX(IO16); TX(IO17) |
| I2C | SDA(IO22); SCL(IO21) |
| SPK | IO26 |
| Ranura para tarjeta SD (SPI) | MOSI(IO23); MISO(IO19); SDK(IO18); CS(IO5) |
Soporte para desarrollo
La placa soporta múltiples entornos de desarrollo como Arduino IDE, Espressif IDF, Lua RTOS y Micro Python, y es compatible con el LVGL graphics library. Sin embargo, en este tutorial me centraré en Arduino IDE y la TFT_eSPI graphics library.
Especificaciones técnicas
La siguiente tabla resume las especificaciones técnicas de la pantalla LCD 2.8″ ESP32 Solo Miner:
| Categoría | Especificación |
|---|---|
| Controlador principal | ESP32-WROOM-32-N4 |
| Arquitectura CPU | Xtensa LX6 de doble núcleo |
| Frecuencia máxima de reloj | Hasta 240 MHz |
| Conectividad inalámbrica | Wi-Fi 802.11 b/g/n (2.4 GHz), Bluetooth 5.0 / BLE |
| Tamaño de pantalla | TFT LCD de 2.8 pulgadas |
| Resolución de pantalla | 320 × 240 píxeles |
| Tipo de pantalla | TN TFT |
| Controlador de pantalla IC | ILI9341V |
| Panel táctil | Pantalla táctil resistiva (controlador XPT2046) |
| Interfaz de pantalla | SPI |
| Almacenamiento externo | Ranura para tarjeta MicroSD (TF) |
| Entrada de alimentación (cableada) | 5 V DC vía USB-C |
| Entrada de alimentación (batería) | 3.7–4.2 V Li-ion / LiPo |
| Controles de usuario | Botones BOOT y RESET |
| Interfaz de audio | Conector para altavoz (amplificador SC8002B) |
| Interfaces de comunicación | UART0, UART1, I2C, GPIO |
| Interfaz de programación | USB-C (USB a TTL) |
| Plataformas de desarrollo soportadas | Arduino IDE, ESP-IDF, PlatformIO, MicroPython, Lua RTOS, ESPHome |
| Temperatura de operación | −20 °C a +70 °C |
| Temperatura de almacenamiento | −30 °C a +80 °C |
| Área activa de pantalla | 43.2 mm × 56.7 mm |
| Peso aproximado | ~61 g |
Instalar núcleo ESP32
La pantalla LCD 2.8″ ESP32 Solo Miner está basada en ESP32. Si quieres programarla necesitas instalar el núcleo ESP32 en tu Arduino IDE.
Comienza abriendo el diálogo de Preferencias seleccionando “Preferences…” en el menú “File”. Esto abrirá el diálogo de Preferencias que se muestra a continuación.
En la pestaña Settings encontrarás un cuadro de edición en la parte inferior del diálogo etiquetado como “Additional boards manager URLs“:
En este campo copia la siguiente URL:
https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json
Esto permitirá que Arduino IDE sepa dónde encontrar las librerías del núcleo ESP32. A continuación instalaremos las placas ESP32 usando el Gestor de Placas.
Abre el Gestor de Placas vía «Tools -> Boards -> Board Manager». Verás el Gestor de Placas en la barra lateral izquierda. Escribe «ESP32» en el campo de búsqueda superior y deberías ver dos tipos de placas ESP32; las «Arduino ESP32 Boards» y las placas «esp32 by Espressif». Queremos las «esp32 libraries by Espressif». Haz clic en el botón INSTALL y espera a que la descarga e instalación finalicen.
Estoy usando la versión 3.3.5 aquí, pero cualquier otra versión 3.x debería funcionar para este proyecto. Si necesitas más información lee nuestro Install ESP32 core in Arduino IDE tutorial.
Seleccionar placa
También necesitas seleccionar una placa ESP32. En el caso de la pantalla LCD 2.8″ ESP32 Solo Miner, puedes elegir la genérica «ESP32S3 Dev Module». Para ello, haz clic en el menú desplegable y luego en «Select other board and port…»:
Esto abrirá un diálogo donde puedes escribir «esp32s3 dev» en la barra de búsqueda. Verás la placa «ESP32S3 Dev Module» bajo Boards. Haz clic en ella y en el puerto COM para activarla y luego haz clic en OK:
Ten en cuenta que debes conectar la placa mediante el cable USB a tu ordenador antes de poder seleccionar un puerto COM.
Probando GPIO
La placa Solo Miner expone dos pines GPIO en el puerto GPIO_D. En este ejemplo implementamos un programa simple Blink para probar el puerto GPIO.
Como la pantalla no tiene LED integrado, vamos a conectar y controlar dos LEDs externos. El diagrama de conexiones a continuación muestra cómo conectar los dos LEDs al puerto:
Los pines dentro del puerto GPIO_D son IO25; IO32, 3.3V, GND. No necesitamos la salida de 3.3V, solo los dos pines GPIO y tierra. Al montar el circuito, no olvides las resistencias de 220Ω para limitar la corriente a los LEDs y asegúrate de que la tierra esté correctamente conectada.
Después puedes subir el siguiente código que hace parpadear los dos LEDs de forma alterna. También imprime en el monitor Serial, así que si hay algún problema con el cableado, al menos puedes verificar que el programa está corriendo. Asegúrate de que la velocidad en baudios del monitor Serial esté configurada 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);
}
Configurando la biblioteca TFT_eSPI
Si quieres mostrar algo en la pantalla necesitarás usar una biblioteca gráfica. Usaremos la biblioteca TFT_eSPI de Bodmer. Para instalarla, abre el LIBRARY MANAGER, escribe «TFT_eSPI» en la barra de búsqueda y haz clic en el botón INSTALL. La imagen a continuación muestra cómo se ve una instalación exitosa:
Luego necesitamos crear un archivo llamado tft_setup.h con los parámetros correctos para la pantalla. Este archivo debe formar parte de cualquier proyecto Arduino que use la pantalla.
Aquí te explico cómo funciona en detalle. Primero crea un nuevo proyecto Arduino y guárdalo como «tft_test«, por ejemplo. Esto creará una carpeta tft_test con un archivo tft_test.ino dentro:
En esta carpeta, crea un archivo llamado «tft_setup.h«. ¡El nombre debe ser exacto! Tu carpeta de proyecto debería verse así:
tft_setup.hEn tu Arduino IDE ahora deberías ver dos pestañas; tft_test.ino y tft_setup.h en las que puedes hacer clic para editar los archivos.
tft_test.ino and tft_setup.hEn el archivo tft_setup.h copia los siguientes parámetros:
#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
En el archivo 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);
}
Ten en cuenta que tft_setup.h está incluido al inicio del programa. El código es fácil de entender. Creamos un objeto TFT_eSPI y lo inicializamos en la función setup(). En la función loop, configuramos el color, tamaño y alineación del texto, y dibujamos la cadena «Makerguides» en el centro de la pantalla TFT.
Si compilas y subes este programa, deberías ver la siguiente salida en tu pantalla:
En las siguientes secciones aprenderás a leer datos táctiles.
Detección de eventos táctiles
El siguiente código muestra cómo detectar eventos táctiles. Dibuja un pequeño círculo amarillo donde toques la pantalla:
#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);
}
Como antes, incluimos tft_setup.h y la biblioteca TFT_eSPI. Luego creamos el objeto display y un array con datos de calibración. El array cal contiene esencialmente las coordenadas de las esquinas y la orientación de la pantalla táctil. En la siguiente sección te mostraré cómo obtener los datos de calibración, pero los que se dan aquí deberían funcionar para empezar.
En la función setup inicializamos la pantalla, configuramos la orientación, establecemos los datos de calibración táctil y llenamos la pantalla de negro.
En la función loop llamamos continuamente a getTouch() para obtener las coordenadas de un evento táctil. La función devuelve true si se detectó un toque. En ese caso dibujamos un círculo amarillo con radio de 5 píxeles en las coordenadas del toque. Aquí tienes un ejemplo de cómo se ve en la pantalla:
Calibración de la pantalla táctil
La pantalla táctil está sobre la pantalla y tiene diferente resolución, ubicación y orientación. Para que la ubicación de los eventos táctiles coincida con la pantalla, necesitamos calibrar la pantalla táctil midiendo las coordenadas de las esquinas y la orientación.
Estos ajustes se almacenan en el array de calibración. Ejecuta el siguiente programa para extraer los parámetros de calibración y mostrarlos en el 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);
}
Al ejecutar este programa te pedirá tocar las cuatro esquinas de la pantalla y luego imprimirá los cinco parámetros de calibración (coordenadas de esquinas y orientación). Durante la calibración tu pantalla debería verse así:
Y en el Monitor Serial deberías ver algo similar impreso, después de tocar las cuatro esquinas:
cal: { 210, 3484, 285, 3511, 7 }
La calibración se repite cada 10 segundos, para que puedas intentar varias veces y obtener los parámetros más precisos. Luego usa estos parámetros al inicializar la pantalla en la función setup:
...
uint16_t cal[5] = { 210, 3484, 285, 3511, 7 };
void setup() {
...
tft.setTouch(cal);
...
}
En las siguientes dos secciones te mostraré rápidamente cómo generar sonido y cómo usar el lector de tarjetas SD.
Reproducir sonido en el altavoz
El siguiente código muestra cómo reproducir sonido en el altavoz. Produce un tono de 440Hz durante un segundo con una pausa de un segundo:
const int speakerPin = 26;
void setup() {
pinMode(speakerPin, OUTPUT);
}
void loop() {
tone(speakerPin, 440); // 440Hz tone
delay(1000);
noTone(speakerPin);
delay(1000);
}
Ten en cuenta que necesitarás conectar un altavoz externo (3W, 4-8 Ohmios) al conector de altavoz de la placa, ya que la placa no tiene altavoz o zumbador integrado.
Detectar tipo de tarjeta SD
Este último ejemplo de código muestra cómo usar el lector de tarjetas SD integrado en la pantalla para detectar una tarjeta 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() { }
Si necesitas más información y ejemplos sobre lectores de tarjetas SD, echa un vistazo al SD Card Module with ESP32 tutorial.
Esquemas
Para mayor comodidad, aquí están las partes más importantes del Schematics para la placa de pantalla LCD 2.8″ ESP32 Solo Miner:
Conclusión
Este tutorial te mostró cómo usar la pantalla, la pantalla táctil, el altavoz y el lector de tarjetas SD del 2.8-inch ESP32 Solo Miner LCD Display. Para información adicional consulta el Github repo y Wiki en Elecrow.
La placa Solo Miner ESP32 Display incluye prácticamente todo lo necesario para un proyecto que involucre una pantalla. Incluye una pantalla táctil TFT, un ESP32, una ranura para tarjeta TF, un conector de batería con cargador, una interfaz para altavoz y una interfaz I2C.
Sin embargo, esto también significa que el número de pines GPIO libres se limita a solo dos. Pero dado que hay una interfaz I2C, puedes usar un expansor GPIO para añadir más GPIOs. Echa un vistazo a nuestro tutorial Using GPIO Expander MCP23017 With Arduino.
El hardware del Pantalla 2.8″ ESP32 Solo Miner es esencialmente idéntico al CrowPanel 2.8″ ESP32 Display. Consulta el CrowPanel 2.8″ ESP32 Display : Easy Setup Guide tutorial para más información.
Para aplicaciones de ejemplo con las pantallas ESP32, mira nuestros tutoriales Digital Clock with CrowPanel 3.5″ ESP32 Display, Parking sensor with CrowPanel ESP32 Display y Digital Timer Switch with CrowPanel ESP32 Display.
Si tienes alguna pregunta, no dudes en dejarla en la sección de comentarios.
¡Feliz bricolaje ; )
