CrowPanel Advance 7" Display: Grundlagen und GUI-Entwicklung mit LVGL/ESP-IDF

In letzter Zeit tauchen immer mehr Boards auf, die einen ESP32 direkt mit einem Display kombinieren. Für uns Maker ist diese Kombination besonders spannend, da der ESP32 einerseits ein leistungsfähiges Framework bietet und andererseits das große Display viele neue Einsatzmöglichkeiten eröffnet. Vor ein paar Wochen hat Elecrow ein neues, sehr interessantes Display vorgestellt, und zwar das CrowPanel Advance 7“ HMI ESP32-S3 AI-Powered IPS Touch Screen aus der Advanced Serie.

Das Display präsentiert sich als eine vielseitige Plattform für Mensch-Maschine-Schnittstellen (HMI) und IoT-Projekte. Ausgestattet mit dem ESP32-S3-Mikrocontroller, einem 7 Zoll Touchscreen und der Unterstützung verschiedener Entwicklungsumgebungen, bietet dieses Display eine solide Grundlage für eine breite Palette von Anwendungen. In diesem Beitrag möchte ich euch das Display vorstellen und zeigen, wie ihr euer erstes Programm mit ESP-IDF darauf zum Laufen bringt.

Zunächst ein kurzer Überblick über die wichtigsten Features des Displays:

7 Zoll IPS-Display mit einer Auflösung von 800x480 Pixeln und einer Helligkeit von 400 cd/m².
Kapazitive Touch-Steuerung.
ESP32-S3-WROOM-1-N16R8 Modul (Dual-Core 32-Bit LX7 Mikroprozessor mit bis zu 240 MHz).
512KB SRAM, 8MB PSRAM und 16MB Flash-Speicher.
2.4GHz Wi-Fi (802.11 b/g/n) und Bluetooth 5 (LE).
Echtzeituhr mit Batterie.
Peripherie-Schnittstellen: 2x UART0, 1x UART1, 1x I²C.
TF-Kartensteckplatz, USB-C Anschluss, Lautsprecheranschluss, Batterieanschluss, Anschluss für Erweiterungsmodule.
Erweiterte KI-Funktionalität (Integriertes Mikrofon und Lautsprecher mit Klasse-D Verstärker auf dem Board).
Modulares Design ermöglicht den Austausch von Modulen zur Unterstützung verschiedener Kommunikationsprotokolle (Zigbee, LoRa, nRF2401, Matter, Thread, Wi-Fi 6).
Entwicklungsumgebungen: Arduino IDE, Espressif IDF, PlatformIO und MicroPython.
Kompatibel mit der LVGL Grafikbibliothek.

Viele dieser Eigenschaften sind auch bei anderen ESP32-basierten Boards zu finden, doch einige Punkte bietet, bis auf wenige Ausnahmen, nur dieses Board.

Zum Standard-Lieferumfang gehören neben dem Display ein USB-C-Kabel und ein 4-poliges Kabel mit Crowtail-Stecker. Optional kann bei der Bestellung ein passendes, dreiteiliges Acryl-Gehäuse hinzugefügt werden, das alle Anschlüsse frei zugänglich lässt.

Zusätzlich sind für das Display insgesamt vier verschiedene Erweiterungsmodule erhältlich: das ESP32-H2, das ESP32-C6, das nRF2401 und ein LoRa-Modul. Anfangs bestand noch die Möglichkeit, alle Module einzeln zum Display dazuzubestellen. Inzwischen hat Elecrow das Angebot jedoch umstrukturiert: Das Display wird nun in zwei Varianten verkauft. Bei der ersten Variante können nur noch die Module ESP32-H2, ESP32-C6 und nRF2401 optional mitbestellt werden, während die zweite Variante mit dem LoRa-Modul ausgestattet ist.

Der Aufbau des CrowPanel Advance HMI ESP32 AI Displays

Die zentrale Komponente bildet wie bei allen ESP32-basierten Boards mit einem parallelen Display ein ESP32-S3 in Form eines ESP32-S3-WROOM-1-N16R8 Moduls. Neben 512KB SRAM, 8MB PSRAM und 16MB Flash-Speicher stehen bei diesem Modul 36 GPIO-Pins für die Ansteuerung der Peripherie zur Verfügung. Davon sind allerdings drei Ports mit dem Octal SPI PSRAM verbunden und können daher nicht für andere Zwecke verwendet werden. Das folgende Diagramm veranschaulicht, wie die verbleibenden 33 GPIO-Pins mit den restlichen Komponenten des Displays verbunden sind.

