Notes: idea of custom firmware on the display, and the bricking risk

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
mangavalkandClaude Opus 5.5 committed 2026-11-16 23:51:04 +01:00
1 parent 85422a1ef4
commit 7bb102676b
1 file changed
+34
+34
View File
@@ -232,3 +232,37 @@ Samples waiting to be compiled: `g3.json` in the session scratchpad (directions
`>=`, mixed `&&`/`||`, string attributes, negative globals, more variants) -- regenerate with
`tools/make_tft_samples.py` (`direction` and `gradient` keys) if the scratchpad is gone.
New sample pairs live in `D:\Claude\nextion-tft-samples\2026-11-17` (outside the repo).
## Idea: custom firmware on the display, and the risk of bricking it (2026-11-17)
Only an idea, not planned. Nothing here was tested; the chips on the board have not been
identified (a photo of the back of the board would tell us the MCU, display controller, flash
and whether there are SWD/JTAG pads).
Three ways to get our own code onto the screen, from safest to riskiest:
1. **A `.tft` from our builder, uploaded the normal way (serial or microSD): low risk.** The
builder copies Nextion's firmware pieces unchanged (the SHA-256 check guarantees that). Only
the project data is ours. A mistake there should give a blank or garbled screen, a crash loop or
a refused upload, not a dead update path. The usual recovery is a microSD card with a
known-good Editor-made `.tft` (insert, power on). Caveat: which flash areas the firmware pieces
overwrite is unknown, but since they are the Editor's own bytes the risk equals any Editor
upload. Before the first test on a real display: prepare that recovery card, and start with a
builder output that is byte-identical to the Editor's.
2. **Our own firmware flashed over SWD (like the nRF dongle): the Nextion firmware is lost for
good, the hardware survives.** The chip is almost certainly read-protected, so the original
cannot be backed up. The chip itself is hard to brick through SWD: it can almost always be
reflashed. Exceptions: firmware that disables the debug pins (usually recoverable by connecting
under reset) and setting the permanent read-protection level (irreversible). Small hardware
risk: driving a pin against something on the board, or misconfiguring the backlight / LCD
supply. Read the board layout before writing to pins. Then own drivers are needed for the LCD
controller, the touch input, the flash and the UART, after which LVGL could run on it. Feasible
on a common STM32/GD32-class MCU with enough RAM; much harder with a proprietary or FPGA
display controller. Only on a spare display.
3. **Our own code in the firmware slots of a `.tft`: highest risk, far away.** Broken code there
could stop the display from ever accepting a new upload; whether microSD recovery still works
depends on where the bootloader lives (unknown). It would also need Nextion's runtime and
bootloader to be understood, which goes beyond the black-box rule.
Cheaper alternative if the goal is just "our own code on the remote's screen": an ESP32 board with
a 3.5" 480x320 touchscreen costs about the same, is fully open, runs LVGL and has Wi-Fi/Bluetooth.