Der 2.8-inch ESP32 Solo Miner LCD Display von Elecrow ist ein kompaktes integriertes Modul, das ein farbiges TFT-Touchscreen mit einem ESP32-WROOM-32 Mikrocontroller kombiniert, um sowohl Benutzeroberfläche als auch eigenständige Verarbeitung auf einer einzigen Platine bereitzustellen.
Das 320 × 240 Pixel resistive Touch-Display wird von einem ILI9341V Controller und dem onboard ESP32 Dual-Core LX6 CPU gesteuert. Es integriert außerdem 2,4 GHz Wi-Fi und Bluetooth. Die Platine bietet zudem einen TF-Kartensteckplatz, mehrere I/O-Ports, USB-C- und UART-Schnittstellen sowie einen Lautsprecher-/Batterieanschluss.
Wenn es mit kompatibler Mining-Firmware wie NMMiner oder NerdMiner verwendet wird, kann das Gerät zu Bildungszwecken am Solo-Mining von Kryptowährungen teilnehmen. Erwarte jedoch keine Einnahmen damit ; )
In diesem Tutorial konzentrieren wir uns auf die Programmierung des Displays mit der Arduino IDE unter Verwendung der TFT_eSPI Grafikbibliothek. Du lernst auch, wie man den GPIO-Port, den Lautsprecher und den SD-Kartenleser verwendet.
Benötigte Teile
Die benötigten Teile umfassen das Display und, falls du externe Hardware anschließen möchtest, sind einige Kabel, Widerstände, LEDs und ein Breadboard hilfreich.
2,8″ ESP32 Solo Miner LCD
Dupont-Kabelset
Breadboard
Widerstands- & LED-Kit
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.
Eigenschaften des 2,8″ ESP32 Solo Miner LCD
Der 2,8″ ESP32 Solo Miner basiert auf dem ESP32-WROOM-32-N4 System-on-Module, das einen Dual-Core Xtensa LX6 Mikroprozessor integriert, der mit bis zu 240 MHz getaktet werden kann. Der ESP32-Kern bietet nativ Wi-Fi (802.11 b/g/n, 2,4 GHz) und Bluetooth (Bluetooth 5.0/BLE) Konnektivität auf dem Chip.
Display- und Touch-Interface
Das Modul verfügt über ein 2,8 Zoll TFT-LCD-Panel mit einer Auflösung von 320 × 240 Pixeln und einem TN (Twisted Nematic) Displaytyp. Das Display verwendet einen ILI9341V Display-Treiber-IC, der über eine SPI-Schnittstelle mit dem ESP32 kommuniziert und für die Pixelsteuerung, Farbdarstellung und Hintergrundbeleuchtung zuständig ist. Das Bild unten zeigt die Vorderseite des Display-Moduls:
Eine resistive Touch-Schicht ist über die LCD-Oberfläche laminiert und ermöglicht die Koordinateneingabe durch Druckkontakt. Das resistive Panel kann mit einem Stylus oder Finger bedient werden und ist über dedizierte Analog-/Digital-Leitungen mit dem ESP32 verbunden, die von einem onboard Touch-Controller (XPT2046) verwaltet werden.
Stromversorgung und physikalische Spezifikationen
Die Platine kann über eine externe 5 V DC Quelle mit bis zu 2 A für einen stabilen Betrieb unter Last versorgt werden oder über eine 3,7–4,2 V Li-ion/LiPo Batterie, die an den integrierten Batterieanschluss angeschlossen wird. Sie verfügt über physische BOOT- und RESET-Taster für die Benutzersteuerung während der Entwicklung oder Firmware-Programmierung.
Die aktive Displayfläche misst etwa 43,2 mm × 56,7 mm, und das Nettogewicht der gesamten Platine beträgt ca. 61 g, was sie kompakt für Embedded- oder tragbare Anwendungen macht.
Periphere und I/O-Schnittstellen
Neben Display und Touch bietet die Platine mehrere Peripherie-Schnittstellen. Ein TF (microSD) Kartensteckplatz ermöglicht lokale Speicherung oder Firmware-/Datenladen. Kommunikationsschnittstellen umfassen I2C, UART0 und UART1 für die serielle Integration mit Sensoren oder externen Controllern.
Der USB-C Anschluss (UART0) dient sowohl als Stromversorgungseingang als auch als USB-zu-TTL Programmierinterface für Firmware-Flashen und serielle Debugging.
Ein GPIO-Header für allgemeine Zwecke bietet zusätzliche digitale I/O-Leitungen, während ein dedizierter Lautsprecheranschluss einfache Audio-Signale unterstützt. Die Anschlüsse verwenden Standard-Pin-Header und PH2.0/HY2.0 Mikro-Steckverbinder. Die folgende Tabelle fasst zusammen, welche GPIO-Pins den IO-Schnittstellen, dem Lautsprecher und dem SD-Kartenleser zugeordnet sind:
| Display | GPIO |
|---|---|
| GPIO_D | IO25; IO32 |
| UART | RX(IO16); TX(IO17) |
| I2C | SDA(IO22); SCL(IO21) |
| SPK | IO26 |
| SD-Kartensteckplatz (SPI) | MOSI(IO23); MISO(IO19); SDK(IO18); CS(IO5) |
Entwicklungsunterstützung
Die Platine unterstützt mehrere Entwicklungsumgebungen wie Arduino IDE, Espressif IDF, Lua RTOS und Micro Python und ist kompatibel mit dem LVGL graphics library. In diesem Tutorial konzentriere ich mich jedoch auf die Arduino IDE und die TFT_eSPI graphics library.
Technische Spezifikationen
Die folgende Tabelle fasst die technischen Spezifikationen des 2,8″ ESP32 Solo Miner LCD Displays zusammen:
| Kategorie | Spezifikation |
|---|---|
| Hauptcontroller | ESP32-WROOM-32-N4 |
| CPU-Architektur | Dual-Core Xtensa LX6 |
| Maximale Taktfrequenz | Bis zu 240 MHz |
| Drahtlose Konnektivität | Wi-Fi 802.11 b/g/n (2,4 GHz), Bluetooth 5.0 / BLE |
| Displaygröße | 2,8 Zoll TFT LCD |
| Displayauflösung | 320 × 240 Pixel |
| Displaytyp | TN TFT |
| Display-Treiber-IC | ILI9341V |
| Touchpanel | Resistiver Touchscreen (XPT2046 Controller) |
| Display-Schnittstelle | SPI |
| Externer Speicher | MicroSD (TF) Kartensteckplatz |
| Stromeingang (verkabelt) | 5 V DC über USB-C |
| Stromeingang (Batterie) | 3,7–4,2 V Li-ion / LiPo |
| Benutzersteuerung | BOOT- und RESET-Tasten |
| Audio-Schnittstelle | Lautsprecheranschluss (SC8002B Verstärker) |
| Kommunikationsschnittstellen | UART0, UART1, I2C, GPIO |
| Programmierschnittstelle | USB-C (USB-zu-TTL) |
| Unterstützte Entwicklungsplattformen | Arduino IDE, ESP-IDF, PlatformIO, MicroPython, Lua RTOS, ESPHome |
| Betriebstemperatur | −20 °C bis +70 °C |
| Lagertemperatur | −30 °C bis +80 °C |
| Aktive Displayfläche | 43,2 mm × 56,7 mm |
| Ungefähres Gewicht | ~61 g |
ESP32 Core installieren
Das 2,8″ ESP32 Solo Miner LCD Display basiert auf dem ESP32. Um es zu programmieren, musst du den ESP32 Core in deiner Arduino IDE installieren.
Öffne zunächst den Preferences-Dialog, indem du im Menü „File“ „Preferences…“ auswählst. Dadurch öffnet sich der unten gezeigte Preferences-Dialog.
Unter dem Reiter „Settings“ findest du unten im Dialog ein Eingabefeld mit der Bezeichnung „Additional boards manager URLs“:
Füge in dieses Eingabefeld folgende URL ein:
https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json
Damit weiß die Arduino IDE, wo sie die ESP32 Core-Bibliotheken findet. Als Nächstes installieren wir die ESP32 Boards über den Boards Manager.
Öffne den Boards Manager über „Tools -> Boards -> Board Manager“. Der Boards Manager erscheint in der linken Seitenleiste. Gib oben im Suchfeld „ESP32“ ein, und du solltest zwei Arten von ESP32 Boards sehen: die „Arduino ESP32 Boards“ und die „esp32 by Espressif“ Boards. Wir wollen die „esp32 libraries by Espressif“. Klicke auf den INSTALL-Button und warte, bis der Download und die Installation abgeschlossen sind.
Ich verwende hier Version 3.3.5, aber jede andere 3.x Version sollte für dieses Projekt ebenfalls funktionieren. Wenn du mehr Informationen brauchst, lies unser Install ESP32 core in Arduino IDE Tutorial.
Board auswählen
Du musst auch ein ESP32 Board auswählen. Im Fall des 2,8″ ESP32 Solo Miner LCD Displays kannst du das generische „ESP32S3 Dev Module“ wählen. Klicke dazu auf das Dropdown-Menü und dann auf „Select other board and port…“:
Es öffnet sich ein Dialog, in dem du „esp32s3 dev“ in die Suchleiste eingibst. Du siehst das Board „ESP32S3 Dev Module“ unter Boards. Klicke darauf, wähle den COM-Port aus, um es zu aktivieren, und klicke dann auf OK:
Beachte, dass du das Board per USB-Kabel mit deinem Computer verbinden musst, bevor du einen COM-Port auswählen kannst.
GPIO testen
Das Solo Miner Board stellt zwei GPIO-Pins am GPIO_D Port bereit. In diesem Beispiel implementieren wir ein einfaches Blink Programm, um den GPIO-Port zu testen.
Da das Display keine eingebaute LED hat, schließen wir zwei externe LEDs an und steuern sie. Das folgende Schaltbild zeigt, wie du die zwei LEDs an den Port anschließt:
Die Pins am GPIO_D Port sind IO25; IO32, 3,3 V, GND. Wir benötigen nur die zwei GPIO-Pins und Masse, nicht die 3,3 V Versorgung. Beim Aufbau der Schaltung nicht die 220Ω Widerstände vergessen, um den Strom für die LEDs zu begrenzen, und darauf achten, dass Masse richtig verbunden ist.
Danach kannst du den folgenden Code hochladen, der die zwei LEDs abwechselnd blinken lässt. Er gibt auch Ausgaben im Serial Monitor aus, sodass du bei Problemen mit der Verkabelung zumindest überprüfen kannst, ob das Programm läuft. Stelle sicher, dass die Baudrate des Serial Monitors auf 115200 eingestellt ist.
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);
}
TFT_eSPI Bibliothek einrichten
Um etwas auf dem Display anzuzeigen, benötigst du eine Grafikbibliothek. Wir verwenden die TFT_eSPI Bibliothek von Bodmer. Um sie zu installieren, öffne den LIBRARY MANAGER, tippe „TFT_eSPI“ in die Suchleiste und klicke auf den INSTALL-Button. Das Bild unten zeigt, wie eine erfolgreiche Installation aussieht:
Als Nächstes müssen wir eine Datei namens tft_setup.h mit den korrekten Parametern für das Display erstellen. Diese Datei muss Teil jedes Arduino-Projekts sein, das das Display verwendet.
So funktioniert das im Detail: Erstelle zuerst ein neues Arduino-Projekt und speichere es z. B. als „tft_test“. Dadurch wird ein Ordner tft_test mit einer Datei tft_test.ino darin erstellt:
In diesem Ordner erstelle eine Datei namens „tft_setup.h“. Der Name muss exakt sein! Dein Projektordner sollte dann so aussehen:
tft_setup.hIn deiner Arduino IDE solltest du jetzt zwei Tabs sehen; tft_test.ino und tft_setup.h, auf die du klicken kannst, um die Dateien zu bearbeiten.
tft_test.ino and tft_setup.hIn der Datei tft_setup.h kopiere folgende Parametereinstellungen:
#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
In der Datei 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);
}
Beachte, dass tft_setup.h oben im Programm eingebunden ist. Der Code selbst ist leicht verständlich. Wir erstellen ein TFT_eSPI Objekt und initialisieren es in der setup() Funktion. In der loop-Funktion setzen wir Textfarbe, Größe und Ausrichtung und zeichnen den String „Makerguides“ zentriert auf dem TFT-Display.
Wenn du dieses Programm kompilierst und hochlädst, solltest du folgende Ausgabe auf deinem Display sehen:
In den nächsten Abschnitten lernst du, wie man Touch-Daten ausliest.
Touch-Events erkennen
Der folgende Code zeigt, wie man Touch-Events erkennt. Er zeichnet einen kleinen gelben Kreis an die Stelle, an der du den Bildschirm berührst:
#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);
}
Wie zuvor binden wir tft_setup.h und die TFT_eSPI Bibliothek ein. Dann erstellen wir das Display-Objekt und ein Array mit Kalibrierungsdaten. Das cal Array enthält im Wesentlichen die Eckkoordinaten und die Ausrichtung des Touchscreens. Im nächsten Abschnitt zeige ich dir, wie du die Kalibrierungsdaten findest, aber die hier angegebenen sollten für den Anfang funktionieren.
In der setup-Funktion initialisieren wir den Bildschirm, setzen die Ausrichtung, die Touch-Kalibrierungsdaten und füllen den Bildschirm mit Schwarz.
In der loop-Funktion rufen wir kontinuierlich getTouch() auf, um die Koordinaten eines Touch-Events zu erhalten. Die Funktion gibt true zurück, wenn eine Berührung erkannt wurde. In diesem Fall zeichnen wir einen gelben Kreis mit einem Radius von 5 Pixeln an den Koordinaten der Berührung. So sieht das auf dem Bildschirm aus:
Touchscreen kalibrieren
Der Touchscreen sitzt auf dem Display und hat eine andere Auflösung, Position und Ausrichtung als das Display. Um die Position der Touch-Events mit den Positionen auf dem Display abzugleichen, müssen wir den Touchscreen kalibrieren, indem wir die Eckkoordinaten und die Ausrichtung messen.
Diese Einstellungen werden im Kalibrierungs-Array gespeichert. Führe das folgende Programm aus, um die Kalibrierungsparameter zu ermitteln und im Serial Monitor auszugeben:
#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);
}
Beim Ausführen des Programms wirst du aufgefordert, die vier Ecken des Bildschirms zu berühren. Anschließend werden die fünf Kalibrierungsparameter (Eckkoordinaten und Bildschirmausrichtung) ausgegeben. Dein Display sollte während der Kalibrierung so aussehen:
Im Serial Monitor solltest du nach dem Berühren der vier Ecken etwa Folgendes sehen:
cal: { 210, 3484, 285, 3511, 7 }
Die Kalibrierung wiederholt sich alle 10 Sekunden, sodass du mehrere Versuche hast, die genauesten Parameter zu erhalten. Verwende diese Parameter dann bei der Initialisierung des Displays in der setup-Funktion:
...
uint16_t cal[5] = { 210, 3484, 285, 3511, 7 };
void setup() {
...
tft.setTouch(cal);
...
}
In den nächsten zwei Abschnitten zeige ich dir kurz, wie man Sound erzeugt und den SD-Kartenleser verwendet.
Sound auf Lautsprecher abspielen
Der folgende Code zeigt, wie man Sound auf dem Lautsprecher abspielt. Er erzeugt einen 440 Hz Ton für eine Sekunde mit einer Pause von einer Sekunde:
const int speakerPin = 26;
void setup() {
pinMode(speakerPin, OUTPUT);
}
void loop() {
tone(speakerPin, 440); // 440Hz tone
delay(1000);
noTone(speakerPin);
delay(1000);
}
Beachte, dass du einen externen Lautsprecher (3W, 4-8 Ohm) an den Lautsprecheranschluss der Display-Platine anschließen musst, da die Platine keinen integrierten Lautsprecher oder Summer hat.
SD-Kartentyp erkennen
Dieses letzte Codebeispiel zeigt, wie du den integrierten SD-Kartenleser des Displays verwendest, um eine SD-Karte zu erkennen:
#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() { }
Wenn du mehr Informationen und Beispiele zu SD-Kartenlesern brauchst, schau dir das SD Card Module with ESP32 Tutorial an.
Schaltpläne
Zur Übersicht hier die wichtigsten Teile des Schematics für das 2,8″ ESP32 Solo Miner LCD Display Board:
Fazit
Dieses Tutorial hat dir gezeigt, wie du das Display, den Touchscreen, den Lautsprecher und den SD-Kartenleser des 2.8-inch ESP32 Solo Miner LCD Display verwendest. Für weitere Informationen siehe das Github repo und Wiki bei Elecrow.
Das Solo Miner ESP32 Display Board bringt so ziemlich alles mit, was du für ein Projekt mit Display brauchst. Es beinhaltet ein TFT-Touchscreen, einen ESP32, einen TF-Kartensteckplatz, einen Batterieanschluss mit Ladefunktion, eine Lautsprecherschnittstelle und eine I2C-Schnittstelle.
Das bedeutet allerdings auch, dass die Anzahl der freien GPIO-Pins auf nur zwei begrenzt ist. Da jedoch eine I2C-Schnittstelle vorhanden ist, kannst du einen GPIO-Expander verwenden, um mehr GPIOs hinzuzufügen. Schau dir dazu unser Tutorial Using GPIO Expander MCP23017 With Arduino an.
Die Hardware des 2,8″ ESP32 Solo Miner Displays ist im Wesentlichen identisch mit dem CrowPanel 2,8″ ESP32 Display. Sieh dir das CrowPanel 2.8″ ESP32 Display : Easy Setup Guide Tutorial für mehr Informationen an.
Für Beispielanwendungen der ESP32 Displays siehe unsere Digital Clock with CrowPanel 3.5″ ESP32 Display, Parking sensor with CrowPanel ESP32 Display und das Digital Timer Switch with CrowPanel ESP32 Display Tutorials.
Wenn du Fragen hast, hinterlasse sie gerne im Kommentarbereich.
Viel Spaß beim Tüfteln ; )