Die meisten Pins werden für das parallele Display benötigt. Das Display verwendet das RGB565-Format, also 5 Bit für Rot, 6 Bit für Grün und 5 Bit für Blau. Weitere 4 Leitungen werden für HSYNC, VSYNC, Data Enable und das Clock Signal verwendet. Somit verbleiben für die gesamte restliche Peripherie nur noch 13 Leitungen. Daher hat Elecrow zu einigen Tricks gegriffen, die es trotzdem ermöglichen, alle externen Geräte anzusprechen, allerdings mussten dafür auch einige Kompromisse eingegangen werden:

PCA9557 8-Bit I/O-Expander: Der PCA9557 ist ein 8-Bit I/O-Expander, der über den I²C-Bus gesteuert wird. Er dient dazu, die Anzahl der parallelen Eingangs-/Ausgangs-Ports in einem System zu erweitern. Der Baustein verfügt über Konfigurationsregister, mit denen jeder der 8 I/O-Pins entweder als Eingang oder als Ausgang definiert werden kann. Zudem besitzt er ein Register, um die Polarität der Eingangssignale umzukehren. Mit diesen Ports werden die SHUT und MUTE Signale für den Verstärker, die Reset Leitung des Touch Interfaces und die Hintergrundbeleuchtung des Displays gesteuert. Üblicherweise wird die Helligkeit der Hintergrundbeleuchtung über ein PWM Signal der LEDC Peripherie gesteuert. Mit dem PCA9557 ist es aber nicht möglich, diesen PWM Signalgenerator zu verwenden und der I²C Bus ist für diese Aufgabe nicht geeignet. Das Display leuchtet daher im eingeschaltetem Zustand immer mit voller Helligkeit.
CH486F High-Speed-Analogschalter: Der CH486F ist ein bidirektionaler High-Speed-Analogschalter mit zwei unabhängigen 4:1-Umschaltern. Auf dem Display sind zwei dieser Bausteine verbaut, die jeweils drei GPIO-Pins umschalten. Dadurch wird es möglich, so alle Komponenten anzusteuern, es kann aber immer nur die Komponente verwendet werden, auf die der Analogschalter gerade eingestellt ist. Diese Einstellung erfolgt durch zwei DIP-Schalter auf dem Board. Folgende Einstellungen stehen dafür zur Verfügung:
- TF-Kartensteckplatz: Bei dieser Einstellung werden drei Ports für die SPI Schnittstelle verwendet, um eine SD-Karte anzusteuern. Die CS-Leitung der SD-Karte ist direkt mit Masse verbunden.
- Mikrofon/Verstärker: Hier werden die beiden I²S Module des ESP32-S3 verwendet, die jeweils drei Leitungen benötigen. Elecrow bezeichnet das Display als "AI-Powered", was zunächst suggeriert, dass auf dem Board irgendeine Art KI-Beschleuniger verbaut ist. Dem ist aber nicht so. Vielmehr ist damit gemeint, dass es möglich ist, mit dem Mikrophon und einem Lautsprecher einen Chatbot zu entwickeln, der beispielsweise das API von OpenAI oder Google verwendet, um Spracheingaben zu verarbeiten und die Antwort auf dem Lautsprecher auszugeben.
- Wireless Module: Für die Module werden vier Leitungen für die SPI Schnittstelle und jeweils zwei Leitungen für die serielle Schnittstelle bzw. den I²C Bus verwendet. Auf die unterschiedlichen Module gehe ich später noch ein.

Die verbleibenden GPIO-Pins werden für die I²C Schnittstelle, den USB-Port, den Buzzer, die Interrupt-Leitung des Touch-Controllers und das IO0 Pin verwendet. Zusätzlich ist über die I²C Schnittstelle ein Echtzeituhr- und Kalender-Chip vom Typ BM8563 verbunden.

