@geastack/targets 0.1.109 → 0.1.111
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/build-config.json +10 -0
- package/package.json +4 -4
- package/targets/esp32/chip_bindings/audio/ns4168.cpp +2 -2
- package/targets/esp32/chip_bindings/displays/rgb_panel.cpp +323 -4
- package/targets/esp32/chip_bindings/expanders/elecrow_stc8h1k17.cpp +155 -0
- package/targets/esp32/chip_bindings/expanders/elecrow_stc8h1k17.h +20 -0
- package/targets/esp32/chip_bindings/power/elecrow_stc8h1k17.cpp +35 -0
- package/targets/esp32/services/app_state.cpp +20 -2
- package/targets/esp32/services/device_control.cpp +59 -23
- package/targets/esp32-p4/CMakeLists.txt +18 -0
- package/targets/esp32-p4/main/CMakeLists.txt +564 -0
- package/targets/esp32-p4/main/Kconfig.projbuild +14 -0
- package/targets/esp32-p4/main/app_main.cpp +177 -0
- package/targets/esp32-p4/main/camera.cpp +1958 -0
- package/targets/esp32-p4/main/fatfs_ffconf.h +383 -0
- package/targets/esp32-p4/main/i2c.cpp +39 -0
- package/targets/esp32-p4/main/idf_component.yml +26 -0
- package/targets/esp32-p4/main/launcher_button.cpp +192 -0
- package/targets/esp32-p4/main/sdcard_mount.cpp +132 -0
- package/targets/esp32-p4/partitions.csv +8 -0
- package/targets/esp32-p4/sdkconfig.defaults +110 -0
- package/targets/esp32-p4-elecrow-crowpanel-advanced-5.0.json +161 -0
- package/targets.json +19 -0
package/build-config.json
CHANGED
|
@@ -9,6 +9,7 @@
|
|
|
9
9
|
"compiler.staticCssTapeMinChunk",
|
|
10
10
|
"compiler.translationUnits",
|
|
11
11
|
"compiler.storeRelowering",
|
|
12
|
+
"compiler.heapMiB",
|
|
12
13
|
"compiler.moduleGraph",
|
|
13
14
|
"compiler.allowAny",
|
|
14
15
|
"compiler.numberPrecision",
|
|
@@ -44,6 +45,7 @@
|
|
|
44
45
|
"compiler.staticCssTapeMinChunk",
|
|
45
46
|
"compiler.translationUnits",
|
|
46
47
|
"compiler.storeRelowering",
|
|
48
|
+
"compiler.heapMiB",
|
|
47
49
|
"compiler.moduleGraph",
|
|
48
50
|
"compiler.allowAny",
|
|
49
51
|
"renderer.bandedUi"
|
|
@@ -73,6 +75,7 @@
|
|
|
73
75
|
"compiler.staticCssTapeMinChunk",
|
|
74
76
|
"compiler.translationUnits",
|
|
75
77
|
"compiler.storeRelowering",
|
|
78
|
+
"compiler.heapMiB",
|
|
76
79
|
"compiler.moduleGraph",
|
|
77
80
|
"compiler.allowAny"
|
|
78
81
|
],
|
|
@@ -95,6 +98,7 @@
|
|
|
95
98
|
"compiler.staticCssTapeMinChunk",
|
|
96
99
|
"compiler.translationUnits",
|
|
97
100
|
"compiler.storeRelowering",
|
|
101
|
+
"compiler.heapMiB",
|
|
98
102
|
"compiler.moduleGraph",
|
|
99
103
|
"compiler.allowAny",
|
|
100
104
|
"display.width",
|
|
@@ -119,6 +123,7 @@
|
|
|
119
123
|
"compiler.staticCssTapeMinChunk",
|
|
120
124
|
"compiler.translationUnits",
|
|
121
125
|
"compiler.storeRelowering",
|
|
126
|
+
"compiler.heapMiB",
|
|
122
127
|
"compiler.moduleGraph",
|
|
123
128
|
"compiler.allowAny",
|
|
124
129
|
"native.jobs",
|
|
@@ -165,6 +170,7 @@
|
|
|
165
170
|
"compiler.staticCssTapeMinChunk",
|
|
166
171
|
"compiler.translationUnits",
|
|
167
172
|
"compiler.storeRelowering",
|
|
173
|
+
"compiler.heapMiB",
|
|
168
174
|
"compiler.moduleGraph",
|
|
169
175
|
"compiler.allowAny"
|
|
170
176
|
],
|
|
@@ -187,6 +193,7 @@
|
|
|
187
193
|
"compiler.staticCssTapeMinChunk",
|
|
188
194
|
"compiler.translationUnits",
|
|
189
195
|
"compiler.storeRelowering",
|
|
196
|
+
"compiler.heapMiB",
|
|
190
197
|
"compiler.moduleGraph",
|
|
191
198
|
"compiler.allowAny"
|
|
192
199
|
],
|
|
@@ -209,6 +216,7 @@
|
|
|
209
216
|
"compiler.staticCssTapeMinChunk",
|
|
210
217
|
"compiler.translationUnits",
|
|
211
218
|
"compiler.storeRelowering",
|
|
219
|
+
"compiler.heapMiB",
|
|
212
220
|
"compiler.moduleGraph",
|
|
213
221
|
"compiler.allowAny"
|
|
214
222
|
],
|
|
@@ -231,6 +239,7 @@
|
|
|
231
239
|
"compiler.staticCssTapeMinChunk",
|
|
232
240
|
"compiler.translationUnits",
|
|
233
241
|
"compiler.storeRelowering",
|
|
242
|
+
"compiler.heapMiB",
|
|
234
243
|
"compiler.moduleGraph",
|
|
235
244
|
"compiler.allowAny",
|
|
236
245
|
"ui.styleStorage"
|
|
@@ -261,6 +270,7 @@
|
|
|
261
270
|
"compiler.staticCssTapeMinChunk",
|
|
262
271
|
"compiler.translationUnits",
|
|
263
272
|
"compiler.storeRelowering",
|
|
273
|
+
"compiler.heapMiB",
|
|
264
274
|
"compiler.moduleGraph",
|
|
265
275
|
"compiler.allowAny",
|
|
266
276
|
"display.width",
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@geastack/targets",
|
|
3
|
-
"version": "0.1.
|
|
3
|
+
"version": "0.1.111",
|
|
4
4
|
"description": "Native embedded build targets (ESP32-IDF, RP2350) for geastack apps: board sources, target catalog, and CMake glue driven by the gea CLI.",
|
|
5
5
|
"license": "GPL-3.0-only",
|
|
6
6
|
"repository": {
|
|
@@ -36,11 +36,11 @@
|
|
|
36
36
|
"access": "public"
|
|
37
37
|
},
|
|
38
38
|
"dependencies": {
|
|
39
|
-
"@geastack/chips": "^0.1.
|
|
39
|
+
"@geastack/chips": "^0.1.8",
|
|
40
40
|
"@geastack/compiler": "^1.0.41",
|
|
41
|
-
"@geastack/core": "0.1.
|
|
41
|
+
"@geastack/core": "0.1.53",
|
|
42
42
|
"@geastack/elements": "^0.1.6",
|
|
43
|
-
"@geastack/engine": "^0.1.
|
|
43
|
+
"@geastack/engine": "^0.1.24",
|
|
44
44
|
"@geastack/geaos": "^0.1.3",
|
|
45
45
|
"@geastack/geatsc-plugin-gea": "0.1.28",
|
|
46
46
|
"@geastack/host": "0.1.23"
|
|
@@ -53,8 +53,8 @@ namespace {
|
|
|
53
53
|
constexpr char kTag[] = "ns4168";
|
|
54
54
|
constexpr auto &kAudio = gea::platform::board::audio;
|
|
55
55
|
constexpr bool kHasMicrophone = kAudio.micBclk != GPIO_NUM_NC && kAudio.micDin != GPIO_NUM_NC;
|
|
56
|
-
constexpr
|
|
57
|
-
constexpr
|
|
56
|
+
constexpr int kSpeakerPort = I2S_NUM_1; // i2s_chan_config_t::id is a plain int (IDF 6 dropped i2s_port_t)
|
|
57
|
+
constexpr int kMicPort = I2S_NUM_0;
|
|
58
58
|
// The INMP441's 24 significant bits sit at the top of the 32-bit slot; keeping
|
|
59
59
|
// bits 29..14 gives ~12 dB of headroom over the raw top 16 bits, which is where
|
|
60
60
|
// speech from arm's length lands for this part.
|
|
@@ -87,6 +87,17 @@
|
|
|
87
87
|
#include "soc/gdma_struct.h"
|
|
88
88
|
#include "esp_async_memcpy.h"
|
|
89
89
|
#endif
|
|
90
|
+
#if CONFIG_IDF_TARGET_ESP32P4 && GEA_EMBEDDED_RGB_SYNC_MONITOR
|
|
91
|
+
#include "soc/axi_dma_struct.h"
|
|
92
|
+
#endif
|
|
93
|
+
#if CONFIG_IDF_TARGET_ESP32P4 && !GEA_EMBEDDED_DISPLAY_RGB_BOUNCE
|
|
94
|
+
// Full-width scroll copies between the scanned buffers go through the AXI-GDMA
|
|
95
|
+
// (see dmaScrollCopy).
|
|
96
|
+
#define GEA_RGB_DMA_SCROLL 1
|
|
97
|
+
#include "esp_async_memcpy.h"
|
|
98
|
+
#else
|
|
99
|
+
#define GEA_RGB_DMA_SCROLL 0
|
|
100
|
+
#endif
|
|
90
101
|
|
|
91
102
|
#include <algorithm>
|
|
92
103
|
#include <atomic>
|
|
@@ -499,6 +510,9 @@ void applyCanvasMap()
|
|
|
499
510
|
// flight the panel has read (see backRowReleased).
|
|
500
511
|
volatile std::int64_t g_vsyncUs = 0;
|
|
501
512
|
volatile std::int64_t g_frameCompleteUs = 0;
|
|
513
|
+
// The driver fills its own bounce buffers (a board names bounceRows on a
|
|
514
|
+
// direct-scanout target): it restarts a short frame itself.
|
|
515
|
+
bool g_driverBounce = false;
|
|
502
516
|
|
|
503
517
|
// VSYNC interrupt lateness: the interval between VSYNC interrupts against
|
|
504
518
|
// the frame period (a late one is a late DMA restart).
|
|
@@ -529,6 +543,21 @@ DRAM_ATTR std::uint32_t g_vsyncPhaseQ4 = 0;
|
|
|
529
543
|
// A VSYNC interrupt this late (past the hardware event, in 1/16 us) may
|
|
530
544
|
// already be inside the next frame's first lines: no restart then.
|
|
531
545
|
constexpr std::uint32_t kVsyncOnTimeQ4 = 40 * 16;
|
|
546
|
+
DRAM_ATTR std::uint32_t g_slipLogMs[16] = {}, g_slipLogN = 0;
|
|
547
|
+
DRAM_ATTR int g_slipSinceSwap[16] = {};
|
|
548
|
+
volatile std::int64_t g_lastSwapUs = 0;
|
|
549
|
+
volatile std::uint32_t g_swapCount = 0;
|
|
550
|
+
DRAM_ATTR std::int32_t g_slipLogUs[16] = {};
|
|
551
|
+
DRAM_ATTR std::int32_t g_eofGapMin = 1 << 30, g_eofGapMax = -(1 << 30), g_eofGapLast = 0;
|
|
552
|
+
// Where the panel DMA is fetching at VSYNC, in bytes from the start of the
|
|
553
|
+
// frame (negative = still in the previous frame): a lag that grows is a drift.
|
|
554
|
+
DRAM_ATTR std::int32_t g_dmaPosMin = 1 << 30, g_dmaPosMax = -(1 << 30), g_dmaPosLast = 0;
|
|
555
|
+
DRAM_ATTR std::uint32_t g_dmaPosUnknown = 0;
|
|
556
|
+
// Tasks running on each core at the VSYNC before, and the one that found, a lag.
|
|
557
|
+
DRAM_ATTR const char *g_lagTask[4] = {};
|
|
558
|
+
DRAM_ATTR const char *g_prevTask[2] = {};
|
|
559
|
+
DRAM_ATTR std::uint32_t g_lagMs = 0;
|
|
560
|
+
DRAM_ATTR std::uint32_t g_vsyncLate40 = 0, g_vsyncLate200us = 0, g_vsyncLate700 = 0, g_vsyncLateMaxQ4 = 0;
|
|
532
561
|
int panelDmaBin();
|
|
533
562
|
IRAM_ATTR bool onPanelVsync(esp_lcd_panel_handle_t panel, const esp_lcd_rgb_panel_event_data_t *, void *)
|
|
534
563
|
{
|
|
@@ -570,6 +599,53 @@ IRAM_ATTR bool onPanelVsync(esp_lcd_panel_handle_t panel, const esp_lcd_rgb_pane
|
|
|
570
599
|
if (lateQ4 <= kVsyncOnTimeQ4) g_vsyncPhaseQ4 = expected + lateQ4 / 4; // follow drift slowly
|
|
571
600
|
}
|
|
572
601
|
}
|
|
602
|
+
#if GEA_EMBEDDED_RGB_SYNC_MONITOR
|
|
603
|
+
// Scan diagnostics: how long before this VSYNC the DMA finished the
|
|
604
|
+
// frame (in step it is a fixed ~0.7 ms on the CrowPanel 5.0; a late or
|
|
605
|
+
// missing frame end is a starved DMA), and interrupt lateness.
|
|
606
|
+
{
|
|
607
|
+
const std::int32_t gap = static_cast<std::int32_t>(now - g_frameCompleteUs);
|
|
608
|
+
if (gap < g_eofGapMin) g_eofGapMin = gap;
|
|
609
|
+
if (gap > g_eofGapMax) g_eofGapMax = gap;
|
|
610
|
+
if (g_eofGapLast != 0 && (gap < 600 || gap > 900) && g_slipLogN < 16) {
|
|
611
|
+
g_slipLogMs[g_slipLogN] = static_cast<std::uint32_t>(now / 1000);
|
|
612
|
+
g_slipLogUs[g_slipLogN] = gap;
|
|
613
|
+
g_slipSinceSwap[g_slipLogN] = static_cast<int>((now - g_lastSwapUs) / 1000);
|
|
614
|
+
g_slipLogN++;
|
|
615
|
+
}
|
|
616
|
+
g_eofGapLast = gap;
|
|
617
|
+
#if CONFIG_IDF_TARGET_ESP32P4
|
|
618
|
+
{
|
|
619
|
+
std::int32_t pos = 0;
|
|
620
|
+
bool found = false;
|
|
621
|
+
for (int ch = 0; ch < 3 && !found; ++ch) {
|
|
622
|
+
const std::uint32_t desc = AXI_DMA.out[ch].conf.out_dscr.val;
|
|
623
|
+
if (desc < 0x4FF00000u || desc >= 0x4FFC0000u) continue;
|
|
624
|
+
const std::uintptr_t b = reinterpret_cast<const volatile std::uint32_t *>(desc)[1];
|
|
625
|
+
for (int i = 0; i < g_scanFbCount && !found; ++i) {
|
|
626
|
+
const auto lo = reinterpret_cast<std::uintptr_t>(g_scanFb[i]);
|
|
627
|
+
if (lo && b >= lo && b < lo + kFramebufferBytes) {
|
|
628
|
+
pos = static_cast<std::int32_t>(b - lo);
|
|
629
|
+
if (pos > static_cast<std::int32_t>(kFramebufferBytes / 2)) pos -= static_cast<std::int32_t>(kFramebufferBytes);
|
|
630
|
+
found = true;
|
|
631
|
+
}
|
|
632
|
+
}
|
|
633
|
+
}
|
|
634
|
+
if (found) {
|
|
635
|
+
if (pos < g_dmaPosMin) g_dmaPosMin = pos;
|
|
636
|
+
if (pos > g_dmaPosMax) g_dmaPosMax = pos;
|
|
637
|
+
g_dmaPosLast = pos;
|
|
638
|
+
} else {
|
|
639
|
+
g_dmaPosUnknown++;
|
|
640
|
+
}
|
|
641
|
+
}
|
|
642
|
+
#endif
|
|
643
|
+
}
|
|
644
|
+
if (lateQ4 > 40 * 16) g_vsyncLate40++;
|
|
645
|
+
if (lateQ4 > 200 * 16) g_vsyncLate200us++;
|
|
646
|
+
if (lateQ4 > 700 * 16) g_vsyncLate700++;
|
|
647
|
+
if (lateQ4 > g_vsyncLateMaxQ4) g_vsyncLateMaxQ4 = lateQ4;
|
|
648
|
+
#endif
|
|
573
649
|
const int bin = panelDmaBin();
|
|
574
650
|
if (bin >= 0 && bin < 32) g_vsyncAt[bin]++;
|
|
575
651
|
// An interrupt in time that finds the DMA anywhere but buffer 0 /
|
|
@@ -593,6 +669,7 @@ IRAM_ATTR bool onPanelVsync(esp_lcd_panel_handle_t panel, const esp_lcd_rgb_pane
|
|
|
593
669
|
g_prevLateUs = lateUs;
|
|
594
670
|
g_prevEofFills = static_cast<std::uint8_t>(std::min<std::uint32_t>(fills, 255));
|
|
595
671
|
}
|
|
672
|
+
#if GEA_EMBEDDED_DISPLAY_RGB_BOUNCE
|
|
596
673
|
if (lateQ4 <= kVsyncOnTimeQ4) {
|
|
597
674
|
if (bin != 1) g_vsyncRealigned++;
|
|
598
675
|
if (esp_lcd_rgb_panel_restart(panel) == ESP_OK) {
|
|
@@ -601,6 +678,32 @@ IRAM_ATTR bool onPanelVsync(esp_lcd_panel_handle_t panel, const esp_lcd_rgb_pane
|
|
|
601
678
|
} else {
|
|
602
679
|
g_vsyncSkipped++;
|
|
603
680
|
}
|
|
681
|
+
#else
|
|
682
|
+
// Direct scanout: in step, the DMA finishes each frame during the
|
|
683
|
+
// front porch, ~0.7 ms before this VSYNC. A FIFO underrun leaves it a
|
|
684
|
+
// few bytes behind for good -- it then finishes ~0.9 ms AFTER VSYNC,
|
|
685
|
+
// every frame, and the picture sits shifted right; each later underrun
|
|
686
|
+
// adds to it (a slow slide). So when no frame end came in the last
|
|
687
|
+
// 3 ms, restart it now: the driver does so right after this callback,
|
|
688
|
+
// at this same VSYNC, into the buffer currently shown. In step it is
|
|
689
|
+
// never touched.
|
|
690
|
+
const bool lagging = !g_driverBounce && g_frameCompleteUs != 0 && now - g_frameCompleteUs > 3000;
|
|
691
|
+
#if GEA_EMBEDDED_RGB_SYNC_MONITOR
|
|
692
|
+
{
|
|
693
|
+
const char *t0 = pcTaskGetName(xTaskGetCurrentTaskHandleForCore(0));
|
|
694
|
+
const char *t1 = pcTaskGetName(xTaskGetCurrentTaskHandleForCore(1));
|
|
695
|
+
if (lagging && g_lagMs == 0) {
|
|
696
|
+
g_lagTask[0] = g_prevTask[0]; g_lagTask[1] = g_prevTask[1];
|
|
697
|
+
g_lagTask[2] = t0; g_lagTask[3] = t1;
|
|
698
|
+
g_lagMs = static_cast<std::uint32_t>(now / 1000);
|
|
699
|
+
}
|
|
700
|
+
g_prevTask[0] = t0; g_prevTask[1] = t1;
|
|
701
|
+
}
|
|
702
|
+
#endif
|
|
703
|
+
if (lagging && esp_lcd_rgb_panel_restart(panel) == ESP_OK) {
|
|
704
|
+
g_vsyncRestarts++;
|
|
705
|
+
}
|
|
706
|
+
#endif
|
|
604
707
|
}
|
|
605
708
|
if (g_vsyncUs != 0) {
|
|
606
709
|
const auto &d = gea::platform::board::display;
|
|
@@ -911,10 +1014,26 @@ void commitSwap(int back)
|
|
|
911
1014
|
taskEXIT_CRITICAL(&g_swapMux);
|
|
912
1015
|
#else
|
|
913
1016
|
// Direct scanout: draw_bitmap writes the whole frame back from the cache
|
|
914
|
-
// (too long for a critical section),
|
|
915
|
-
//
|
|
1017
|
+
// (too long for a critical section), then relinks the tail of every frame's
|
|
1018
|
+
// descriptor chain to the new buffer. The GDMA reads a descriptor's link a
|
|
1019
|
+
// few descriptors (a few lines) ahead, so a relink well before the current
|
|
1020
|
+
// frame's last line takes effect at the next frame end, which then releases
|
|
1021
|
+
// the old front. A relink close to it may miss, and the old buffer is sent
|
|
1022
|
+
// once more: allow two frame ends then. Always waiting two held the next
|
|
1023
|
+
// back buffer up to a whole frame longer than needed, and a tab swipe on
|
|
1024
|
+
// the CrowPanel 5.0 dropped every third frame on that wait.
|
|
1025
|
+
const std::uint32_t seqBefore = g_frameSeq;
|
|
916
1026
|
esp_lcd_panel_draw_bitmap(g_panel, 0, 0, kWidth, kHeight, g_scanFb[back]);
|
|
917
|
-
|
|
1027
|
+
const std::int64_t relinkedUs = esp_timer_get_time();
|
|
1028
|
+
const std::int64_t lastFrameEndUs = g_frameCompleteUs;
|
|
1029
|
+
g_lastSwapUs = relinkedUs;
|
|
1030
|
+
g_swapCount = g_swapCount + 1;
|
|
1031
|
+
const auto &d = gea::platform::board::display;
|
|
1032
|
+
constexpr std::int64_t kRelinkMarginUs = 1500;
|
|
1033
|
+
const std::int64_t frameUs = static_cast<std::int64_t>(kWidth + d.hsyncPulseWidth + d.hsyncBackPorch + d.hsyncFrontPorch) *
|
|
1034
|
+
(kHeight + d.vsyncPulseWidth + d.vsyncBackPorch + d.vsyncFrontPorch) * 1000000 / kPixelClockHz;
|
|
1035
|
+
const bool relinkedEarly = g_frameSeq == seqBefore && lastFrameEndUs != 0 && relinkedUs < lastFrameEndUs + frameUs - kRelinkMarginUs;
|
|
1036
|
+
seq = g_frameSeq + (relinkedEarly ? 1 : 2);
|
|
918
1037
|
#endif
|
|
919
1038
|
g_freeSeq[g_frontIndex] = seq;
|
|
920
1039
|
std::uint16_t *oldBack = g_scanFb[back];
|
|
@@ -933,9 +1052,27 @@ void commitSwap(int back)
|
|
|
933
1052
|
// One line per kSwapDiagFrames published frames, the same in both modes:
|
|
934
1053
|
// publish = whole Display flush call, raster = fused raster inside it, copy =
|
|
935
1054
|
// pixel copies into scanout memory, wait = blocked on the panel releasing the back buffer.
|
|
1055
|
+
#if GEA_RGB_FRAME_TRACE
|
|
1056
|
+
struct FrameTrace { std::uint32_t ms; std::int32_t dtUs, copyUs, waitUs, pubUs, px, patchPx, rasterUs; std::uint8_t path; };
|
|
1057
|
+
FrameTrace g_trace[128];
|
|
1058
|
+
volatile std::uint32_t g_traceHead = 0;
|
|
1059
|
+
std::int64_t g_tracePrevUs = 0, g_tracePrevCopy = 0, g_tracePrevWait = 0, g_tracePrevPatch = 0, g_tracePrevRaster = 0;
|
|
1060
|
+
#endif
|
|
936
1061
|
void noteFrameDiag(int path, std::int64_t totalUs, int px)
|
|
937
1062
|
{
|
|
938
1063
|
if (px <= 0) return;
|
|
1064
|
+
#if GEA_RGB_FRAME_TRACE
|
|
1065
|
+
{
|
|
1066
|
+
const std::int64_t now = esp_timer_get_time();
|
|
1067
|
+
FrameTrace &t = g_trace[g_traceHead % 128];
|
|
1068
|
+
t = {static_cast<std::uint32_t>(now / 1000), static_cast<std::int32_t>(g_tracePrevUs ? now - g_tracePrevUs : 0),
|
|
1069
|
+
static_cast<std::int32_t>(g_swapDiag.copyUs - g_tracePrevCopy), static_cast<std::int32_t>(g_swapDiag.waitUs - g_tracePrevWait),
|
|
1070
|
+
static_cast<std::int32_t>(totalUs), px, static_cast<std::int32_t>(g_swapDiag.patchPx - g_tracePrevPatch), static_cast<std::int32_t>(g_swapDiag.rasterUs - g_tracePrevRaster), static_cast<std::uint8_t>(path)};
|
|
1071
|
+
g_traceHead = g_traceHead + 1;
|
|
1072
|
+
g_tracePrevUs = now;
|
|
1073
|
+
g_tracePrevCopy = g_swapDiag.copyUs; g_tracePrevWait = g_swapDiag.waitUs; g_tracePrevPatch = g_swapDiag.patchPx; g_tracePrevRaster = g_swapDiag.rasterUs;
|
|
1074
|
+
}
|
|
1075
|
+
#endif
|
|
939
1076
|
g_swapDiag.paths[path]++;
|
|
940
1077
|
g_swapDiag.totalUs += totalUs;
|
|
941
1078
|
g_swapDiag.px += px;
|
|
@@ -966,6 +1103,9 @@ void noteFrameDiag(int path, std::int64_t totalUs, int px)
|
|
|
966
1103
|
n * 1000000.0 / static_cast<double>(now - g_swapDiag.windowStartUs));
|
|
967
1104
|
g_swapDiag = {};
|
|
968
1105
|
g_swapDiag.windowStartUs = now;
|
|
1106
|
+
#if GEA_RGB_FRAME_TRACE
|
|
1107
|
+
g_tracePrevCopy = g_tracePrevWait = g_tracePrevPatch = g_tracePrevRaster = 0;
|
|
1108
|
+
#endif
|
|
969
1109
|
g_diagVsync0 = vs;
|
|
970
1110
|
g_diagFrame0 = fr;
|
|
971
1111
|
}
|
|
@@ -1017,6 +1157,56 @@ void scanoutRowCopy(void *dst, const void *src, std::size_t bytes)
|
|
|
1017
1157
|
}
|
|
1018
1158
|
|
|
1019
1159
|
// Copy rect r of the front buffer into the back buffer.
|
|
1160
|
+
#if GEA_RGB_DMA_SCROLL
|
|
1161
|
+
async_memcpy_handle_t g_scrollDma = nullptr;
|
|
1162
|
+
bool g_scrollDmaFailed = false;
|
|
1163
|
+
|
|
1164
|
+
bool scrollDmaReady()
|
|
1165
|
+
{
|
|
1166
|
+
if (g_scrollDma) return true;
|
|
1167
|
+
if (g_scrollDmaFailed) return false;
|
|
1168
|
+
async_memcpy_config_t cfg = ASYNC_MEMCPY_DEFAULT_CONFIG();
|
|
1169
|
+
cfg.dma_burst_size = 128;
|
|
1170
|
+
if (esp_async_memcpy_install_gdma_axi(&cfg, &g_scrollDma) != ESP_OK) {
|
|
1171
|
+
g_scrollDmaFailed = true;
|
|
1172
|
+
g_scrollDma = nullptr;
|
|
1173
|
+
ESP_LOGW(kTag, "AXI-GDMA memcpy unavailable; scroll copies stay on the CPU");
|
|
1174
|
+
return false;
|
|
1175
|
+
}
|
|
1176
|
+
return true;
|
|
1177
|
+
}
|
|
1178
|
+
|
|
1179
|
+
bool IRAM_ATTR onScrollDmaDone(async_memcpy_handle_t, async_memcpy_event_t *, void *arg)
|
|
1180
|
+
{
|
|
1181
|
+
BaseType_t woken = pdFALSE;
|
|
1182
|
+
xSemaphoreGiveFromISR(static_cast<SemaphoreHandle_t>(arg), &woken);
|
|
1183
|
+
return woken == pdTRUE;
|
|
1184
|
+
}
|
|
1185
|
+
|
|
1186
|
+
// A scroll's shifted copy from the front buffer to the back, as one AXI-GDMA
|
|
1187
|
+
// transfer of contiguous memory. The CPU copy costs three PSRAM passes a pixel
|
|
1188
|
+
// (the write-allocate fill, the write-back and the read): ~12 ms for a tab
|
|
1189
|
+
// swipe's 800x410 viewport on the CrowPanel 5.0, most of a 61 Hz frame. The DMA
|
|
1190
|
+
// reads and writes each pixel once in 128-byte bursts, past the cache: 640 KB
|
|
1191
|
+
// in 4.6 ms. (The PPA's block move was no faster than the CPU.) IDF writes the
|
|
1192
|
+
// source back and invalidates the destination first.
|
|
1193
|
+
bool dmaScrollCopy(const std::uint16_t *src, std::uint16_t *dst, std::size_t bytes)
|
|
1194
|
+
{
|
|
1195
|
+
if (bytes == 0 || !scrollDmaReady()) return false;
|
|
1196
|
+
// Either core may copy (a patch can run on the row worker): each call waits
|
|
1197
|
+
// on its own semaphore.
|
|
1198
|
+
StaticSemaphore_t doneStorage;
|
|
1199
|
+
SemaphoreHandle_t done = xSemaphoreCreateBinaryStatic(&doneStorage);
|
|
1200
|
+
if (esp_async_memcpy(g_scrollDma, dst, const_cast<std::uint16_t *>(src), bytes, onScrollDmaDone, done) != ESP_OK) {
|
|
1201
|
+
vSemaphoreDelete(done);
|
|
1202
|
+
return false;
|
|
1203
|
+
}
|
|
1204
|
+
xSemaphoreTake(done, portMAX_DELAY);
|
|
1205
|
+
vSemaphoreDelete(done);
|
|
1206
|
+
return true;
|
|
1207
|
+
}
|
|
1208
|
+
#endif
|
|
1209
|
+
|
|
1020
1210
|
void patchRect(const StaleRect &r)
|
|
1021
1211
|
{
|
|
1022
1212
|
const std::uint16_t *src = g_scanFb[g_frontIndex];
|
|
@@ -1024,6 +1214,17 @@ void patchRect(const StaleRect &r)
|
|
|
1024
1214
|
const std::size_t bytes = static_cast<std::size_t>(r.x1 - r.x0 + 1) * sizeof(std::uint16_t);
|
|
1025
1215
|
const ScanMap &ms = g_map[g_frontIndex];
|
|
1026
1216
|
const ScanMap &md = g_map[g_drawIndex];
|
|
1217
|
+
#if GEA_RGB_DMA_SCROLL
|
|
1218
|
+
// Full-width rows laid out alike in both buffers are one contiguous block:
|
|
1219
|
+
// the DMA copies it (see dmaScrollCopy). A gesture's first frame patches the
|
|
1220
|
+
// whole stale buffer, 16 ms on the CPU and 5.5 ms this way.
|
|
1221
|
+
constexpr int kMinDmaRows = 16;
|
|
1222
|
+
if (r.x0 == 0 && r.x1 == kWidth - 1 && r.y1 - r.y0 + 1 >= kMinDmaRows && mapRow(ms, r.y0) == r.y0 && mapRow(md, r.y0) == r.y0 &&
|
|
1223
|
+
mapRow(ms, r.y1) == r.y1 && mapRow(md, r.y1) == r.y1 && (ms.h == 0 || ms.off == 0) && (md.h == 0 || md.off == 0)) {
|
|
1224
|
+
const std::size_t at = static_cast<std::size_t>(r.y0) * kWidth;
|
|
1225
|
+
if (dmaScrollCopy(&src[at], &dst[at], static_cast<std::size_t>(r.y1 - r.y0 + 1) * kWidth * sizeof(std::uint16_t))) return;
|
|
1226
|
+
}
|
|
1227
|
+
#endif
|
|
1027
1228
|
for (int y = r.y0; y <= r.y1; ++y) {
|
|
1028
1229
|
scanoutRowCopy(&dst[static_cast<std::size_t>(mapRow(md, y)) * kWidth + r.x0],
|
|
1029
1230
|
&src[static_cast<std::size_t>(mapRow(ms, y)) * kWidth + r.x0], bytes);
|
|
@@ -1477,6 +1678,9 @@ esp_err_t initRgbPanel()
|
|
|
1477
1678
|
config.timings.vsync_back_porch = display.vsyncBackPorch;
|
|
1478
1679
|
config.timings.vsync_front_porch = display.vsyncFrontPorch;
|
|
1479
1680
|
config.timings.flags.pclk_active_neg = display.pclkActiveNeg ? 1 : 0;
|
|
1681
|
+
#ifdef GEA_EMBEDDED_DISPLAY_RGB_PCLK_IDLE_HIGH
|
|
1682
|
+
config.timings.flags.pclk_idle_high = GEA_EMBEDDED_DISPLAY_RGB_PCLK_IDLE_HIGH;
|
|
1683
|
+
#endif
|
|
1480
1684
|
config.data_width = 16;
|
|
1481
1685
|
config.in_color_format = LCD_COLOR_FMT_RGB565;
|
|
1482
1686
|
config.out_color_format = LCD_COLOR_FMT_RGB565;
|
|
@@ -1505,7 +1709,20 @@ esp_err_t initRgbPanel()
|
|
|
1505
1709
|
}
|
|
1506
1710
|
if (ownFbs < wantFbs) ESP_LOGW(kTag, "no room for %d scanout buffers; using %d", wantFbs, ownFbs);
|
|
1507
1711
|
#else
|
|
1508
|
-
|
|
1712
|
+
// Direct scanout (the P4): the driver owns the framebuffers and scans them
|
|
1713
|
+
// straight out of PSRAM with only a small FIFO, so a PSRAM stall of a few
|
|
1714
|
+
// microseconds underruns it and the picture shifts right (see onPanelVsync
|
|
1715
|
+
// for the recovery). On the CrowPanel 5.0 slow flash was such a stall:
|
|
1716
|
+
// at DIO 40MHz it underran every few seconds; at its QIO 80MHz, never.
|
|
1717
|
+
// Two swapping buffers, as in Elecrow's firmware: one buffer adds a
|
|
1718
|
+
// PSRAM-to-PSRAM copy of each changed region. Driver-filled bounce
|
|
1719
|
+
// buffers, when a board names rows, could not keep up with the render
|
|
1720
|
+
// load on the CrowPanel 5.0 (frames dropped en masse).
|
|
1721
|
+
{
|
|
1722
|
+
const int rows = display.bounceRows;
|
|
1723
|
+
config.bounce_buffer_size_px = rows > 0 && kHeight % rows == 0 ? static_cast<std::size_t>(kWidth) * rows : 0;
|
|
1724
|
+
g_driverBounce = config.bounce_buffer_size_px != 0;
|
|
1725
|
+
}
|
|
1509
1726
|
#endif
|
|
1510
1727
|
config.dma_burst_size = 64;
|
|
1511
1728
|
config.hsync_gpio_num = display.hsync;
|
|
@@ -1633,6 +1850,67 @@ esp_err_t initRgbPanel()
|
|
|
1633
1850
|
g_stripBuffer ? "ON" : "OFF (no internal SRAM)", g_stripBuffer, g_stripRows, g_stripHalves,
|
|
1634
1851
|
static_cast<unsigned>(heap_caps_get_free_size(MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT)),
|
|
1635
1852
|
static_cast<unsigned>(heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT)));
|
|
1853
|
+
#endif
|
|
1854
|
+
#if !GEA_EMBEDDED_DISPLAY_RGB_BOUNCE && GEA_EMBEDDED_RGB_SYNC_MONITOR
|
|
1855
|
+
// Scan health, every 2 s: in step, the driver completes exactly one frame
|
|
1856
|
+
// per VSYNC; a difference means the DMA fell out of step with the panel.
|
|
1857
|
+
xTaskCreatePinnedToCore([](void *) {
|
|
1858
|
+
std::uint32_t v0 = g_vsyncSeq, f0 = g_frameSeq;
|
|
1859
|
+
for (;;) {
|
|
1860
|
+
vTaskDelay(pdMS_TO_TICKS(2000));
|
|
1861
|
+
const std::uint32_t v = g_vsyncSeq, f = g_frameSeq;
|
|
1862
|
+
std::printf("[rgb-sync] vsync=%u frames=%u diff=%d late>40us=%u >200us=%u >700us=%u max=%uus eofgap=%d..%d last=%d swaps=%u dmapos=%d..%d last=%d unknown=%u restarts=%u\n", unsigned(v - v0), unsigned(f - f0), int((v - v0) - (f - f0)), unsigned(g_vsyncLate40), unsigned(g_vsyncLate200us), unsigned(g_vsyncLate700), unsigned(g_vsyncLateMaxQ4 >> 4), int(g_eofGapMin), int(g_eofGapMax), int(g_eofGapLast), unsigned(g_swapCount), int(g_dmaPosMin), int(g_dmaPosMax), int(g_dmaPosLast), unsigned(g_dmaPosUnknown), unsigned(g_vsyncRestarts));
|
|
1863
|
+
g_vsyncRestarts = 0;
|
|
1864
|
+
if (g_lagMs) {
|
|
1865
|
+
std::printf("[rgb-lag] t=%ums before: c0=%s c1=%s at: c0=%s c1=%s\n", unsigned(g_lagMs), g_lagTask[0] ? g_lagTask[0] : "?", g_lagTask[1] ? g_lagTask[1] : "?", g_lagTask[2] ? g_lagTask[2] : "?", g_lagTask[3] ? g_lagTask[3] : "?");
|
|
1866
|
+
g_lagMs = 0;
|
|
1867
|
+
}
|
|
1868
|
+
g_dmaPosMin = 1 << 30; g_dmaPosMax = -(1 << 30); g_dmaPosUnknown = 0;
|
|
1869
|
+
g_swapCount = 0;
|
|
1870
|
+
g_eofGapMin = 1 << 30; g_eofGapMax = -(1 << 30);
|
|
1871
|
+
for (std::uint32_t i = 0; i < g_slipLogN; ++i) std::printf("[rgb-slip] t=%ums gap=%dus since_swap=%dms\n", unsigned(g_slipLogMs[i]), int(g_slipLogUs[i]), g_slipSinceSwap[i]);
|
|
1872
|
+
g_slipLogN = 0;
|
|
1873
|
+
g_vsyncLate40 = g_vsyncLate200us = g_vsyncLate700 = g_vsyncLateMaxQ4 = 0;
|
|
1874
|
+
v0 = v;
|
|
1875
|
+
f0 = f;
|
|
1876
|
+
}
|
|
1877
|
+
}, "rgb_sync", 3072, nullptr, 1, nullptr, 0);
|
|
1878
|
+
#endif
|
|
1879
|
+
#if GEA_RGB_FRAME_TRACE
|
|
1880
|
+
{
|
|
1881
|
+
// Bandwidth probe: 640 KB copies between the two scan buffers / SRAM.
|
|
1882
|
+
const std::size_t n = 640 * 1024;
|
|
1883
|
+
auto *a = static_cast<std::uint8_t *>(heap_caps_aligned_alloc(64, n, MALLOC_CAP_SPIRAM));
|
|
1884
|
+
auto *b = static_cast<std::uint8_t *>(heap_caps_aligned_alloc(64, n, MALLOC_CAP_SPIRAM));
|
|
1885
|
+
auto *sram = static_cast<std::uint8_t *>(heap_caps_aligned_alloc(64, 32768, MALLOC_CAP_INTERNAL));
|
|
1886
|
+
if (a && b && sram) {
|
|
1887
|
+
std::memset(a, 1, n); std::memset(b, 2, n);
|
|
1888
|
+
std::int64_t t0 = esp_timer_get_time(); std::memcpy(b, a, n); std::int64_t t1 = esp_timer_get_time();
|
|
1889
|
+
for (std::size_t o = 0; o < n; o += 32768) std::memcpy(b + o, sram, 32768);
|
|
1890
|
+
std::int64_t t2 = esp_timer_get_time();
|
|
1891
|
+
for (std::size_t o = 0; o < n; o += 32768) std::memcpy(sram, a + o, 32768);
|
|
1892
|
+
std::int64_t t3 = esp_timer_get_time();
|
|
1893
|
+
std::memset(b, 3, n); std::int64_t t4 = esp_timer_get_time();
|
|
1894
|
+
std::printf("[bw] psram->psram %dus sram->psram %dus psram->sram %dus memset %dus (640KB)\n", int(t1 - t0), int(t2 - t1), int(t3 - t2), int(t4 - t3));
|
|
1895
|
+
}
|
|
1896
|
+
if (a) heap_caps_free(a);
|
|
1897
|
+
if (b) heap_caps_free(b);
|
|
1898
|
+
if (sram) heap_caps_free(sram);
|
|
1899
|
+
}
|
|
1900
|
+
#endif
|
|
1901
|
+
#if GEA_RGB_FRAME_TRACE
|
|
1902
|
+
xTaskCreatePinnedToCore([](void *) {
|
|
1903
|
+
std::uint32_t tail = 0;
|
|
1904
|
+
for (;;) {
|
|
1905
|
+
vTaskDelay(pdMS_TO_TICKS(200));
|
|
1906
|
+
const std::uint32_t head = g_traceHead;
|
|
1907
|
+
if (head - tail > 128) tail = head - 128;
|
|
1908
|
+
for (; tail != head; ++tail) {
|
|
1909
|
+
const FrameTrace t = g_trace[tail % 128];
|
|
1910
|
+
std::printf("[ft] %u dt=%d raster=%d copy=%d wait=%d pub=%d px=%d patch=%d p%u\n", unsigned(t.ms), int(t.dtUs), int(t.rasterUs), int(t.copyUs), int(t.waitUs), int(t.pubUs), int(t.px), int(t.patchPx), unsigned(t.path));
|
|
1911
|
+
}
|
|
1912
|
+
}
|
|
1913
|
+
}, "rgb_trace", 3072, nullptr, 1, nullptr, 0);
|
|
1636
1914
|
#endif
|
|
1637
1915
|
ESP_LOGI(kTag, "RGB panel ready %dx%d pclk=%d bounce_rows=%d fb=%p fb2=%p swap=%d isr_core=%d draw_fb=%p single_fb=%d row_bytes=%u fb_alignment64=%u vsync_restart=%d",
|
|
1638
1916
|
kWidth,
|
|
@@ -2700,6 +2978,9 @@ extern "C" void gea_replay_stage_end()
|
|
|
2700
2978
|
}
|
|
2701
2979
|
}
|
|
2702
2980
|
|
|
2981
|
+
// The PIE vector unit is the S3's (Xtensa LX7); elsewhere (the ESP32-P4's
|
|
2982
|
+
// RISC-V cores) render.cpp's weak defaults keep the drawer on its scalar path.
|
|
2983
|
+
#if CONFIG_IDF_TARGET_ESP32S3
|
|
2703
2984
|
namespace {
|
|
2704
2985
|
|
|
2705
2986
|
// ── PIE SIMD over-blend (gea_pie_blend hooks) ────────────────────────────────
|
|
@@ -2795,6 +3076,7 @@ extern "C" void gea_pie_blend_span8(std::uint16_t *dst, const std::uint16_t *fgN
|
|
|
2795
3076
|
pieBlendSpan8Native(dst, fgN, a5, count8, &cb2[0][0]);
|
|
2796
3077
|
taskEXIT_CRITICAL(mux);
|
|
2797
3078
|
}
|
|
3079
|
+
#endif // CONFIG_IDF_TARGET_ESP32S3
|
|
2798
3080
|
|
|
2799
3081
|
extern "C" int gea_current_render_core()
|
|
2800
3082
|
{
|
|
@@ -2845,6 +3127,16 @@ bool Display::init()
|
|
|
2845
3127
|
return true;
|
|
2846
3128
|
}
|
|
2847
3129
|
|
|
3130
|
+
// No zero-copy producer path yet: a camera (or video) producer composes into the
|
|
3131
|
+
// canvas and is flushed like any other rect. Declining here is what sends it there.
|
|
3132
|
+
bool Display::panelDirectTarget(int, int, int, int, uint16_t **, int *, int *, int *, int *, int *, int *, int *,
|
|
3133
|
+
int *)
|
|
3134
|
+
{
|
|
3135
|
+
return false;
|
|
3136
|
+
}
|
|
3137
|
+
void Display::flipPanelToBack() {}
|
|
3138
|
+
void Display::flipPanelToBack(uint16_t *) {}
|
|
3139
|
+
|
|
2848
3140
|
bool Display::start()
|
|
2849
3141
|
{
|
|
2850
3142
|
if (!g_initialized && !init()) return false;
|
|
@@ -3400,6 +3692,7 @@ bool backRowReleased(std::uint32_t freeSeq, int row)
|
|
|
3400
3692
|
}
|
|
3401
3693
|
} // namespace
|
|
3402
3694
|
|
|
3695
|
+
|
|
3403
3696
|
namespace {
|
|
3404
3697
|
struct ScrollCopy {
|
|
3405
3698
|
const std::uint16_t *src;
|
|
@@ -3497,6 +3790,27 @@ void Display::scrollRect(int x, int y, int w, int h, int dx, int dy)
|
|
|
3497
3790
|
// copy at full speed from the other core starves the bounce ISR's refill of
|
|
3498
3791
|
// the same bus, and the panel shows stale bounce rows (short glitch lines);
|
|
3499
3792
|
// on the ISR's core the ISR simply preempts it.
|
|
3793
|
+
#if GEA_RGB_DMA_SCROLL
|
|
3794
|
+
// Full-width rows are contiguous memory: one transfer moves them all. A
|
|
3795
|
+
// sideways shift then also carries a few pixels from each row's end into
|
|
3796
|
+
// the next row's start, both inside the strip the shift exposes, which the
|
|
3797
|
+
// caller repaints after this returns.
|
|
3798
|
+
if (x0 == 0 && x1 == kWidth - 1) {
|
|
3799
|
+
const int ady = dy > 0 ? dy : -dy;
|
|
3800
|
+
const int srcRow = dy < 0 ? y0 + ady : y0, dstRow = dy > 0 ? y0 + dy : y0;
|
|
3801
|
+
const std::size_t len = dx != 0 ? (static_cast<std::size_t>(rh - 1) * kWidth) * sizeof(std::uint16_t) + bytes
|
|
3802
|
+
: static_cast<std::size_t>(rh - ady) * kWidth * sizeof(std::uint16_t);
|
|
3803
|
+
// It writes every row at once: the panel must be done with the buffer.
|
|
3804
|
+
waitBackBufferFree();
|
|
3805
|
+
if (dmaScrollCopy(&src[static_cast<std::size_t>(srcRow) * kWidth + sx0], &dst[static_cast<std::size_t>(dstRow) * kWidth + dxs], len)) {
|
|
3806
|
+
g_swapDiag.copyUs += esp_timer_get_time() - c0;
|
|
3807
|
+
ensureBackReady(&skip, 1);
|
|
3808
|
+
g_canvas.markDirty(x0, y0, x1, y1);
|
|
3809
|
+
markStale(x0, y0, x1, y1);
|
|
3810
|
+
return;
|
|
3811
|
+
}
|
|
3812
|
+
}
|
|
3813
|
+
#endif
|
|
3500
3814
|
ScrollCopy job{src, dst, dxs, sx0, bytes, y0, y1, dy, g_freeSeq[g_drawIndex]};
|
|
3501
3815
|
if (g_panelIsrCore >= 0 && g_panelIsrCore != static_cast<int>(xPortGetCoreID()) &&
|
|
3502
3816
|
submitRenderWorkerJob(scrollCopyRows, &job, y0, y1)) {
|
|
@@ -3541,6 +3855,11 @@ extern "C" bool gea_display_scroll_rect_begin(int x, int y, int w, int h, int dx
|
|
|
3541
3855
|
const std::uint32_t *const nextSig = g_nextSig;
|
|
3542
3856
|
g_nextSig = nullptr;
|
|
3543
3857
|
if (!g_swapFbs || g_backReady || onWorkerCore() || dy != 0 || dx == 0 || g_regionH > 0) return false;
|
|
3858
|
+
#if GEA_RGB_DMA_SCROLL
|
|
3859
|
+
// A full-width viewport: the DMA copy (Display::scrollRect) beats overlapping
|
|
3860
|
+
// the CPU copy with the strip repaint.
|
|
3861
|
+
if (x <= 0 && x + w >= kWidth && scrollDmaReady()) return false;
|
|
3862
|
+
#endif
|
|
3544
3863
|
if (g_panelIsrCore < 0 || g_panelIsrCore == static_cast<int>(xPortGetCoreID())) return false;
|
|
3545
3864
|
int x0 = x, y0 = y, x1 = x + w - 1, y1 = y + h - 1;
|
|
3546
3865
|
int cx0, cy0, cx1, cy1;
|