Dieses Tutorial zeigt dir, wie du mit dem CrowPanel Advance 7“ HMI Display (Version 1.0) von Elecrow startest. Das CrowPanel Advance 7“ HMI Display ist ein HMI-Touchscreen mit einem IPS-Display und einer Auflösung von 800*480. Als Hauptprozessor kommt der ESP32-S3 zum Einsatz, ausgestattet mit 512KB SRAM, 8M PSRAM und 16M Flash.
Neben dem großen IPS-Display gehören optionale Funkmodule für Thread, Zigbee, Matter, WiFi 6 oder 2,4 GHz Funk, ein Mikrofon- und Lautsprecherschnittstelle zu den Hauptmerkmalen. Dadurch eignet sich das Display für AI assistant Anwendungen, und Elecrow stellt Beispiel-code und Anleitungs-videos dafür bereit.
In diesem Tutorial beginnen wir jedoch mit einem sehr einfachen Beispiel, das nur Text auf dem Bildschirm anzeigt und auf Berührungen reagiert. So kannst du leicht mit dem Display starten. Beachte, dass ich Version 1.0 verwende und der Code für andere Display-Versionen möglicherweise nicht funktioniert!
Benötigte Teile
Du benötigst das CrowPanel Advance 7“ HMI Display von ELECROW und die Arduino IDE. Ich habe Version 1.0, es gibt aber eine neuere Version 1.2.
CrowPanel Advance 7“
Beachte, dass du das Display mit oder ohne Acrylgehäuse bekommen kannst. Letzteres ist praktisch, wenn du das Display beispielsweise an der Wand montieren möchtest und kein eigenes Gehäuse bauen willst. Achte nur auf die Reset-/Boot-Tasten auf der Rückseite. Diese ragen ziemlich heraus und wenn du das Display zu nah montierst, werden sie gedrückt.
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.
Merkmale des CrowPanel Advance 7“ Displays
Das CrowPanel Advance ESP32 7-Zoll Display ist ein IPS-Kapazitiv-Touchscreen mit einer Auflösung von 800*480 und einem 178°-weiten Betrachtungswinkel. Das Bild unten zeigt die Vorderseite des Displays mit den Maßen:
Das Display verwendet den ESP32-S3 Chip als Hauptprozessor. Dieser Chip ist mit einem Xtensa 32-Bit LX7 Dual-Core Prozessor mit einer Hauptfrequenz von bis zu 240MHz ausgestattet, sowie 512KB SRAM, 8M PSRAM und 16M Flash.
Peripheriegeräte
Das Displaymodul verfügt über eine Echtzeituhr (RTC) mit eingebauter Batterie, einen Ladeanschluss für die Batterie, einen Lautsprecherausgang, ein digitales Mikrofon, einen Summer, einen Micro-SD-Kartensteckplatz, einen I2C-Port, einen GPIO-Port mit zwei GPIOs und zwei UART-Ausgänge. Das Foto unten zeigt die Rückseite der Platine, auf der die meisten dieser Komponenten zu sehen sind:
Die folgende Tabelle gibt einen Überblick über die verschiedenen Anschlüsse, zugehörigen GPIO-Pins und elektrische Eigenschaften:
| Anschluss | Pins | Elektrische Eigenschaften |
|---|---|---|
| UART0-OUT | RX(IO44); TX(IO43) RX; | Ausgangsspannung: 3,3V Ausgangsstrom: max. 1A Verwendung: Stromversorgungsausgang und Kommunikation. |
| UART1-OUT | RX(IO19); TX(IO20) RX; | Ausgangsspannung: 3,3V Ausgangsstrom: max. 1A Verwendung: Stromversorgungsausgang und Kommunikation. |
| UART0-IN | RX(IO44); TX(IO43) RX; | Eingangsspannung: 5V ± 5%. Max. 5,5V Eingangsstrom: max. 2A Zweck: Stromversorgungseingang und Kommunikation. |
| I2C | SDA(IO15); SCL(IO16); | Ausgangsspannung: 3,3V Ausgangsstrom: max. 1A Verwendung: Stromversorgungsausgang und Kommunikation. |
| SPK | I2S_LRCLK(IO6); I2S_BCLK(IO5); I2S_SDIN(IO4); | Maximaler Ausgangsstrom: 20mA Signaltyp: 3,3V Logikpegel, digitales Steuersignal |
| SD-Kartensteckplatz | MOSI(IO6); MISO(IO4); CLK(IO5); CS(GND) | Maximaler Ausgangsstrom: 20mA Signaltyp: 3,3V Logikpegel, digitales Steuersignal |
| LCD-Hintergrundbeleuchtung | P3.5 (STC8H1K28) | Maximaler Ausgangsstrom: 20mA Signaltyp: 3,3V Logikpegel, digitales Steuersignal |
| Hintergrundbeleuchtungsanpassung | P1.1 (STC8H1K28) | |
| I2S-Mikrofon | MIC_SD(IO20); MIC_WS(IO2); MIC_CLK(IO19) | Maximaler Ausgangsstrom: 20mA Signaltyp: 3,3V Logikpegel, digitales Steuersignal |
| SUMMER | P2.7 (STC8H1K28) | Maximaler Ausgangsstrom: 20mA Signaltyp: 3,3V Logikpegel, digitales Steuersignal |
| TP_RST | P1.7 (STC8H1K28) | |
| Leistungsverstärker MUTE | P3.7 (STC8H1K28) | |
| Leistungsverstärker SHUT | P3.6 (STC8H1K28) |
Funktionsauswahl
Einige Peripheriegeräte wie Mikrofon (MIC), Lautsprecher (SPK), Funkmodul (WM) und SD-Karte (TF Card) konkurrieren um GPIO-Pins und können nur in bestimmten Kombinationen verwendet werden. Auf der Rückseite des Displays findest du eine Tabelle und zwei DIP-Schalter, mit denen du eine bestimmte Kombination auswählen kannst:
Drahtlose Kommunikation
Zusätzlich zur integrierten 2,4GHz Wi-Fi- und BLE-Funktion mit eingebauter RF-Antenne verfügt das Display über einen separaten Steckplatz für ein Funkmodul. Es gibt vier Funkmodule zur Auswahl: Module-ESP32-H2, Module-ESP32-C6, Module-nRF2401 und das Module-Meshtastic, mit denen du über Zigbee, LoRa, nRF2401, Matter, Thread und Wi-Fi 6 kommunizieren kannst. Das Bild unten zeigt, wo diese Kommunikationsmodule eingesetzt werden:
Für weitere technische Informationen siehe Description page for the CrowPanel Advance 7“ Display.
Andere Display-Varianten
Das CrowPanel Advance ESP32 7-Zoll Display ist eine Weiterentwicklung des Standard CrowPanel ESP32 7-Zoll Displays. Diese Displays gibt es in verschiedenen Größen und Auflösungen, mit unterschiedlichen Display-Treibern und Funktionen. Die folgende Tabelle gibt einen Überblick über die verschiedenen Display-Optionen:
Einrichten des CrowPanel Advance 7“ Displays
Die Programmierung des CrowPanel Advance 7“ Displays ist etwas knifflig, da du bestimmte Versionen der Bibliotheken und des ESP32-Cores installieren musst. Andere Versionen könnten funktionieren, wurden von mir aber nicht getestet.
Bibliotheken installieren
Zuerst installieren wir die benötigten Bibliotheken. Gehe zum CrowPanel-Advance-HMI-lib Ordner, der auf einem Google Drive liegt. Lade von dort die librariesAdvance7.0.rarDatei herunter, indem du auf das Download-Symbol klickst, wie unten gezeigt:
librariesAdvance7.0.rar ist eine komprimierte Datei, die du zuerst entpacken musst. Klicke einfach auf die Datei im Explorer (unter Windows) und kopiere den Inhalt in einen anderen Ordner. In meinem Fall habe ich den Inhalt in folgenden Ordner kopiert:
c:\Maet\Temp\librariesAdvance7.0\libraries
Der Screenshot unten zeigt einen Teil des Inhalts dieses Ordners, dein Ordnerinhalt sollte ähnlich aussehen:
librariesOrdnersDu kannst jeden anderen Pfad wählen, aber er muss mit \libraries enden, da wir ihn in den Pfadeinstellungen der Arduino IDE verwenden werden.
Die Arduino IDE speichert installierte Bibliotheken im Ordner \libraries unter dem Sketchbook-Verzeichnis. Du könntest alle Bibliotheken in diesem Verzeichnis durch die heruntergeladenen ersetzen, aber dann verlierst du alle zuvor installierten Bibliotheken.
Stattdessen ändern wir (vorübergehend) den Pfad für das Sketchbook-Verzeichnis, was schneller und leichter rückgängig zu machen ist. Öffne den Dialog Datei -> Einstellungen und gib den Pfad c:\Maet\Temp\librariesAdvance7.0 im Feld für das Sketchbook-Verzeichnis ein, wie unten gezeigt:
Achte darauf, dass du den \libraries Ordner am Ende des Pfads NICHT hinzufügst. Die Arduino IDE sucht diesen Ordner automatisch. Anders gesagt: Die heruntergeladenen Bibliotheken liegen unter c:\Maet\Temp\librariesAdvance7.0\libraries, du gibst aber den Pfad c:\Maet\Temp\librariesAdvance7.0 ein.
Wenn du mit der Programmierung des CrowPanel Advance 7“ Displays fertig bist, kannst du den Pfad für das Sketchbook-Verzeichnis wieder auf den ursprünglichen Pfad zurücksetzen und deine ursprünglichen Bibliotheken zurückbekommen. Unter Windows ist das typischerweise c:\Users\<username>\OneDrive\Documents\Arduino.
ESP32 Core Version 3.0.2 installieren
Als nächstes müssen wir eine bestimmte Version des ESP32-Cores installieren. Öffne den BOARDS MANAGER, gib „esp32“ in das Suchfeld ein und du siehst die „esp32 by Espressif Systems“ Boards, wie unten gezeigt:
Wenn du die ESP32 Boards noch nicht installiert hast, siehst du einen INSTALL-Button. Wenn du die Boards schon installiert hast, aber nicht die neueste Version (wie oben), siehst du stattdessen einen UPDATE-Button.
Klicke in jedem Fall auf die Dropdown-Liste und wähle die Version 3.0.2 aus, wie unten gezeigt, und drücke dann INSTALLIEREN.
Im Screenshot siehst du, dass ich Version 3.0.2 bereits installiert habe und deshalb der UPDATE-Button angezeigt wird. Du solltest dasselbe sehen, sobald du den ESP32 Core 3.0.2 installiert hast. Wenn du mehr Hilfe brauchst, schau dir unser How to Program ESP32 with Arduino IDE Tutorial an.
Board auswählen
Als nächstes wählen wir ein passendes ESP32 Board aus. Für das CrowPanel Advance 7“ wählen wir das „ESP32S3 Dev Module“. Verbinde dazu zuerst das Display per USB-Kabel mit deinem Computer. Klicke dann 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 „ESP32S3 Dev Module“ Board unter Boards. Klicke darauf und auf den COM-Port, um es zu aktivieren, und dann auf OK:
Den COM-Port kannst du nur auswählen, wenn das Display per USB mit dem Computer verbunden ist.
Board-Einstellungen
Zum Schluss müssen wir die richtigen Parameter für das Board einstellen. Gehe dazu ins Tools-Menü, wie unten gezeigt:
Es öffnet sich ein großes Dropdown-Menü mit den Einstellungsoptionen am Ende. Stelle sicher, dass du folgende Parameter setzt:
Insbesondere sollte die Flash-Größe auf 16MB, das Partition-Schema auf Huge APP und das PSRAM auf OPI PSRAM eingestellt sein. Weitere Informationen findest du auf der Product Introduction Seite für das CrowPanel Advance 7“ Display.
Zeichnen auf dem CrowPanel Advance 7“ Display
Mit der Einrichtung abgeschlossen, können wir nun mit der Programmierung des Displays beginnen. Das CrowPanel Advance 7“ Display wird mit code Beispielen und Video-tutorials geliefert, die alle SquareLine Studio and LVGL verwenden, um etwas auf dem Bildschirm anzuzeigen.
Das ist großartig für komplexere Benutzeroberflächen, aber etwas schwierig, wenn du gerade erst mit dem Display starten möchtest, da der zugehörige Code recht umfangreich und komplex ist.
Das folgende Beispiel ist viel einfacher und zeigt dir, wie du Text auf dem Bildschirm ausgibst und auf Berührungen reagierst, indem du die LovyanGFX Bibliothek nutzt. Wenn du der oben beschriebenen Einrichtung gefolgt bist, hast du die LovyanGFX Bibliothek bereits installiert.
Projektstruktur
Zuerst erstellen wir den notwendigen Projektordner. Erstelle einen Ordner mit dem Namen „advance7“ mit zwei Dateien darin, die „advance7.ino“ und „lgfx_conf.h“ heißen:
Öffne dann die advance7.inoDatei in deiner Arduino IDE. Du solltest Tabs für die beiden Projektdateien sehen:
LovyanGFX-Konfiguration
In der lgfx_conf.h Datei kopiere den folgenden Code, der die LGFX Klasse mit der Pin-Konfiguration für das Display erstellt.
// lgfx_conf.h
#define LGFX_USE_V1
#include <LovyanGFX.hpp>
#include <lgfx/v1/platforms/esp32s3/Panel_RGB.hpp>
#include <lgfx/v1/platforms/esp32s3/Bus_RGB.hpp>
#include <driver/i2c.h>
class LGFX : public lgfx::LGFX_Device {
public:
lgfx::Bus_RGB _bus_instance;
lgfx::Panel_RGB _panel_instance;
lgfx::Touch_GT911 _touch_instance;
LGFX(void) {
{
auto cfg = _panel_instance.config();
cfg.memory_width = 800;
cfg.memory_height = 480;
cfg.panel_width = 800;
cfg.panel_height = 480;
cfg.offset_x = 0;
cfg.offset_y = 0;
_panel_instance.config(cfg);
}
{
auto cfg = _panel_instance.config_detail();
cfg.use_psram = 1;
_panel_instance.config_detail(cfg);
}
{
auto cfg = _bus_instance.config();
cfg.panel = &_panel_instance;
cfg.pin_d0 = GPIO_NUM_21; // B0
cfg.pin_d1 = GPIO_NUM_47; // B1
cfg.pin_d2 = GPIO_NUM_48; // B2
cfg.pin_d3 = GPIO_NUM_45; // B3
cfg.pin_d4 = GPIO_NUM_38; // B4
cfg.pin_d5 = GPIO_NUM_9; // G0
cfg.pin_d6 = GPIO_NUM_10; // G1
cfg.pin_d7 = GPIO_NUM_11; // G2
cfg.pin_d8 = GPIO_NUM_12; // G3
cfg.pin_d9 = GPIO_NUM_13; // G4
cfg.pin_d10 = GPIO_NUM_14; // G5
cfg.pin_d11 = GPIO_NUM_7; // R0
cfg.pin_d12 = GPIO_NUM_17; // R1
cfg.pin_d13 = GPIO_NUM_18; // R2
cfg.pin_d14 = GPIO_NUM_3; // R3
cfg.pin_d15 = GPIO_NUM_46; // R4
cfg.pin_henable = GPIO_NUM_42;
cfg.pin_vsync = GPIO_NUM_41;
cfg.pin_hsync = GPIO_NUM_40;
cfg.pin_pclk = GPIO_NUM_39;
cfg.freq_write = 21000000;
cfg.hsync_polarity = 0;
cfg.hsync_front_porch = 8;
cfg.hsync_pulse_width = 4;
cfg.hsync_back_porch = 8;
cfg.vsync_polarity = 0;
cfg.vsync_front_porch = 8;
cfg.vsync_pulse_width = 4;
cfg.vsync_back_porch = 8;
cfg.pclk_idle_high = 1;
_bus_instance.config(cfg);
}
_panel_instance.setBus(&_bus_instance);
{
auto cfg = _touch_instance.config();
cfg.x_min = 0;
cfg.x_max = 800;
cfg.y_min = 0;
cfg.y_max = 480;
cfg.pin_int = -1;
cfg.bus_shared = false;
cfg.offset_rotation = 0;
cfg.i2c_port = I2C_NUM_0;
cfg.pin_sda = GPIO_NUM_15;
cfg.pin_scl = GPIO_NUM_16;
cfg.pin_rst = -1;
cfg.freq = 400000;
cfg.i2c_addr = 0x5D; // 0x5D , 0x14
_touch_instance.config(cfg);
_panel_instance.setTouch(&_touch_instance);
}
setPanel(&_panel_instance);
}
};
Es ist die Konfiguration für das Display, wie sie von der LovyanGFX Bibliothek benötigt wird, und im Wesentlichen eine Kopie der LovyanGFX_Driver.h Datei aus dem Codebeispiel lesson-03. Sie teilt der Bibliothek mit, welche Pins des Displays und der Touch-Schnittstelle mit welchen GPIO-Pins des ESP32 verbunden sind.
Diese Konfigurationsdatei bleibt für alle Projekte gleich und du kannst sie bei Bedarf in verschiedene Projekte kopieren.
Code zum Zeichnen
Kopiere abschließend den folgenden Code in die advance7.ino Datei. Es ist ein einfacher Test, der etwas Text auf dem Display schreibt und auf Berührungen reagiert:
#include "lgfx_conf.h"
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <TCA9534.h>
LGFX gfx;
TCA9534 ioex;
void initIOEX() {
Wire.begin(15, 16);
delay(50);
ioex.attach(Wire);
ioex.setDeviceAddress(0x18);
ioex.config(1, TCA9534::Config::OUT);
ioex.config(2, TCA9534::Config::OUT);
ioex.config(3, TCA9534::Config::OUT);
ioex.config(4, TCA9534::Config::OUT);
ioex.output(1, TCA9534::Level::H); // backlight
}
void initGT911() {
pinMode(1, OUTPUT);
digitalWrite(1, LOW);
ioex.output(2, TCA9534::Level::L);
delay(20);
ioex.output(2, TCA9534::Level::H);
delay(100);
pinMode(1, INPUT);
}
void setup() {
initIOEX();
initGT911();
gfx.init();
gfx.fillScreen(TFT_BLUE);
gfx.setTextColor(TFT_WHITE, TFT_BLUE);
gfx.setTextSize(4);
gfx.drawString("Makerguides-4", 250, 200);
}
void loop() {
uint16_t touch_x, touch_y;
if (gfx.getTouch(&touch_x, &touch_y)) {
gfx.fillCircle(touch_x, touch_y, 10, TFT_YELLOW);
}
delay(100);
}
Genauer gesagt füllt dieser Code den Hintergrund des Displays mit Blau, schreibt den Text „Makerguides-4“ und reagiert auf Berührungen, indem er an der Berührungsstelle einen gelben Kreis zeichnet. Das Bild unten zeigt, wie der Bildschirm nach einigen Berührungen aussieht:
In den nächsten Abschnitten schauen wir uns den Code genauer an und erklären, wie er funktioniert.
Includes
Der Code beginnt mit dem Einbinden der Display-Konfigurationsdatei, der Wire-Bibliothek für I2C-Kommunikation, der Adafruit_GFX-Bibliothek zum Zeichnen und der TCA9534-Bibliothek für den IO-Expander, der Teil des CrowPanel Advance 7“ Displays ist:
#include "lgfx_conf.h" #include <Wire.h> #include <Adafruit_GFX.h> #include <TCA9534.h>
Objekte
Als nächstes erstellen wir Objekte für das Display und den IO-Expander:
LGFX gfx; TCA9534 ioex;
initIOEX Funktion
Die initIOEX Funktion initialisiert den TCA9534 IO-Expander. Dieser wird benötigt, um die Kommunikation zwischen Display und ESP32 über die begrenzte Anzahl an GPIO-Kanälen zu routen.
void initIOEX() {
Wire.begin(15, 16);
delay(50);
ioex.attach(Wire);
ioex.setDeviceAddress(0x18);
ioex.config(1, TCA9534::Config::OUT);
ioex.config(2, TCA9534::Config::OUT);
ioex.config(3, TCA9534::Config::OUT);
ioex.config(4, TCA9534::Config::OUT);
ioex.output(1, TCA9534::Level::H); // backlight
}
Wichtig ist auch die letzte Zeile, die die Hintergrundbeleuchtung des Displays einschaltet. Ohne Hintergrundbeleuchtung siehst du nichts.
initGT911 Funktion
Die initGT911 Funktion initialisiert den Touchscreen-Controller (GT911) für das Display. So kann der ESP32 auf Berührungen reagieren.
void initGT911() {
pinMode(1, OUTPUT);
digitalWrite(1, LOW);
ioex.output(2, TCA9534::Level::L);
delay(20);
ioex.output(2, TCA9534::Level::H);
delay(100);
pinMode(1, INPUT);
}
setup Funktion
In der setup-Funktion initialisieren wir den IO-Expander, den GT911 und das Display. Dann füllen wir den Bildschirm mit Blau und schreiben den Text „Makerguides-4“ ungefähr in die Mitte bei Position (250, 200) in Weiß.
void setup() {
initIOEX();
initGT911();
gfx.init();
gfx.fillScreen(TFT_BLUE);
gfx.setTextColor(TFT_WHITE, TFT_BLUE);
gfx.setTextSize(4);
gfx.drawString("Makerguides-4", 250, 200);
}
loop Funktion
In der loop-Funktion rufen wir wiederholt die gfx.getTouch() Funktion auf, um nach Berührungen zu prüfen. Wenn eine Berührung erkannt wird, holen wir die Berührungsposition aus den Variablen touch_x und touch_y und zeichnen an dieser Stelle einen gefüllten gelben Kreis mit einem Radius von 10 Pixeln.
void loop() {
uint16_t touch_x, touch_y;
if (gfx.getTouch(&touch_x, &touch_y)) {
gfx.fillCircle(touch_x, touch_y, 10, TFT_YELLOW);
}
delay(100);
}
Wenn du den Code kompilierst und hochlädst, wirst du bemerken, dass die Arduino IDE dich darauf hinweist, dass Updates für deine Boards und Bibliotheken verfügbar sind.
Installiere diese Updates nicht, da sie die spezifischen Bibliotheks- und Board-Versionen ersetzen würden, die wir gerade installiert haben.
Display Version 1.0 vs 1.2
Es gibt ein Problem mit der älteren Version V1.0 des CrowPanel Advance 7“ Displays, das du kennen solltest. Die Version deines Displays findest du auf der Rückseite der Platine. Siehe Foto unten. Wenn dein Display mit Acrylgehäuse kommt, musst du die Rückplatte entfernen, um die Versionsnummer zu sehen.
Die H2- und C6-Module für die drahtlose Kommunikation, die mit der V1.0 Charge des Displays geliefert werden, haben keine vorinstallierte Firmware. Leider kannst du keinen seriellen Programmer direkt anschließen, um die Firmware zu flashen, da die Header-Pins fehlen. Du musst Pins anlöten, die Firmware flashen und sie dann wieder entfernen.
Für mehr Details siehe https://github.com/Elecrow-RD/CrowPanel-Advance-5.0-HMI-ESP32-AI-Display-800×480/tree/master/example/example_code5.0/lesson-09.
Beachte, dass es auch Unterschiede in den Schaltplänen für Version 1.0 und die aktuelle Version 1.2 gibt, die für manche Anwendungen wichtig sein könnten.
Fazit
Ich hoffe, dieses Tutorial hat dir den Einstieg mit dem CrowPanel Advance 7“ HMI Display erleichtert. Wir haben ein einfaches Codebeispiel gezeigt, wie man Text auf dem Display ausgibt und auf Berührungen reagiert. Für viele Anwendungen ist das ein guter Startpunkt.
Wenn du komplexere Benutzeroberflächen bauen möchtest, sind SquareLine Studio and LVGL der richtige Weg, sie sind aber auch schwieriger zu nutzen und der Code deutlich komplexer.
Elecrow bietet außerdem mehrere code Beispiele und Video-tutorials, die zeigen, wie man den Lautsprecher, die SD-Karten-Schnittstelle, die verschiedenen Funkoptionen nutzt und wie man KI-Anwendungen baut, wie z.B. ein Chat Bot.
Wenn du ein kleineres, einfacheres CrowPanel Display suchst, schau dir unser CrowPanel 2.8″ ESP32 Display : Easy Setup Guide an. Wir haben auch Tutorials zu Anwendungen mit CrowPanel Displays wie Digital Clock with CrowPanel 3.5″ ESP32 Display, Digital Timer Switch with CrowPanel ESP32 Display oder dem Parking sensor with CrowPanel ESP32 Display, die interessant sein könnten.
Wenn du Fragen hast, hinterlasse sie gerne im Kommentarbereich.
Viel Spaß beim Tüfteln ; )
Links
Hier einige Links zum CrowPanel Advance 7“ HMI Display, die ich beim Schreiben dieses Tutorials als nützlich empfand:
- Wiki
- Specification
- Setup Instructions
- Code Examples
- Code for Wireless Modules
- Video Tutorials
- Schematics Version 1.0
- Schematics Version 1.2
Thomas
Wednesday 18th of February 2026
Hallo, ich verwende das 7" Display mit der V1.2. Kann ich dafür diese lgfx_conf.h verwenden?
Mein Display bleibt nachdem hochladen schwarz.
Danke und Gruß Thomas
Stefan Maetschke
Thursday 19th of February 2026
Soweit ich weiss hat sich die Hardware für V1.2 geändert und der Beispielcode in diesem Blogpost funktioniert leider nur mit V.1.0.