Grundsätzlich finde ich die Idee sehr gut, die Beschränkungen des ESP32-S3 auf diese Weise zu umgehen. Allerdings gibt es dadurch einige interessante Szenarien, die sich damit nicht umsetzen lassen. Wenn ich beispielsweise das ESP32-C6 Modul verwende, um Geräte per Zigbee oder Matter anzusteuern, und ich diese Steuerung über Sprachbefehle umsetzen will, dann geht das nicht. Genauso wenig könnte ich die Daten des LoRa Moduls auf einer SD-Karte speichern. Ich möchte hier aber noch einmal betonen, dass das Problem nicht bei Elecrow liegt, sondern an der begrenzten Anzahl von GPIO-Pins des ESP32-S3, speziell bei Verwendung eines parallelen Displays.

Die Funkmodule

Das eigentliche Highlight dieses Displays sind die optionalen Module. Andere Displays besitzen zwar teilweise auch eine GPIO Leiste für Erweiterungen, aber nur das Elecrow Display bietet fertige Module für diverse drahtlose Technologien an, die der ESP32-S3 nicht unterstützt:

Zigbee: Ein etablierter Standard für Heimautomation und IoT, der auf stromsparende Mesh-Netzwerke über kurze bis mittlere Distanzen (primär 2,4 GHz, auch Sub-GHz) setzt. Ideal für batteriebetriebene Sensoren, aber anfällig für Interferenzen im 2,4-GHz-Band und mit begrenzter Reichweite/Datenrate.
LoRa: Spezialisiert auf extrem weite Reichweiten (Kilometer) bei sehr geringem Energieverbrauch (LPWAN) unter Verwendung von Sub-GHz-Bändern. Die Datenraten sind jedoch sehr niedrig, was es für Fernüberwachung, aber nicht für bandbreitenintensive Anwendungen geeignet macht. Zur Netzwerkintegration via LoRaWAN werden Gateways benötigt.
nRF2401: Eine kostengünstige und bei Makern beliebte 2,4-GHz-Lösung für die Kurzstreckenkommunikation (bis ca. 100 Meter, erweiterbar) mit moderaten Datenraten. Einfach zu nutzen, aber anfällig für 2,4-GHz-Interferenzen und empfindlich bezüglich der Stromversorgung.
Matter: Ein neuer Standard zur Vereinheitlichung von Smart-Home-Geräten verschiedener Hersteller. Nutzt bestehende Technologien wie Wi-Fi und Thread, um Interoperabilität, einfache Einrichtung und lokale Steuerung zu ermöglichen. Relevant für das Display via Wi-Fi oder optionalem Thread-Modul.
Thread: Ein stromsparendes, sicheres und zuverlässiges IPv6-basiertes Mesh-Netzwerkprotokoll (IEEE 802.15.4 im 2,4-GHz-Band), das speziell für Smart-Home-Geräte entwickelt wurde und eine Grundlage für Matter bildet. Benötigt einen Border-Router für die Verbindung zu anderen IP-Netzwerken.
Wi-Fi 6 (802.11ax): Die neueste Wi-Fi-Generation bietet deutlich höhere Geschwindigkeiten, Kapazität und Effizienz, besonders in Umgebungen mit vielen Geräten. Ideal für datenintensive Anwendungen, aber mit höherem Energieverbrauch als Low-Power-Technologien.

Diese Optionen ermöglichen die Anpassung des Displays an spezifische Projektanforderungen, von einfacher Nahbereichskommunikation bis hin zu komplexen Smart-Home-Integrationen oder Sensornetzwerken.

Die Module werden über einen 2 x 7 Pin GPIO-Header mit dem Display verbunden. Die Anordnung der Pins sieht folgendermaßen aus:

Für die Module stehen also gleich drei Schnittstellen zur Verfügung, UART, I²C und SPI. Ein kleines Detail ist besonders erfreulich. Es steht auch die 5 Volt Stromversorgung zur Verfügung. Bei allen anderen Displays, die ich bisher für die Wetterstation verwendet habe, musste ich hier extra ein Kabel anlöten, um den Feinstaubsensor mit der nötigen Spannung zu versorgen.

Die folgenden vier Module bietet Elecrow bisher an:

ESP32-H2 Modul

Dieses Modul basiert auf dem ESP32-H2 Chip von Espressif. Sein Fokus liegt klar auf Low-Power-IoT-Anwendungen und Smart-Home-Konnektivität.

