From ff23e0e61405a45a9567a637b7495ffe87097de0 Mon Sep 17 00:00:00 2001 From: raw-designs Date: Thu, 3 Sep 2026 01:42:05 +0200 Subject: [PATCH] =?UTF-8?q?diag(P4):=20Gezeichnete=20Fl=C3=A4che=20messen,?= =?UTF-8?q?=20direktes=20Zeichnen=20zur=C3=BCcknehmen=20(1.9.1)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit WS7_DIRECT_FB hat die Bildaufbauzeit nicht verkürzt (weiterhin 240-300 ms) und Bildfehler erzeugt - in denselben Speicher zu zeichnen, aus dem gerade angezeigt wird, geht ohne zweiten Framebuffer nicht sauber. Zurück auf 0, Schalter mit Begründung erhalten. Damit ist belegt: Der Flaschenhals liegt nicht im Kopieren, sondern im Rendern selbst. Offen ist, ob LVGL kleine Bereiche langsam zeichnet oder jedes Mal die volle Fläche - zwei verschiedene Ursachen. refr_start_cb summiert deshalb jetzt die nicht zusammengefassten inv_areas und meldet Anzahl und Flächenanteil zusammen mit der Dauer. Beide Panel-Varianten mit arduino-cli gegengebaut. Co-Authored-By: Claude Opus 5 --- P4_Display_Firmware/Changelog.txt | 12 ++++++++++++ P4_Display_Firmware/pins_config.h | 10 ++++++---- P4_Display_Firmware/ui.cpp | 27 +++++++++++++++++++++++++-- 3 files changed, 43 insertions(+), 6 deletions(-) diff --git a/P4_Display_Firmware/Changelog.txt b/P4_Display_Firmware/Changelog.txt index 6cb373d..5173390 100644 --- a/P4_Display_Firmware/Changelog.txt +++ b/P4_Display_Firmware/Changelog.txt @@ -1,3 +1,15 @@ +Version 1.9.1: +- Das direkte Zeichnen in den Bildspeicher aus 1.9.0 ist zurückgenommen: Es hat die + Bildaufbauzeit nicht verkürzt (weiterhin 240 bis 300 ms) und stattdessen Bildfehler + erzeugt, weil in denselben Speicher gezeichnet wird, aus dem gerade angezeigt wird. + Damit ist auch klar, dass der Flaschenhals nicht im Kopieren liegt, sondern im Zeichnen + selbst. Der Schalter WS7_DIRECT_FB bleibt samt Begründung erhalten. +- Die Messung sagt jetzt zusätzlich, WIE VIEL neu gezeichnet wurde: Anzahl der Bereiche und + ihr Anteil an der Gesamtfläche. Erst damit lässt sich unterscheiden, ob LVGL nur kleine + Bereiche anfasst - dann ist das Zeichnen an sich zu langsam - oder ob jedes Mal der ganze + Bildschirm neu entsteht, weil ihn etwas unnötig ungültig macht. Das sind zwei völlig + verschiedene Ursachen mit verschiedenen Gegenmitteln. + Version 1.9.0: - Die Messung aus 1.8.8 hat die Ursache der Trägheit gefunden: Jeder Bildaufbau kostete 240 bis 300 Millisekunden - dauerhaft, auch im Leerlauf. Fünf Sekunden für den diff --git a/P4_Display_Firmware/pins_config.h b/P4_Display_Firmware/pins_config.h index 4fb43fa..bea1948 100644 --- a/P4_Display_Firmware/pins_config.h +++ b/P4_Display_Firmware/pins_config.h @@ -39,10 +39,12 @@ // nicht - siehe die ausfuehrliche Begruendung weiter unten beim Avoid-Tear-Schalter. // Auf 0 nur, wenn das Startverhalten erneut untersucht wird. #define WS7_SINGLE_FB 1 -// LVGL zeichnet direkt in den Bildspeicher, statt in einen eigenen Puffer zu zeichnen und -// den danach zu kopieren. Spart pro Bild einen kompletten Durchgang durch 2,7 MB PSRAM -// und laesst LVGL nur die geaenderten Bereiche neu zeichnen. Braucht WS7_SINGLE_FB. -#define WS7_DIRECT_FB 1 +// LVGL zeichnet direkt in den Bildspeicher statt in einen eigenen Puffer, dessen Inhalt +// danach kopiert wird. GEPRUEFT: bringt an diesem Panel nichts (die Bildaufbauzeit blieb bei +// 240-300 ms) und erzeugt Bildfehler, weil in denselben Speicher gezeichnet wird, aus dem +// gerade angezeigt wird. Der Flaschenhals liegt also nicht im Kopieren, sondern im Zeichnen +// selbst. Bleibt als Schalter erhalten, damit der Versuch nicht erneut gemacht wird. +#define WS7_DIRECT_FB 0 #define WS7_PARALLEL_RENDER 1 #define EXAMPLE_LVGL_PORT_TASK_MAX_DELAY_MS 500 //range 2 to 2000 diff --git a/P4_Display_Firmware/ui.cpp b/P4_Display_Firmware/ui.cpp index 72441c9..784f1ce 100644 --- a/P4_Display_Firmware/ui.cpp +++ b/P4_Display_Firmware/ui.cpp @@ -24,6 +24,7 @@ #include "esp_system.h" #include "display_hal.h" #include "esp_rom_sys.h" +#include "lvgl_private.h" // ------------------------------------------------------------------------------------ // Schriftgroesse @@ -3464,11 +3465,33 @@ static bool g_uiReady = false; static uint32_t g_refrStart = 0; -static void refr_start_cb(lv_event_t*) { g_refrStart = lv_tick_get(); } +static uint32_t g_refrPixels = 0; +static uint32_t g_refrAreas = 0; + +// Beim Start eines Zeichenzyklus festhalten, WIE VIEL neu gezeichnet wird. Erst damit laesst +// sich unterscheiden, ob LVGL nur kleine Bereiche anfasst - dann ist das Zeichnen an sich zu +// langsam - oder ob jedes Mal der ganze Bildschirm neu entsteht, weil ihn etwas unnoetig +// ungueltig macht. +static void refr_start_cb(lv_event_t*) { + g_refrStart = lv_tick_get(); + g_refrPixels = 0; + g_refrAreas = 0; + lv_display_t* d = lv_display_get_default(); + if (!d) return; + for (uint16_t i = 0; i < d->inv_p; i++) { + if (d->inv_area_joined[i]) continue; + const lv_area_t* a = &d->inv_areas[i]; + g_refrPixels += (uint32_t)(a->x2 - a->x1 + 1) * (uint32_t)(a->y2 - a->y1 + 1); + g_refrAreas++; + } +} static void refr_ready_cb(lv_event_t*) { uint32_t d = lv_tick_get() - g_refrStart; - if (d >= REFR_WARN_MS) esp_rom_printf("[UI] Bildaufbau %u ms\n", (unsigned)d); + if (d < REFR_WARN_MS) return; + unsigned pct = (unsigned)((uint64_t)g_refrPixels * 100ULL / ((uint64_t)LCD_H_RES * LCD_V_RES)); + esp_rom_printf("[UI] Bildaufbau %u ms, %u Bereiche, %u %% der Flaeche\n", + (unsigned)d, (unsigned)g_refrAreas, pct); } static void refr_monitor_install() { -- 2.54.0