Le 2.8-inch ESP32 Solo Miner LCD Display d’Elecrow est un module intégré compact qui combine un écran tactile TFT couleur avec un microcontrôleur ESP32-WROOM-32 pour offrir à la fois une interface utilisateur et une capacité de traitement autonome sur une seule carte.
L’écran tactile résistif de 320 × 240 pixels est piloté par un contrôleur ILI9341V et le CPU double cœur LX6 de l’ESP32 embarqué. Il intègre également le Wi-Fi 2,4 GHz et le Bluetooth. La carte dispose en outre d’un emplacement pour carte TF, de plusieurs ports E/S, d’interfaces USB-C et UART, ainsi que d’un connecteur pour haut-parleur/batterie.
Lorsqu’il est utilisé avec un firmware de minage compatible tel que NMMiner ou NerdMiner, l’appareil peut participer au minage solo de cryptomonnaies à des fins éducatives. Ne vous attendez pas à générer des revenus avec ; )
Dans ce tutoriel, nous nous concentrerons sur la programmation de l’écran avec l’Arduino IDE en utilisant la bibliothèque graphique TFT_eSPI. Vous apprendrez également à utiliser le port GPIO, le haut-parleur et le lecteur de carte SD.
Pièces requises
Les pièces requises incluent l’écran et, si vous souhaitez connecter du matériel externe, quelques câbles, résistances, LED et une breadboard seront utiles.
Écran LCD 2,8″ ESP32 Solo Miner
Jeu de fils Dupont
Breadboard
Kit résistances & 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.
Caractéristiques de l’écran 2,8″ ESP32 Solo Miner LCD
Le 2,8″ ESP32 Solo Miner est construit autour du système sur module ESP32-WROOM-32-N4, qui intègre un microprocesseur Xtensa LX6 double cœur cadencé jusqu’à 240 MHz. Le cœur ESP32 offre nativement la connectivité Wi-Fi (802.11 b/g/n, 2,4 GHz) et Bluetooth (Bluetooth 5.0/BLE).
Affichage et interface tactile
Le module dispose d’un écran TFT-LCD de 2,8 pouces avec une résolution de 320 × 240 pixels et un type d’affichage TN (Twisted Nematic). L’écran utilise un circuit pilote ILI9341V qui communique avec l’ESP32 via une interface SPI, responsable du contrôle des pixels, du rendu des couleurs et de l’éclairage. L’image ci-dessous montre la face avant du module d’affichage :
Un revêtement tactile résistif est laminé sur la surface de l’écran LCD, permettant la saisie des coordonnées par contact de pression. La dalle résistive accepte un stylet ou le doigt et communique avec l’ESP32 via des lignes analogiques/numériques dédiées gérées par un contrôleur tactile embarqué (XPT2046).
Alimentation et spécifications physiques
La carte peut être alimentée par une source externe 5 V DC jusqu’à 2 A pour un fonctionnement stable sous charge, ou par une batterie Li-ion/LiPo 3,7–4,2 V connectée au port batterie intégré. Elle comprend des boutons poussoirs BOOT et RESET pour le contrôle utilisateur lors du développement ou du flashage du firmware.
La zone active de l’écran mesure environ 43,2 mm par 56,7 mm, et le poids net total de la carte est d’environ 61 g, ce qui la rend compacte pour des applications embarquées ou portables.
Périphériques et interfaces E/S
Au-delà de l’affichage et du tactile, la carte expose plusieurs interfaces périphériques. Un emplacement pour carte TF (microSD) permet le stockage local ou le chargement de firmware/données. Les interfaces de communication incluent I2C, UART0 et UART1 pour l’intégration série avec des capteurs ou contrôleurs externes.
Le connecteur USB-C (UART0) sert à la fois d’entrée d’alimentation et d’interface de programmation USB-to-TTL pour le flashage du firmware et le débogage série.
Un connecteur GPIO polyvalent expose des lignes E/S numériques supplémentaires, tandis qu’un port dédié au haut-parleur supporte la signalisation audio simple. Les connecteurs utilisent des headers standards et des micro-connecteurs PH2.0/HY2.0. Le tableau suivant résume les broches GPIO assignées aux interfaces IO, au haut-parleur et au lecteur de carte SD :
| Affichage | GPIO |
|---|---|
| GPIO_D | IO25; IO32 |
| UART | RX(IO16); TX(IO17) |
| I2C | SDA(IO22); SCL(IO21) |
| SPK | IO26 |
| Emplacement carte SD (SPI) | MOSI(IO23); MISO(IO19); SDK(IO18); CS(IO5) |
Support de développement
La carte supporte plusieurs environnements de développement tels que Arduino IDE, Espressif IDF, Lua RTOS et Micro Python, et est compatible avec le LVGL graphics library. Cependant, dans ce tutoriel, je me concentrerai sur Arduino IDE et la TFT_eSPI graphics library.
Spécifications techniques
Le tableau suivant résume les spécifications techniques de l’écran 2,8″ ESP32 Solo Miner LCD :
| Catégorie | Spécification |
|---|---|
| Contrôleur principal | ESP32-WROOM-32-N4 |
| Architecture CPU | Xtensa LX6 double cœur |
| Fréquence maximale | Jusqu’à 240 MHz |
| Connectivité sans fil | Wi-Fi 802.11 b/g/n (2,4 GHz), Bluetooth 5.0 / BLE |
| Taille d’écran | Écran TFT LCD 2,8 pouces |
| Résolution d’écran | 320 × 240 pixels |
| Type d’écran | TN TFT |
| Circuit pilote d’écran | ILI9341V |
| Panneau tactile | Écran tactile résistif (contrôleur XPT2046) |
| Interface d’affichage | SPI |
| Stockage externe | Emplacement carte MicroSD (TF) |
| Alimentation (filaire) | 5 V DC via USB-C |
| Alimentation (batterie) | 3,7–4,2 V Li-ion / LiPo |
| Contrôles utilisateur | Boutons BOOT et RESET |
| Interface audio | Connecteur haut-parleur (amplificateur SC8002B) |
| Interfaces de communication | UART0, UART1, I2C, GPIO |
| Interface de programmation | USB-C (USB-to-TTL) |
| Plateformes de développement supportées | Arduino IDE, ESP-IDF, PlatformIO, MicroPython, Lua RTOS, ESPHome |
| Température de fonctionnement | −20 °C à +70 °C |
| Température de stockage | −30 °C à +80 °C |
| Zone active d’affichage | 43,2 mm × 56,7 mm |
| Poids approximatif | ~61 g |
Installer le Core ESP32
L’écran 2,8″ ESP32 Solo Miner LCD est basé sur l’ESP32. Pour le programmer, vous devez installer le core ESP32 dans votre Arduino IDE.
Commencez par ouvrir la boîte de dialogue Préférences en sélectionnant « Preferences… » dans le menu « File ». Cela ouvrira la boîte de dialogue Préférences affichée ci-dessous.
Sous l’onglet Settings, vous trouverez une zone de saisie en bas de la boîte intitulée « Additional boards manager URLs » :
Dans ce champ, copiez l’URL suivante :
https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json
Cela permettra à l’Arduino IDE de savoir où trouver les bibliothèques du core ESP32. Ensuite, nous installerons les cartes ESP32 via le Boards Manager.
Ouvrez le Boards Manager via « Tools -> Boards -> Board Manager ». Le gestionnaire de cartes apparaîtra dans la barre latérale gauche. Tapez « ESP32 » dans le champ de recherche en haut et vous verrez deux types de cartes ESP32 : les « Arduino ESP32 Boards » et les cartes « esp32 by Espressif ». Nous voulons les « esp32 libraries by Espressif ». Cliquez sur le bouton INSTALL et attendez la fin du téléchargement et de l’installation.
J’utilise ici la version 3.3.5, mais toute autre version 3.x devrait également fonctionner pour ce projet. Pour plus d’informations, consultez notre Install ESP32 core in Arduino IDE tutoriel.
Sélection de la carte
Vous devez également sélectionner une carte ESP32. Pour l’écran 2,8″ ESP32 Solo Miner LCD, vous pouvez choisir le module générique « ESP32S3 Dev Module ». Pour cela, cliquez sur le menu déroulant puis sur « Select other board and port… »:
Cela ouvrira une boîte de dialogue où vous pouvez taper « esp32s3 dev » dans la barre de recherche. Vous verrez la carte « ESP32S3 Dev Module » sous Boards. Cliquez dessus, sélectionnez le port COM pour l’activer, puis cliquez sur OK :
Notez que vous devez connecter la carte via le câble USB à votre ordinateur avant de pouvoir sélectionner un port COM.
Test des GPIO
La carte Solo Miner expose deux broches GPIO sur le port GPIO_D. Dans cet exemple, nous implémentons un simple Blink programme pour tester le port GPIO.
Comme l’écran n’a pas de LED intégrée, nous allons connecter et contrôler deux LED externes. Le schéma de câblage ci-dessous montre comment connecter les deux LED au port :
Les broches du port GPIO_D sont IO25; IO32, 3.3V, GND. Nous n’avons pas besoin de la sortie 3.3V, juste des deux broches GPIO et de la masse. Lors du montage, n’oubliez pas les résistances de 220Ω pour limiter le courant vers les LED et assurez-vous que la masse est bien connectée.
Ensuite, vous pouvez téléverser le code suivant qui fait clignoter alternativement les deux LED. Il affiche aussi des messages sur le moniteur série, donc en cas de problème de câblage, vous pouvez au moins vérifier que le programme tourne. Assurez-vous que le débit en bauds du moniteur série est réglé à 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);
}
Configuration de la bibliothèque TFT_eSPI
Pour afficher quelque chose à l’écran, vous aurez besoin d’une bibliothèque graphique. Nous allons utiliser la bibliothèque TFT_eSPI de Bodmer. Pour l’installer, ouvrez le LIBRARY MANAGER, tapez « TFT_eSPI » dans la barre de recherche, puis cliquez sur le bouton INSTALL. L’image ci-dessous montre à quoi ressemble une installation réussie :
Ensuite, il faut créer un fichier nommé tft_setup.h avec les paramètres corrects pour l’écran. Ce fichier doit faire partie de tout projet Arduino utilisant l’écran.
Voici comment procéder en détail. Créez d’abord un nouveau projet Arduino et enregistrez-le sous le nom « tft_test« , par exemple. Cela créera un dossier tft_test contenant un fichier tft_test.ino :
Dans ce dossier, créez un fichier nommé « tft_setup.h« . Le nom doit être exact ! Votre dossier de projet devrait alors ressembler à ceci :
tft_setup.hDans votre Arduino IDE, vous devriez maintenant voir deux onglets ; tft_test.ino et tft_setup.h sur lesquels vous pouvez cliquer pour éditer les fichiers.
tft_test.ino and tft_setup.hDans le fichier tft_setup.h, copiez les paramètres suivants :
#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
Dans le fichier 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);
}
Notez que tft_setup.h est inclus en haut du programme. Le code est simple à comprendre. Nous créons un objet TFT_eSPI et l’initialisons dans la fonction setup(). Dans la fonction loop, nous réglons la couleur, la taille et l’alignement du texte, puis affichons la chaîne « Makerguides » au centre de l’écran TFT.
Si vous compilez et téléversez ce programme, vous devriez voir la sortie suivante sur votre écran :
Dans les sections suivantes, vous apprendrez à lire les données tactiles.
Détection des événements tactiles
Le code suivant montre comment détecter les événements tactiles. Il dessine un petit cercle jaune à l’endroit où vous touchez l’écran :
#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);
}
Comme précédemment, nous incluons tft_setup.h et la bibliothèque TFT_eSPI. Ensuite, nous créons l’objet écran et un tableau avec les données de calibration. Le tableau cal contient essentiellement les coordonnées des coins et l’orientation de l’écran tactile. Je vous montrerai dans la section suivante comment trouver ces données de calibration, mais celles fournies ici devraient fonctionner pour commencer.
Dans la fonction setup, nous initialisons l’écran, réglons l’orientation, définissons les données de calibration tactile et remplissons l’écran en noir.
Dans la fonction loop, nous appelons continuellement getTouch() pour obtenir les coordonnées d’un événement tactile. La fonction retourne true si un contact est détecté. Dans ce cas, nous dessinons un cercle jaune de 5 pixels de rayon aux coordonnées du contact. Voici un exemple de ce que cela donne à l’écran :
Calibration de l’écran tactile
L’écran tactile est placé au-dessus de l’écran et a une résolution, une position et une orientation différentes. Pour faire correspondre les coordonnées tactiles avec celles de l’écran, il faut calibrer l’écran tactile en mesurant les coordonnées des coins et l’orientation.
Ces réglages sont stockés dans le tableau de calibration. Lancez le programme suivant pour extraire les paramètres de calibration et les afficher dans le moniteur série :
#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);
}
Lorsque vous lancez ce programme, il vous demande de toucher les quatre coins de l’écran, puis affiche les cinq paramètres de calibration (coordonnées des coins et orientation de l’écran). Votre écran pendant la calibration devrait ressembler à ceci :
Et dans le moniteur série, vous devriez voir quelque chose comme ceci après avoir touché les quatre coins :
cal: { 210, 3484, 285, 3511, 7 }
La calibration se répète toutes les 10 secondes, vous permettant plusieurs essais pour obtenir les paramètres les plus précis. Utilisez ensuite ces paramètres lors de l’initialisation de l’écran dans la fonction setup :
...
uint16_t cal[5] = { 210, 3484, 285, 3511, 7 };
void setup() {
...
tft.setTouch(cal);
...
}
Dans les deux sections suivantes, je vous montre rapidement comment générer du son et utiliser le lecteur de carte SD.
Jouer un son sur le haut-parleur
Le code suivant montre comment jouer un son sur le haut-parleur. Il produit un ton de 440 Hz pendant une seconde, suivi d’une pause d’une seconde :
const int speakerPin = 26;
void setup() {
pinMode(speakerPin, OUTPUT);
}
void loop() {
tone(speakerPin, 440); // 440Hz tone
delay(1000);
noTone(speakerPin);
delay(1000);
}
Notez que vous devrez connecter un haut-parleur externe (3W, 4-8 Ohms) au connecteur haut-parleur de la carte, car la carte ne possède pas de haut-parleur ou buzzer intégré.
Détecter le type de carte SD
Ce dernier exemple de code montre comment utiliser le lecteur de carte SD intégré de l’écran pour détecter une carte 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() { }
Pour plus d’informations et d’exemples sur les lecteurs de carte SD, consultez le SD Card Module with ESP32 tutoriel.
Schémas
Pour plus de commodité, voici les parties les plus importantes du Schematics pour la carte écran 2,8″ ESP32 Solo Miner LCD :
Conclusion
Ce tutoriel vous a montré comment utiliser l’écran, l’écran tactile, le haut-parleur et le lecteur de carte SD du 2.8-inch ESP32 Solo Miner LCD Display. Pour plus d’informations, consultez le Github repo et le Wiki chez Elecrow.
La carte Solo Miner ESP32 Display comprend pratiquement tout ce dont vous avez besoin pour un projet impliquant un écran. Elle inclut un écran tactile TFT, un ESP32, un emplacement pour carte TF, un connecteur batterie avec chargeur, une interface haut-parleur et une interface I2C.
Cependant, cela signifie aussi que le nombre de broches GPIO libres est limité à seulement deux. Mais comme il y a une interface I2C, vous pouvez utiliser un expandeur GPIO pour ajouter plus de broches. Consultez notre tutoriel Using GPIO Expander MCP23017 With Arduino.
Le matériel du 2,8″ ESP32 Solo Miner Display est essentiellement identique à celui du CrowPanel 2,8″ ESP32 Display. Consultez le CrowPanel 2.8″ ESP32 Display : Easy Setup Guide tutoriel pour plus d’informations.
Pour des exemples d’application des écrans ESP32, voyez nos tutoriels Digital Clock with CrowPanel 3.5″ ESP32 Display, Parking sensor with CrowPanel ESP32 Display et Digital Timer Switch with CrowPanel ESP32 Display.
Si vous avez des questions, n’hésitez pas à les poser dans la section commentaires.
Bon bricolage ; )