Unterstützte Protokolle: Die Hauptstärke des ESP32-H2 ist die Unterstützung von IEEE 802.15.4, wodurch es Zigbee und Thread Kommunikation ermöglicht. Damit ist es eine Schlüsselkomponente für die Integration des Displays in moderne Smart-Home-Ökosysteme, insbesondere für Matter über Thread. Zusätzlich unterstützt es Bluetooth 5 (Low Energy).
Anwendungsbereiche: Perfekt für die Steuerung von Smart-Home-Geräten, den Aufbau von Sensornetzwerken oder die Teilnahme an Thread-/Matter-Netzwerken.

ESP32-C6 Modul

Das Modul mit dem ESP32-C6 Chip kombiniert verschiedene Funkstandards auf einem Chip.

Unterstützte Protokolle: Ähnlich wie der H2 unterstützt auch der C6 IEEE 802.15.4 (Zigbee, Thread) und Bluetooth 5 (LE). Der entscheidende Unterschied ist die zusätzliche Integration von Wi-Fi 6 (802.11ax) im 2.4 GHz Band. Das Modul unterstützt zudem den Matter-Standard (über Wi-Fi oder Thread).
Anwendungsbereiche: Dieses Modul ist die vielseitigste Option. Es eignet sich für Smart-Home-Anwendungen (Zigbee, Thread, Matter), kann aber gleichzeitig die Vorteile von Wi-Fi 6 nutzen, wie höhere Effizienz und bessere Leistung in dichten Funkumgebungen.

nRF2401 Modul

Dieses Modul setzt auf den bekannten nRF24L01+ Chip.

Unterstützte Protokolle: Es handelt sich um einen einfachen 2.4 GHz Transceiver, der eine proprietäre Kommunikation ermöglicht (nicht Wi-Fi oder Bluetooth kompatibel). Es nutzt das sogenannte "Enhanced ShockBurst" Protokoll für eine zuverlässige Übertragung.
Anwendungsbereiche: Wegen seiner niedrigen Kosten und der einfachen Handhabung (viele Bibliotheken für Arduino etc. verfügbar) ist es ideal für kostengünstige Punkt-zu-Punkt- oder Stern-Netzwerkverbindungen über kurze bis mittlere Distanzen (typ. bis 100m Sichtlinie, mit PA/LNA-Versionen auch mehr). Gut geeignet für Fernsteuerungen, einfache Sensornetzwerke oder die Kommunikation zwischen mehreren eigenen Geräten.

LoRa Modul

Für Anwendungen, die eine Kommunikation über große Entfernungen bei gleichzeitig geringem Energieverbrauch erfordern, bietet Elecrow ein LoRa-Modul an, das auf den Semtech SX1262 Chip basiert.

Unterstützte Protokolle: Implementiert die LoRa Funktechnik. Ermöglicht Kommunikation über mehrere Kilometer hinweg im lizenzfreien Sub-GHz-Frequenzband (z.B. 868 MHz in Europa, 915 MHz in Nordamerika). Es ist für den Einsatz in LoRaWAN-Netzwerken vorgesehen.
Anwendungsbereiche: Ideal für Low Power Wide Area Network (LPWAN) Szenarien wie Umweltmonitoring, intelligente Landwirtschaft, Tracking von Gütern oder Smart-City-Anwendungen, bei denen Sensordaten selten und über große Distanzen gesendet werden.

Damit sind wohl die meisten Standards abgedeckt, die im Maker- und IoT-Umfeld häufig zum Einsatz kommen. Für darüber hinausgehende, spezifischere Anforderungen bietet der Modulsteckplatz durch die Bereitstellung von SPI, UART, I²C und sowohl 3.3V als auch 5V die Grundlage für Entwicklungen eigener Module, die genau auf die Anforderungen des eigenen Projekts zugeschnitten sind.

CrowPanel Advance: Erste Schritte mit ESP-IDF und LVGL

Elecrow bietet auf ihrem Wiki einige grundlegende Infos zu dem Display. Deutlich mehr Informationen gibt es aber auf ihrer GitHub Seite, wo es neben Datenblättern, Schaltplänen, einer SquareLine Studio Anleitung auch viele Code-Beispiele für das Display gibt, die einerseits das Display, als auch die Module abdecken. Es sind wirklich sehr viele Beispiele und ich empfehle auch die Video-Tutorials auf YouTube anzusehen.

