O 2.8-inch ESP32 Solo Miner LCD Display da Elecrow é um módulo integrado compacto que combina um ecrã tátil TFT a cores com um microcontrolador ESP32-WROOM-32 para fornecer tanto interface de utilizador como capacidade de processamento autónomo numa única placa.
O ecrã tátil resistivo de 320 × 240 pixels é controlado por um controlador ILI9341V e pelo CPU dual-core LX6 do ESP32 integrado. Também integra Wi-Fi 2.4 GHz e Bluetooth. A placa expõe ainda um slot para cartão TF, múltiplas portas I/O, interfaces USB-C e UART, e um conector para altifalante/bateria.
Quando usado com firmware de mineração compatível como NMMiner ou NerdMiner, o dispositivo pode participar em mineração solo de criptomoedas para fins educativos. Não espere gerar qualquer rendimento com ele ; )
Neste tutorial vamos focar-nos na programação do ecrã com o Arduino IDE usando a biblioteca gráfica TFT_eSPI. Também vai aprender a usar a porta GPIO, o altifalante e o leitor de cartão SD.
Peças Necessárias
As peças necessárias incluem o ecrã e, se quiser ligar algum hardware externo, alguns cabos, resistores, LEDs e uma breadboard serão úteis.
Ecrã LCD 2.8″ ESP32 Solo Miner
Conjunto de fios Dupont
Breadboard
Kit de resistores e 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 do Ecrã LCD 2.8″ ESP32 Solo Miner
O 2.8″ ESP32 Solo Miner é construído em torno do sistema em módulo ESP32-WROOM-32-N4, que integra um microprocessador dual-core Xtensa LX6 capaz de atingir até 240 MHz. O núcleo ESP32 oferece conectividade Wi-Fi (802.11 b/g/n, 2.4 GHz) e Bluetooth (Bluetooth 5.0/BLE) nativamente no chip.
Ecrã e Interface Tátil
O módulo apresenta um painel TFT-LCD de 2.8 polegadas com resolução de 320 × 240 pixels e tipo de ecrã TN (Twisted Nematic). O ecrã usa um controlador ILI9341V que comunica com o ESP32 via interface SPI, responsável pelo controlo dos pixels, renderização de cores e operação da retroiluminação. A imagem abaixo mostra a frente do módulo de ecrã:
Uma camada tátil resistiva está laminada sobre a superfície do LCD, permitindo a entrada de coordenadas através de contacto por pressão. O painel resistivo aceita um stylus ou dedo e comunica com o ESP32 via linhas analógicas/digitais dedicadas geridas por um controlador tátil onboard (XPT2046).
Especificações de Energia e Físicas
A placa pode ser alimentada por uma fonte externa DC de 5 V até 2 A para operação estável sob carga, ou por uma bateria Li-ion/LiPo de 3.7–4.2 V ligada ao conector integrado de bateria. Inclui botões físicos BOOT e RESET para controlo do utilizador durante o desenvolvimento ou gravação de firmware.
A área ativa do ecrã mede aproximadamente 43.2 mm por 56.7 mm, e o peso líquido total da placa é cerca de 61 g, tornando-a compacta para aplicações embutidas ou portáteis.
Interfaces Periféricas e I/O
Além do ecrã e toque, a placa expõe múltiplas interfaces periféricas. Um slot para cartão TF (microSD) permite armazenamento local ou carregamento de firmware/dados. As interfaces de comunicação incluem I2C, UART0 e UART1 para integração serial com sensores ou controladores externos.
O conector USB-C (UART0) funciona tanto como entrada de energia como interface USB-to-TTL para gravação de firmware e depuração serial.
Um cabeçalho GPIO de uso geral expõe linhas digitais I/O adicionais, enquanto uma porta dedicada para altifalante suporta sinalização áudio simples. Os conectores usam pinos padrão e micro-conectores PH2.0/HY2.0. A tabela seguinte resume quais pinos GPIO estão atribuídos às interfaces IO, ao altifalante e ao leitor de cartão SD:
| Ecrã | GPIO |
|---|---|
| GPIO_D | IO25; IO32 |
| UART | RX(IO16); TX(IO17) |
| I2C | SDA(IO22); SCL(IO21) |
| SPK | IO26 |
| Slot para Cartão SD (SPI) | MOSI(IO23); MISO(IO19); SDK(IO18); CS(IO5) |
Suporte ao Desenvolvimento
A placa suporta múltiplos ambientes de desenvolvimento como Arduino IDE, Espressif IDF, Lua RTOS e Micro Python, e é compatível com o LVGL graphics library. Contudo, neste tutorial vou focar-me no Arduino IDE e na TFT_eSPI graphics library.
Especificações Técnicas
A tabela seguinte resume as especificações técnicas do Ecrã LCD 2.8″ ESP32 Solo Miner:
| Categoria | Especificação |
|---|---|
| Controlador Principal | ESP32-WROOM-32-N4 |
| Arquitetura CPU | Dual-core Xtensa LX6 |
| Frequência Máxima | Até 240 MHz |
| Conectividade Wireless | Wi-Fi 802.11 b/g/n (2.4 GHz), Bluetooth 5.0 / BLE |
| Tamanho do Ecrã | TFT LCD de 2.8 polegadas |
| Resolução do Ecrã | 320 × 240 pixels |
| Tipo de Ecrã | TN TFT |
| Controlador do Ecrã | ILI9341V |
| Painel Tátil | Ecrã tátil resistivo (controlador XPT2046) |
| Interface do Ecrã | SPI |
| Armazenamento Externo | Slot para cartão MicroSD (TF) |
| Entrada de Energia (Com Fios) | 5 V DC via USB-C |
| Entrada de Energia (Bateria) | 3.7–4.2 V Li-ion / LiPo |
| Controlo do Utilizador | Botões BOOT e RESET |
| Interface de Áudio | Conector para altifalante (amplificador SC8002B) |
| Interfaces de Comunicação | UART0, UART1, I2C, GPIO |
| Interface de Programação | USB-C (USB-to-TTL) |
| Plataformas de Desenvolvimento Suportadas | Arduino IDE, ESP-IDF, PlatformIO, MicroPython, Lua RTOS, ESPHome |
| Temperatura de Operação | −20 °C a +70 °C |
| Temperatura de Armazenamento | −30 °C a +80 °C |
| Área Ativa do Ecrã | 43.2 mm × 56.7 mm |
| Peso Aproximado | ~61 g |
Instalar Core ESP32
O Ecrã LCD 2.8″ ESP32 Solo Miner é baseado no ESP32. Se quiser programá-lo, precisa de instalar o core ESP32 no seu Arduino IDE.
Comece por abrir o diálogo de Preferências selecionando “Preferences…” no menu “File”. Isto abrirá o diálogo de Preferências mostrado abaixo.
Na aba Settings encontrará uma caixa de edição no fundo do diálogo rotulada “Additional boards manager URLs“:
Neste campo copie a seguinte URL:
https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json
Isto permitirá ao Arduino IDE saber onde encontrar as bibliotecas do core ESP32. A seguir vamos instalar as placas ESP32 usando o Gestor de Placas.
Abra o Gestor de Placas via “Tools -> Boards -> Board Manager”. O Gestor de Placas aparecerá na barra lateral esquerda. Digite “ESP32” no campo de pesquisa no topo e deverá ver dois tipos de placas ESP32; as “Arduino ESP32 Boards” e as placas “esp32 by Espressif”. Queremos as “esp32 libraries by Espressif”. Clique no botão INSTALL e aguarde até o download e instalação terminarem.
Estou a usar a versão 3.3.5 aqui, mas qualquer outra versão 3.x deve funcionar para este projeto. Se precisar de mais informações, leia o nosso Install ESP32 core in Arduino IDE tutorial.
Selecionar Placa
Também precisa de selecionar uma placa ESP32. No caso do Ecrã LCD 2.8″ ESP32 Solo Miner, pode escolher o genérico “ESP32S3 Dev Module”. Para isso, clique no menu suspenso e depois em “Select other board and port…”:
Isto abrirá um diálogo onde pode digitar “esp32s3 dev” na barra de pesquisa. Verá a placa “ESP32S3 Dev Module” em Boards. Clique nela e no porto COM para ativá-la e depois clique OK:
Note que precisa de ligar a placa via cabo USB ao seu computador antes de poder selecionar uma porta COM.
Testar GPIO
A placa Solo Miner expõe dois pinos GPIO na porta GPIO_D. Neste exemplo implementamos um programa simples Blink para testar a porta GPIO.
Como o ecrã não tem LED integrado, vamos ligar e controlar dois LEDs externos. O diagrama de ligação abaixo mostra como ligar os dois LEDs à porta:
Os pinos na porta GPIO_D são IO25; IO32, 3.3V, GND. Não precisamos da saída 3.3V, apenas dos dois pinos GPIO e do terra. Ao montar o circuito, não se esqueça dos resistores de 220Ω para limitar a corrente aos LEDs e certifique-se que o terra está bem ligado.
Depois pode carregar o código seguinte que pisca os dois LEDs alternadamente. Também imprime no monitor Serial, para que se houver algum problema na ligação, possa pelo menos verificar que o programa está a correr. Certifique-se que a taxa de baud do monitor Serial está definida para 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);
}
Configurar a biblioteca TFT_eSPI
Se quiser mostrar algo no ecrã, vai precisar de usar uma biblioteca gráfica. Vamos usar a biblioteca TFT_eSPI do Bodmer. Para a instalar, abra o LIBRARY MANAGER, escreva “TFT_eSPI” na barra de pesquisa e clique no botão INSTALL. A imagem abaixo mostra como fica uma instalação bem-sucedida:
De seguida precisamos criar um ficheiro chamado tft_setup.h com os parâmetros corretos para o ecrã. Este ficheiro precisa fazer parte de qualquer projeto Arduino que use o ecrã.
Aqui está como isso funciona em detalhe. Primeiro crie um novo projeto Arduino e guarde-o como “tft_test“, por exemplo. Isso criará uma pasta tft_test com um ficheiro tft_test.ino dentro:
Nesta pasta, crie um ficheiro chamado “tft_setup.h“. O nome tem de ser exato! A sua pasta de projeto deverá então ficar assim:
tft_setup.hNo seu Arduino IDE deverá agora ver duas abas; tft_test.ino e tft_setup.h que pode clicar para editar os ficheiros.
tft_test.ino and tft_setup.hNo ficheiro tft_setup.h copie as seguintes definições de 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
No ficheiro 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);
}
Note que tft_setup.h está incluído no topo do programa. O código em si é fácil de entender. Criamos um objeto TFT_eSPI e inicializamo-lo na função setup(). Na função loop, definimos a cor do texto, tamanho e alinhamento, e desenhamos a string “Makerguides” no centro do ecrã TFT.
Se compilar e carregar este programa, deverá ver a seguinte saída no seu ecrã:
Nas próximas secções, vai aprender a ler dados de toque.
Detetar Eventos de Toque
O código seguinte mostra como detetar eventos de toque. Desenha um pequeno círculo amarelo onde quer que toque no ecrã:
#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, incluímos tft_setup.h e a biblioteca TFT_eSPI. De seguida criamos o objeto do ecrã e um array com dados de calibração. O array cal contém essencialmente as coordenadas dos cantos e a orientação do ecrã tátil. Vou mostrar na próxima secção como pode encontrar os dados de calibração, mas os dados aqui fornecidos devem funcionar para começar.
Na função setup inicializamos o ecrã, definimos a orientação, os dados de calibração do toque e preenchemos o ecrã com preto.
Na função loop chamamos continuamente getTouch() para obter as coordenadas de um evento de toque. A função retorna true se um toque foi detetado. Nesse caso, desenhamos um círculo amarelo com raio de 5 pixels nas coordenadas do toque. Aqui está um exemplo de como isto aparece no ecrã:
Calibrar o Ecrã Tátil
O ecrã tátil está sobreposto ao ecrã e tem uma resolução, localização e orientação diferentes. Para corresponder a localização dos eventos de toque com as posições no ecrã, precisamos calibrar o ecrã tátil medindo as coordenadas dos cantos e a orientação do ecrã tátil.
Estas definições são armazenadas no array de calibração. Execute o programa seguinte para extrair os parâmetros de calibração e imprimi-los no 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 executar este programa, ele pede para tocar nos quatro cantos do ecrã e depois imprime os cinco parâmetros de calibração (coordenadas dos cantos e orientação do ecrã). O seu ecrã durante a calibração deverá parecer assim:
E no Monitor Serial deverá ver algo assim impresso, depois de tocar nos quatro cantos:
cal: { 210, 3484, 285, 3511, 7 }
A calibração repete-se a cada 10 segundos, para que possa tentar várias vezes obter os parâmetros mais precisos. Depois use estes parâmetros ao inicializar o ecrã na função setup:
...
uint16_t cal[5] = { 210, 3484, 285, 3511, 7 };
void setup() {
...
tft.setTouch(cal);
...
}
Nas próximas duas secções, vou mostrar rapidamente como gerar som e como usar o leitor de cartão SD.
Reproduzir Som no Altifalante
O código seguinte mostra como reproduzir som no altifalante. Produz um tom de 440Hz durante um segundo com uma pausa de um segundo:
const int speakerPin = 26;
void setup() {
pinMode(speakerPin, OUTPUT);
}
void loop() {
tone(speakerPin, 440); // 440Hz tone
delay(1000);
noTone(speakerPin);
delay(1000);
}
Note que precisa de ligar um altifalante externo (3W, 4-8 Ohms) ao conector do altifalante da placa do ecrã, pois a placa não tem altifalante ou buzzer integrado.
Detetar Tipo de Cartão SD
Este último exemplo de código mostra como usar o leitor de cartão SD integrado do ecrã para detetar um cartão 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 precisar de mais informações e exemplos sobre leitores de cartão SD, consulte o SD Card Module with ESP32 tutorial.
Esquemas
Para conveniência, aqui estão as partes mais importantes do Schematics para a placa do Ecrã LCD 2.8″ ESP32 Solo Miner:
Conclusão
Este tutorial mostrou como usar o ecrã, o ecrã tátil, o altifalante e o leitor de cartão SD do 2.8-inch ESP32 Solo Miner LCD Display. Para informações adicionais, consulte o Github repo e Wiki na Elecrow.
A placa Solo Miner ESP32 Display vem com praticamente tudo o que precisa para um projeto que envolva um ecrã. Inclui um ecrã tátil TFT, um ESP32, um slot para cartão TF, um conector de bateria com carregador, uma interface para altifalante e uma interface I2C.
No entanto, isto também significa que o número de pinos GPIO livres é limitado a apenas dois. Mas como existe uma interface I2C, pode usar um expansor GPIO para adicionar mais GPIOs. Veja o nosso tutorial Using GPIO Expander MCP23017 With Arduino.
O hardware do Ecrã 2.8″ ESP32 Solo Miner é essencialmente idêntico ao CrowPanel 2.8″ ESP32 Display. Veja o tutorial CrowPanel 2.8″ ESP32 Display : Easy Setup Guide para mais informações.
Para exemplos de aplicação dos ecrãs ESP32, veja os nossos tutoriais Digital Clock with CrowPanel 3.5″ ESP32 Display, Parking sensor with CrowPanel ESP32 Display e Digital Timer Switch with CrowPanel ESP32 Display.
Se tiver alguma dúvida, sinta-se à vontade para deixá-la na secção de comentários.
Boas experiências a criar ; )