Allerdings sind alle Beispiele, bis auf wenige Ausnahmen, mit dem Arduino Framework umgesetzt. Da ich aber das ESP-IDF Framework bevorzuge, habe ich die Demo-Applikation aus meinem früheren Artikel an dieses Display angepasst. Grundsätzlich ist die Funktionsweise des CrowPanel Advance Displays identisch mit anderen parallelen Displays, allerdings gibt es einige entscheidende Unterschiede, die eine Anpassung des Codes nötig machen.

Ursprünglich konnte in der Demo über einen Slider die Helligkeit des Displays geregelt werden. Da das aber bei diesem Display nicht möglich ist, kann man jetzt stattdessen mit drei Slidern die Echtzeituhr einstellen. Zusätzlich wird in einem eigenen Task die Uhrzeit ausgelesen und am Display angezeigt. Das Layout der Applikation wurde wieder in SquareLine Studio erstellt und ist auf GitHub verfügbar.

Vor dem Export der UI-Daten müssen noch die Pfade für Project Export Root und UI Files Export Root angepasst werden. Die exportierten Files werden dann in den ui-Ordner des Projekts kopiert. Ich habe versucht, mit diesem Beispiel möglichst viele Aspekte einer ESP32 Applikation abzudecken:

Erstellen der Layouts mit SquareLine Studio
Ansteuerung des Displays und Touch-Controllers
Events im Userinterface und entsprechende Updates des Displays
Änderung des Displays aus einem Task heraus
Ansteuerung der RTC Echtzeituhr, des IO-Expanders und des Buzzers

Große Teile des Codes sind weitgehend identisch mit der Version für das Makerfabs bzw. Sunton Display. Ich werde hier daher vor allem auf die Unterschiede eingehen. Zunächst ein Überblick über die Struktur des Projekts.

CMakeLists.txt
platformio.ini                                     Konfiguration des Projekts
sdkconfig.defaults                                 Spezielle ESP-IDF Einstellungen
boards\crowpanel advance_s3.json                   Konfiguration des CrowPanel Boards
components
components\bm8563                                  RTC Treiber
components\buzzer                                  Einfacher Treiber für den Buzzer
components\esp_lcd_touch                           Allgemeiner Touch Treiber Code
components\esp_lcd_touch_gt911                     Angepasster GT911 Treiber
components\pca9557                                 Treiber für den IO-Expander
src
src\CMakeLists.txt
src\main.c                                         Hauptprogramm
src\lv_conf.h                                      LVGL Konfiguration
src\display
src\display\esp32_s3.c                             Display und LVGL Initialisierung
src\display\esp32_s3.h
src\display\elecrow_advanced_7inch_800x480.h       Header File für das CrowPanel Board
src\gui
src\gui\gui.h
src\gui\gui.c                                      Funktionen für Änderungen im GUI
src\task
src\task\time_task.h                               Einfacher Task der die RTC Zeit anzeigt
src\task\time_task.c
src\ui                                             Dieser Ordner enthält den Squareline Studio Export

Wie oben schon beschrieben, verwendet Elecrow den IO-Expander für Steuerung einiger Pins der Peripherie. Daher muss der Code entsprechend angepasst werden, da diese Pins nicht mehr einfach mit gpio_set_direction oder gpio_set_level angesprochen werden können. Die Grundvoraussetzung, um das Display überhaupt betreiben zu können, ist daher ein Treiber für den PCA9557 IO-Expander. Daher habe ich einen einfachen Treiber für ESP-IDF implementiert, der die Funktionen bietet, um die Pins ein- und auszuschalten bzw. zu lesen:

/**
 * @brief Initializes the PCA9557 driver.
 *
 * @param bus The I2C bus handle.
 * @param expander_handle Pointer to store the created device handle.
 * @param config Pointer to the I2C device configuration structure (contains device address etc.).
 * @return ESP_OK on success, otherwise an error code.
 */
esp_err_t pca9557_init(i2c_master_bus_handle_t bus, pca9557_handle_t *expander_handle, const i2c_device_config_t *config);

/**
 * @brief Sets the direction of a single pin.
 *
 * @param dev The device handle.
 * @param pin The pin number (0-7).
 * @param direction The direction (PCA9557_INPUT or PCA9557_OUTPUT).
 * @return ESP_OK on success, otherwise an error code.
 */
esp_err_t pca9557_set_direction(pca9557_handle_t dev, uint8_t pin, uint8_t direction);

/**
 * @brief Reads the state of a single pin.
 *
 * @param dev The device handle.
 * @param pin The pin number (0-7).
 * @param value A pointer to store the read state (0 or 1).
 * @return ESP_OK on success, otherwise an error code.
 */
esp_err_t pca9557_read_pin(pca9557_handle_t dev, uint8_t pin, int *value);

/**
 * @brief Writes a state to a single pin.
 *
 * @param dev The device handle.
 * @param pin The pin number (0-7).
 * @param value The state to write (0 or 1).
 * @return ESP_OK on success, otherwise an error code.
 */
esp_err_t pca9557_write_pin(pca9557_handle_t dev, uint8_t pin, int value);

/**
 * @brief Releases the resources of the PCA9557 driver.
 *
 * @param dev The device handle.
 * @return ESP_OK on success, otherwise an error code.
 */
esp_err_t pca9557_delete(pca9557_handle_t dev); // Note: Functionality likely handled by i2c_master_bus_rm_device

Die nächste Änderung betrifft den Treiber für den GT911 Touch-Controller. Hier muss die Reset Logik angepasst werden, da auch für die Reset-Leitung der IO-Expander verwendet wird. Die angepasste Funktion sieht folgendermaßen aus:

/* Reset controller */
static esp_err_t touch_gt911_reset(pca9557_handle_t expander_handle, esp_lcd_touch_handle_t tp)
{
    assert(expander_handle != NULL);

    ESP_LOGI(TAG, "Resetting GT911 controller");

    vTaskDelay(pdMS_TO_TICKS(99));  // wait <100ms

    gpio_set_direction(tp->config.int_gpio_num, GPIO_MODE_OUTPUT); // Set Int pin to output
    pca9557_set_direction(expander_handle, 2, PCA9557_OUTPUT); // Set Reset pin to output

    gpio_set_level(tp->config.int_gpio_num, 0); // Set INT pin to 0
    pca9557_write_pin(expander_handle, 2, tp->config.levels.reset);  // Set Reset pin to 0

    vTaskDelay(pdMS_TO_TICKS(11));  // wait >10ms

    pca9557_write_pin(expander_handle, 2, !tp->config.levels.reset);  // Set Reset pin to 1

    vTaskDelay(pdMS_TO_TICKS(6)); // wait >5ms

    gpio_set_direction(tp->config.int_gpio_num, GPIO_MODE_INPUT); // Set Int pin to input

    vTaskDelay(pdMS_TO_TICKS(199)); // wait <200ms

    return ESP_OK;
}

Die letzte wichtige Anpassung ist die Konfiguration der Pins und Timings des Displays. Diese Werte kann man direkt aus den Beispielprogrammen von Elecrow entnehmen. Die Werte sind im Header File elecrow_advanced_7inch_800x480.h eingetragen.

// Buzzer Configuration
#define BUZZER_GPIO GPIO_NUM_8 
#define BUZZER_LEDC_TIMER LEDC_TIMER_1
#define BUZZER_LEDC_CHANNEL LEDC_CHANNEL_1

// I2C
#define I2C_SCL          GPIO_NUM_16
#define I2C_SDA          GPIO_NUM_15
#define I2C_RST          GPIO_NUM_NC
#define I2C_CLK_SPEED_HZ 400000
#define I2C_NUM          I2C_NUM_0

// LCD
#define LCD_PIXEL_CLOCK_HZ     (18 * 1000 * 1000)

#define PIN_NUM_HSYNC          GPIO_NUM_40
#define PIN_NUM_VSYNC          GPIO_NUM_41
#define PIN_NUM_DE             GPIO_NUM_42
#define PIN_NUM_PCLK           GPIO_NUM_39
#define PIN_NUM_DATA0          GPIO_NUM_21   // B0
#define PIN_NUM_DATA1          GPIO_NUM_47   // B1
#define PIN_NUM_DATA2          GPIO_NUM_48   // B2
#define PIN_NUM_DATA3          GPIO_NUM_45   // B3
#define PIN_NUM_DATA4          GPIO_NUM_38   // B4
#define PIN_NUM_DATA5          GPIO_NUM_9    // G0
#define PIN_NUM_DATA6          GPIO_NUM_10   // G1
#define PIN_NUM_DATA7          GPIO_NUM_11   // G2
#define PIN_NUM_DATA8          GPIO_NUM_12   // G3
#define PIN_NUM_DATA9          GPIO_NUM_13   // G4
#define PIN_NUM_DATA10         GPIO_NUM_14   // G5
#define PIN_NUM_DATA11         GPIO_NUM_7    // R0
#define PIN_NUM_DATA12         GPIO_NUM_17   // R1
#define PIN_NUM_DATA13         GPIO_NUM_18   // R2
#define PIN_NUM_DATA14         GPIO_NUM_3    // R3
#define PIN_NUM_DATA15         GPIO_NUM_46   // R4
#define PIN_NUM_DISP_EN        GPIO_NUM_NC

#define HSYNC_BACK_PORCH  8
#define HSYNC_FRONT_PORCH 8
#define HSYNC_PULSE_WIDTH 4
#define VSYNC_BACK_PORCH  8
#define VSYNC_FRONT_PORCH 8
#define VSYNC_PULSE_WIDTH 4

#define LCD_H_RES         800
#define LCD_V_RES         480

// LVGL
#define LVGL_TASK_DELAY_MS   10
#define LVGL_TASK_STACK_SIZE (4 * 1024)
#define LVGL_TASK_PRIORITY   0

Mit diesen Anpassungen ist das Display auch mit ESP-IDF Framework verwendbar. Zusätzlich habe ich auch noch einfache Treiber für den Buzzer und die Echtzeit-Uhr implementiert. Leider habe ich mit der Uhr noch ein Problem. Das Lesen über den I²C Bus funktioniert nicht immer. Bisher habe ich noch nicht die Ursache dafür finden können. Das Setzen von disable_ack_check verbessert die Situation zwar, aber fehlerfrei wird die Uhrzeit trotzdem noch nicht gelesen. Vielleicht hat jemand eine Idee, was der Grund dafür sein könnte?

Der Code für die Demo ist auf GitHub verfügbar.

Leider haben die Module ESP32-H2 und ESP32-C6 aus meiner Charge ein Problem: Sie wurden ohne vorinstallierte Firmware ausgeliefert, und das notwendige Flashen über einen externen Serial-Programmer wird durch sehr kurze Header-Pins erschwert. Laut Elecrow erfordert die Inbetriebnahme dieser spezifischen Charge aktuell das temporäre Anlöten von Stiftleisten. Das Problem ist bei neueren Produktionschargen aber behoben. Die Verwendung der Module werde ich daher in einem zweiten Teil beschreiben.

Fazit

Mein Fazit zum Elecrow CrowPanel Advance 7" fällt insgesamt sehr positiv aus. Elecrow liefert hier ein leistungsstarkes Paket mit einem guten 7-Zoll IPS-Touchdisplay, dem ESP32-S3, nützlichen Extras wie einer Echtzeituhr mit Batterie-Backup, Audio Ein-/Ausgabe und vor allem dem flexiblen Konzept der optionalen Funkmodule. Es bietet damit eine hervorragende Grundlage für anspruchsvolle Ausgaben.

Die Hardware-Designer standen vor der Herausforderung, die Fülle an Peripherie trotz der begrenzten GPIO-Pins des ESP32-S3 bei Ansteuerung eines parallelen Displays unterzubringen. Die gewählten Lösungen mittels I/O-Expander und Analogschaltern sind clever, führen aber zu nachvollziehbaren Kompromissen: Die Einschränkung, dass SD-Karte, Audio-Peripherie und Funkmodule nicht gleichzeitig aktiv sein können, sondern per DIP-Schalter gewählt werden müssen, ist angesichts der Umstände aber verständlich.

Der entscheidende Schwachpunkt ist jedoch die fehlende PWM-Steuerung der Hintergrundbeleuchtung. Diese Einschränkung macht es für den Einsatz in meiner Wetterstation leider ungeeignet. Die Lösung dafür wäre im Grunde ganz einfach. Ein aktiver statt passiver Buzzer, der über eine Leitung des IO-Expanders gesteuert wird und das frei gewordene GPIO-Pin wird für das PWM Signal verwendet.

Abgesehen von diesem spezifischen Manko, das nur für bestimmte Anwendungsfälle relevant ist, ist das CrowPanel Advance 7" aber eine äußerst interessante und vielseitige Plattform mit einem einzigartigen modularen Ansatz. Wer ein großes ESP32-Display mit maximaler Flexibilität bei den Funkstandards sucht und auf eine variable Helligkeit verzichten kann, findet hier eine starke Option für viele spannende Projekte.

Konversation wird geladen