Initial CYD LD2420 radar dashboard with flashable firmware archive.

Presence uses ESPHome factory gates/timeout; OT1->GPIO22 RX->GPIO27; prebuilt bins under firmware/cyd_28r. Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-18 21:53:26 +08:00
commit d5cfc30b3b
16 changed files with 1422 additions and 0 deletions
--- a/.cursor/rules/git-and-docs.mdc
+++ b/.cursor/rules/git-and-docs.mdc
@@ -0,0 +1,15 @@
+---
+description: 每次改动必须提交 Git、更新文档，并刷新预编译固件
+alwaysApply: true
+---
+
+# Git、文档与固件
+
+对本项目做任何功能、行为或配置改动后，在结束本次任务前必须：
+
+1. **更新文档**：至少更新 `README.md` 的「功能 / 硬件 / 变更记录」中受影响部分。
+2. **刷新预编译固件**：运行 `.\firmware\export_from_build.ps1`（或 `-SkipBuild`），保证 `firmware/cyd_28r/` 随时可刷。
+3. **提交 Git**：`git add` 相关文件后 `git commit`（含 `firmware/` 归档）。
+4. **不要**在未提交的情况下声称任务已完成。
+
+例外：用户明确说「先别提交」或「不要改文档」时，以用户当次指令为准。
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,8 @@
+.pio
+.vscode/.browse.c_cpp.db*
+.vscode/c_cpp_properties.json
+.vscode/launch.json
+.vscode/ipch
+*.pyc
+__pycache__/
+.DS_Store
--- a/README.md
+++ b/README.md
@@ -0,0 +1,102 @@
+# CYD LD2420 雷达仪表盘
+
+ESP32 Cheap Yellow Display（ESP32-2432S028R）+ HLK-LD2420 24GHz 毫米波雷达 + LVGL 仪表盘。
+
+## 硬件
+
+| 项目 | 说明 |
+|------|------|
+| 板子 | CYD ESP32-2432S028R（2.8" ILI9341） |
+| 传感器 | HLK-LD2420 |
+| OT1 | **GPIO22**（模块串口 TX → ESP RX，固件 ≥ v1.5.3） |
+| RX | **GPIO27**（模块串口 RX → ESP TX） |
+| 供电 | 3.3V / GND（与 CYD 共地） |
+
+接线（固件 ≥ v1.5.3）：
+
+```
+LD2420 3V3 → CYD 3.3V
+LD2420 GND → CYD GND
+LD2420 OT1 → GPIO22
+LD2420 RX  → GPIO27
+```
+
+> 旧固件（&lt; v1.5.3）串口 TX 在 OT2，且默认波特率多为 **256000**。本工程会依次探测 115200 / 256000。
+
+## 功能
+
+- 横屏网格：距离圆弧 + 存在圆弧；底部左信息 / 右趋势图
+- **显示 LD2420 固件版本**（启动时进入配置模式读取 `CMD 0x0000`）
+- **存在逻辑**：移动或静止检到 → 保持 ON；离开约 **10s** 后才 OFF（ESPHome 同款超时/门限）
+- 检测门默认 1–12（约 0.7–8.4 m），出厂静止门限（能坐着不动也保持有人）
+- 短按切换背光；长按 ≥0.7s 重置 min/max
+
+## 构建与烧录
+
+依赖 [PlatformIO](https://platformio.org/)。
+
+```bash
+pio run -e cyd_28r -t upload
+pio device monitor -b 115200
+```
+
+### 预编译固件（随时刷，不必编译）
+
+已归档到 [`firmware/cyd_28r/`](firmware/cyd_28r/)（含 bootloader / partitions / app）：
+
+```powershell
+cd firmware\cyd_28r
+.\flash.ps1
+# 或 .\flash.ps1 -Port COM3
+```
+
+说明见 [`firmware/README.md`](firmware/README.md)。源码更新后重新打包：`.\firmware\export_from_build.ps1`。
+
+### 环境选择
+
+| 环境 | 适用 |
+|------|------|
+| `cyd_28r` | 标准 ILI9341 CYD（默认） |
+| `cyd_28r_inv` | 颜色反相 / 发白 |
+| `cyd_28_st7789` | USB-C 双口 / ST7789 变体 |
+
+## 项目结构
+
+```
+platformio.ini                 # 板级与库依赖
+include/lv_conf.h              # LVGL 配置
+src/main.cpp                   # 仪表盘 + LD2420 驱动
+scripts/exclude_lvgl_asm.py    # 排除 ESP32 不兼容的 LVGL ASM
+firmware/                      # 预编译固件（可离线刷写）
+.cursor/rules/                 # Cursor 协作规则
+README.md                      # 本文档
+```
+
+## 变更约定
+
+每次功能或行为改动须：
+
+1. 更新本 README（及必要时的注释）
+2. 刷新 `firmware/cyd_28r/`（`.\firmware\export_from_build.ps1`）
+3. `git add` + `git commit` 提交
+
+详见 `.cursor/rules/git-and-docs.mdc`。
+
+## 变更记录
+
+| 日期 | 说明 |
+|------|------|
+| 2026-10-18 | 初版：CYD + LD2420 LVGL 仪表盘；OT1→GPIO22、RX→GPIO27；显示固件版本 |
+| 2026-10-18 | 存在逻辑改为 ESPHome 出厂门限 + 10s 离开保持（动/静均保持 ON） |
+| 2026-10-18 | 归档预编译固件到 `firmware/cyd_28r/`，附一键刷写；初始化本地 Git |
+
+## 串口日志示例
+
+```
+CYD LVGL LD2420 Radar Dashboard
+LD2420 probe @ 115200 baud RX=22 TX=27
+  FW=v1.6.1  mode=simple
+  set gates 1..12 to=10s (OK)
+```
+
+界面左下角会显示 `FW v1.6.1` 与波特率（后缀 `S`=Simple）。
--- a/firmware/README.md
+++ b/firmware/README.md
@@ -0,0 +1,46 @@
+# 预编译固件（可随时刷写）
+
+当前归档目录：[`cyd_28r/`](cyd_28r/)
+
+对应板子：**CYD ESP32-2432S028R**（ILI9341），LD2420 OT1→GPIO22、RX→GPIO27。  
+版本信息见 [`cyd_28r/VERSION.txt`](cyd_28r/VERSION.txt)。
+
+## 直接刷写（无需重新编译）
+
+1. USB 连接板子  
+2. 在本目录执行：
+
+```powershell
+cd firmware\cyd_28r
+.\flash.ps1
+# 或指定端口
+.\flash.ps1 -Port COM3
+```
+
+也可双击 / 运行 `flash.bat`。
+
+依赖其一即可：
+
+- 已安装 PlatformIO（`pio`，自带 esptool）
+- 或 `pip install esptool`
+
+## 手动 esptool
+
+```bash
+esptool.py --chip esp32 --port COM3 --baud 921600 write_flash -z ^
+  --flash_mode dio --flash_freq 40m --flash_size 4MB ^
+  0x1000 bootloader.bin ^
+  0x8000 partitions.bin ^
+  0xe000 boot_app0.bin ^
+  0x10000 firmware.bin
+```
+
+## 从源码重新打包进本目录
+
+在仓库根目录：
+
+```powershell
+.\firmware\export_from_build.ps1
+# 仅复制、不编译：
+.\firmware\export_from_build.ps1 -SkipBuild
+```
--- a/firmware/cyd_28r/VERSION.txt
+++ b/firmware/cyd_28r/VERSION.txt
@@ -0,0 +1,16 @@
+name: CYD LD2420 radar dashboard (cyd_28r)
+git: unknown
+date: 2026-10-18
+board: ESP32-2432S028R (ILI9341)
+ld2420: OT1->GPIO22 RX->GPIO27
+flash_size: 4MB
+offsets:
+  0x1000  bootloader.bin
+  0x8000  partitions.bin
+  0xe000  boot_app0.bin
+  0x10000 firmware.bin
+sha256:
+  bootloader.bin  3D234A7471F67B013686DABD4DEE7C1FA915C9928463616A94BC9297ACF1ABF8
+  boot_app0.bin   F94C5D786A7A8FAB06AC5D10E33BF37711A6697636DC037559EA19CC410A17F0
+  firmware.bin    33D7FADFD8050A0B83BE2EC233A0A310644E6545DEA0E7BCD63B315153B89A63
+  partitions.bin  0A8B5720E7B77FF11F1462458C3A509DEE79224E5279898F26D6A2E3AE0517B7
--- a/firmware/cyd_28r/boot_app0.bin
+++ b/firmware/cyd_28r/boot_app0.bin
--- a/firmware/cyd_28r/bootloader.bin
+++ b/firmware/cyd_28r/bootloader.bin
--- a/firmware/cyd_28r/firmware.bin
+++ b/firmware/cyd_28r/firmware.bin
--- a/firmware/cyd_28r/flash.bat
+++ b/firmware/cyd_28r/flash.bat
@@ -0,0 +1,5 @@
+@echo off
+setlocal
+cd /d "%~dp0"
+powershell -NoProfile -ExecutionPolicy Bypass -File "%~dp0flash.ps1" %*
+exit /b %ERRORLEVEL%
--- a/firmware/cyd_28r/flash.ps1
+++ b/firmware/cyd_28r/flash.ps1
@@ -0,0 +1,84 @@
+# Flash archived CYD LD2420 radar firmware (no rebuild needed)
+# Usage:
+#   .\flash.ps1
+#   .\flash.ps1 -Port COM5
+#   .\flash.ps1 -Port COM5 -Baud 460800
+
+param(
+  [string]$Port = "",
+  [int]$Baud = 921600
+)
+
+$ErrorActionPreference = "Stop"
+$here = Split-Path -Parent $MyInvocation.MyCommand.Path
+Set-Location $here
+
+function Find-Esptool {
+  $pio = Get-Command pio -ErrorAction SilentlyContinue
+  if ($pio) {
+    $pkg = Join-Path $env:USERPROFILE ".platformio\packages\tool-esptoolpy\esptool.py"
+    if (Test-Path $pkg) { return @{ Kind = "py"; Path = $pkg } }
+  }
+  $py = Get-Command python -ErrorAction SilentlyContinue
+  if ($py) {
+    try {
+      & python -c "import esptool" 2>$null
+      if ($LASTEXITCODE -eq 0) { return @{ Kind = "mod"; Path = "esptool" } }
+    } catch {}
+  }
+  $esp = Get-Command esptool.py -ErrorAction SilentlyContinue
+  if ($esp) { return @{ Kind = "py"; Path = $esp.Source } }
+  return $null
+}
+
+if (-not $Port) {
+  $ports = @()
+  try {
+    Add-Type -AssemblyName System.IO.Ports -ErrorAction SilentlyContinue | Out-Null
+    $ports = [System.IO.Ports.SerialPort]::GetPortNames() | Sort-Object
+  } catch {}
+  if (-not $ports -or $ports.Count -eq 0) {
+    $ports = Get-CimInstance Win32_SerialPort -ErrorAction SilentlyContinue |
+      Select-Object -ExpandProperty DeviceID | Sort-Object
+  }
+  if (-not $ports -or $ports.Count -eq 0) {
+    Write-Error "No serial ports found. Plug in the CYD USB cable, then retry with -Port COMx"
+  }
+  if ($ports.Count -eq 1) {
+    $Port = $ports[0]
+  } else {
+    Write-Host "Available ports: $($ports -join ', ')"
+    $Port = $ports[-1]
+    Write-Host "Using last port: $Port (override with -Port)"
+  }
+}
+
+$tool = Find-Esptool
+if (-not $tool) {
+  Write-Error "esptool not found. Install PlatformIO (`pio`) or: pip install esptool"
+}
+
+$argsCommon = @(
+  "--chip", "esp32",
+  "--port", $Port,
+  "--baud", "$Baud",
+  "--before", "default_reset",
+  "--after", "hard_reset",
+  "write_flash", "-z",
+  "--flash_mode", "dio",
+  "--flash_freq", "40m",
+  "--flash_size", "4MB",
+  "0x1000", "bootloader.bin",
+  "0x8000", "partitions.bin",
+  "0xe000", "boot_app0.bin",
+  "0x10000", "firmware.bin"
+)
+
+Write-Host "Flashing $here -> $Port @ $Baud"
+if ($tool.Kind -eq "mod") {
+  & python -m esptool @argsCommon
+} else {
+  & python $tool.Path @argsCommon
+}
+if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+Write-Host "Done. Open serial monitor at 115200 if needed."
--- a/firmware/cyd_28r/partitions.bin
+++ b/firmware/cyd_28r/partitions.bin
--- a/firmware/export_from_build.ps1
+++ b/firmware/export_from_build.ps1
@@ -0,0 +1,57 @@
+# Rebuild (optional) and refresh firmware/cyd_28r from PlatformIO build output.
+# Usage:
+#   .\firmware\export_from_build.ps1
+#   .\firmware\export_from_build.ps1 -SkipBuild
+
+param([switch]$SkipBuild)
+
+$ErrorActionPreference = "Stop"
+$root = Split-Path -Parent (Split-Path -Parent $MyInvocation.MyCommand.Path)
+Set-Location $root
+
+if (-not $SkipBuild) {
+  pio run -e cyd_28r
+  if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+}
+
+$src = Join-Path $root ".pio\build\cyd_28r"
+$dst = Join-Path $root "firmware\cyd_28r"
+New-Item -ItemType Directory -Force -Path $dst | Out-Null
+
+Copy-Item (Join-Path $src "bootloader.bin") $dst -Force
+Copy-Item (Join-Path $src "partitions.bin") $dst -Force
+Copy-Item (Join-Path $src "firmware.bin") $dst -Force
+
+$bootApp = Join-Path $env:USERPROFILE ".platformio\packages\framework-arduinoespressif32\tools\partitions\boot_app0.bin"
+if (-not (Test-Path $bootApp)) {
+  Write-Error "boot_app0.bin not found under PlatformIO packages"
+}
+Copy-Item $bootApp (Join-Path $dst "boot_app0.bin") -Force
+
+$git = "unknown"
+try {
+  $git = (git -C $root rev-parse --short HEAD 2>$null).Trim()
+  if (-not $git) { $git = "unknown" }
+} catch { $git = "unknown" }
+
+$date = Get-Date -Format "yyyy-MM-dd"
+$hashes = Get-FileHash (Join-Path $dst "*.bin") -Algorithm SHA256
+$lines = @(
+  "name: CYD LD2420 radar dashboard (cyd_28r)",
+  "git: $git",
+  "date: $date",
+  "board: ESP32-2432S028R (ILI9341)",
+  "ld2420: OT1->GPIO22 RX->GPIO27",
+  "flash_size: 4MB",
+  "offsets:",
+  "  0x1000  bootloader.bin",
+  "  0x8000  partitions.bin",
+  "  0xe000  boot_app0.bin",
+  "  0x10000 firmware.bin",
+  "sha256:"
+)
+foreach ($h in $hashes) {
+  $lines += ("  {0,-15} {1}" -f (Split-Path $h.Path -Leaf), $h.Hash)
+}
+$lines | Set-Content -Encoding utf8 (Join-Path $dst "VERSION.txt")
+Write-Host "Exported -> $dst (git $git)"
--- a/include/lv_conf.h
+++ b/include/lv_conf.h
@@ -0,0 +1,86 @@
+#ifndef LV_CONF_H
+#define LV_CONF_H
+
+#include <stdint.h>
+
+#define LV_COLOR_DEPTH 16
+
+#define LV_MEM_SIZE (48 * 1024U)
+#define LV_DEF_REFR_PERIOD 16
+#define LV_DPI_DEF 130
+
+/* ESP32 无 Helium，关掉以免 .S 汇编被错误预处理 */
+#define LV_USE_DRAW_SW_ASM LV_DRAW_SW_ASM_NONE
+
+#define LV_USE_OS LV_OS_NONE
+#define LV_USE_STDLIB_MALLOC LV_STDLIB_BUILTIN
+#define LV_USE_STDLIB_STRING LV_STDLIB_BUILTIN
+#define LV_USE_STDLIB_SPRINTF LV_STDLIB_BUILTIN
+
+#define LV_USE_LOG 0
+#define LV_USE_ASSERT_NULL 1
+#define LV_USE_ASSERT_MALLOC 1
+
+#define LV_FONT_MONTSERRAT_12 1
+#define LV_FONT_MONTSERRAT_14 1
+#define LV_FONT_MONTSERRAT_16 1
+#define LV_FONT_MONTSERRAT_20 1
+#define LV_FONT_MONTSERRAT_24 1
+#define LV_FONT_MONTSERRAT_28 1
+#define LV_FONT_MONTSERRAT_32 1
+#define LV_FONT_MONTSERRAT_40 1
+#define LV_FONT_DEFAULT &lv_font_montserrat_14
+
+#define LV_USE_FLOAT 1
+#define LV_USE_MATRIX 0
+
+#define LV_USE_LABEL 1
+#define LV_LABEL_TEXT_SELECTION 0
+#define LV_LABEL_LONG_TXT_HINT 1
+
+#define LV_USE_ARC 1
+#define LV_USE_BAR 1
+#define LV_USE_BTN 1
+#define LV_USE_BUTTON 1
+#define LV_USE_IMG 1
+#define LV_USE_IMAGE 1
+#define LV_USE_LINE 1
+#define LV_USE_SLIDER 1
+#define LV_USE_SWITCH 1
+#define LV_USE_TEXTAREA 0
+#define LV_USE_CHECKBOX 0
+#define LV_USE_DROPDOWN 0
+#define LV_USE_ROLLER 0
+#define LV_USE_TABLE 0
+#define LV_USE_CALENDAR 0
+#define LV_USE_CHART 1
+#define LV_USE_KEYBOARD 0
+#define LV_USE_LIST 0
+#define LV_USE_MENU 0
+#define LV_USE_MSGBOX 0
+#define LV_USE_SPAN 0
+#define LV_USE_SPINBOX 0
+#define LV_USE_SPINNER 1
+#define LV_USE_TABVIEW 0
+#define LV_USE_TILEVIEW 0
+#define LV_USE_WIN 0
+#define LV_USE_LED 1
+#define LV_USE_SCALE 1
+
+#define LV_USE_THEME_DEFAULT 1
+#define LV_THEME_DEFAULT_DARK 1
+#define LV_THEME_DEFAULT_GROW 0
+#define LV_THEME_DEFAULT_TRANSITION_TIME 80
+
+#define LV_USE_FLEX 1
+#define LV_USE_GRID 1
+
+#define LV_USE_TFT_ESPI 1
+
+#define LV_USE_OBSERVER 0
+#define LV_USE_SYSMON 0
+#define LV_USE_PROFILER 0
+#define LV_USE_DEMO_WIDGETS 0
+#define LV_USE_DEMO_BENCHMARK 0
+
+#endif /* LV_CONF_H */
--- a/platformio.ini
+++ b/platformio.ini
@@ -0,0 +1,66 @@
+; CYD ESP32-2432S028R — LVGL LD2420 毫米波雷达仪表盘
+; LD2420 OT1 -> GPIO22 (ESP RX), LD2420 RX -> GPIO27 (ESP TX)
+
+[platformio]
+default_envs = cyd_28r
+
+[env]
+platform = espressif32@6.9.0
+board = esp32dev
+framework = arduino
+monitor_speed = 115200
+upload_speed = 921600
+board_build.partitions = min_spiffs.csv
+lib_deps =
+  lvgl/lvgl@9.2.2
+  bodmer/TFT_eSPI@2.5.43
+  https://github.com/PaulStoffregen/XPT2046_Touchscreen.git
+extra_scripts = pre:scripts/exclude_lvgl_asm.py
+build_flags =
+  -D CORE_DEBUG_LEVEL=0
+  -D USER_SETUP_LOADED=1
+  -D USE_HSPI_PORT=1
+  -D ILI9341_2_DRIVER=1
+  -D TFT_WIDTH=240
+  -D TFT_HEIGHT=320
+  -D TFT_MISO=12
+  -D TFT_MOSI=13
+  -D TFT_SCLK=14
+  -D TFT_CS=15
+  -D TFT_DC=2
+  -D TFT_RST=-1
+  -D TFT_BL=21
+  -D TFT_BACKLIGHT_ON=HIGH
+  -D SPI_FREQUENCY=40000000
+  -D SPI_READ_FREQUENCY=20000000
+  -D LOAD_GLCD=1
+  -D LOAD_FONT2=0
+  -D LOAD_FONT4=0
+  -D LOAD_FONT6=0
+  -D LOAD_FONT7=0
+  -D LOAD_FONT8=0
+  -D LOAD_GFXFF=0
+  -D SMOOTH_FONT=0
+  -D TOUCH_CS=-1
+  -D LV_CONF_INCLUDE_SIMPLE=1
+  -I include
+
+; 标准 CYD 2.8" 电阻屏 (ILI9341)
+[env:cyd_28r]
+build_flags =
+  ${env.build_flags}
+
+; 颜色反相版本（若画面色偏/发白可改用此环境）
+[env:cyd_28r_inv]
+build_flags =
+  ${env.build_flags}
+  -D TFT_INVERSION_ON=1
+
+; USB-C 双口 / 7789 变体
+[env:cyd_28_st7789]
+build_flags =
+  ${env.build_flags}
+  -U ILI9341_2_DRIVER
+  -D ST7789_DRIVER=1
+  -D TFT_RGB_ORDER=TFT_BGR
+  -D TFT_INVERSION_ON=1
--- a/scripts/exclude_lvgl_asm.py
+++ b/scripts/exclude_lvgl_asm.py
@@ -0,0 +1,13 @@
+"""Exclude LVGL Helium/Neon .S files that break ESP32 (xtensa) builds."""
+import shutil
+from pathlib import Path
+
+Import("env")  # type: ignore  # noqa: F821
+
+LIBDEPS = Path(env["PROJECT_LIBDEPS_DIR"]) / env["PIOENV"] / "lvgl"  # type: ignore  # noqa: F821
+
+for sub in ("draw/sw/blend/helium", "draw/sw/blend/neon"):
+    target = LIBDEPS / "src" / sub
+    if target.exists():
+        shutil.rmtree(target, ignore_errors=True)
+        print(f"Removed LVGL ASM path: {target}")
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -0,0 +1,924 @@
+/**
+ * CYD ESP32-2432S028R — LVGL LD2420 毫米波雷达仪表盘
+ *
+ * 接线 (固件 ≥ v1.5.3):
+ *   LD2420 OT1 -> GPIO22  (模块串口 TX → ESP RX)
+ *   LD2420 RX  -> GPIO27  (模块串口 RX → ESP TX)
+ *   VCC 3.3V / GND
+ */
+
+#include <Arduino.h>
+#include <lvgl.h>
+#include <TFT_eSPI.h>
+#include <XPT2046_Touchscreen.h>
+#include <math.h>
+#include <string.h>
+
+/* ---- pins ---- */
+#define LD2420_RX_PIN 22 /* ESP RX  <- OT1 */
+#define LD2420_TX_PIN 27 /* ESP TX  -> RX  */
+#define TFT_BL_PIN 21
+
+#define XPT2046_IRQ 36
+#define XPT2046_MOSI 32
+#define XPT2046_MISO 39
+#define XPT2046_CLK 25
+#define XPT2046_CS 33
+
+#define SCREEN_WIDTH 320
+#define SCREEN_HEIGHT 240
+#define UI_REFRESH_MS 250
+#define CHART_PUSH_MS 1000
+#define SENSOR_STALE_MS 5000
+#define HISTORY_LEN 48
+#define DIST_ARC_MAX 800 /* cm (~11 gates * 70cm) */
+#define DRAW_BUF_SIZE (SCREEN_WIDTH * SCREEN_HEIGHT / 10 * (LV_COLOR_DEPTH / 8))
+
+/* Layout grid — exclusive regions, no overlaps */
+#define UI_M 6
+#define UI_G 6
+#define UI_HDR_H 22
+#define UI_GAUGE_H 124
+#define UI_GAUGE_W 151
+#define UI_ARC 90
+#define UI_BOT_Y (UI_HDR_H + UI_G + UI_GAUGE_H + UI_G) /* 158 */
+#define UI_BOT_H (SCREEN_HEIGHT - UI_BOT_Y - UI_M)      /* 76 */
+#define UI_BOT_W (SCREEN_WIDTH - 2 * UI_M)              /* 308 */
+#define UI_INFO_W 124
+#define UI_CHART_W (UI_BOT_W - 12 - UI_INFO_W - UI_G)   /* ~160 */
+
+/* LD2420 protocol (wire byte order) */
+static const uint8_t CMD_HDR_B[4] = {0xFD, 0xFC, 0xFB, 0xFA};
+static const uint8_t CMD_FTR_B[4] = {0x04, 0x03, 0x02, 0x01};
+static const uint8_t ENERGY_HDR_B[4] = {0xF1, 0xF2, 0xF3, 0xF4};
+static const uint8_t ENERGY_FTR_B[4] = {0xF5, 0xF6, 0xF7, 0xF8};
+static const uint16_t CMD_ENABLE_CONF = 0x00FF;
+static const uint16_t CMD_DISABLE_CONF = 0x00FE;
+static const uint16_t CMD_READ_VERSION = 0x0000;
+static const uint16_t CMD_WRITE_SYS = 0x0012;
+static const uint16_t CMD_WRITE_ABD = 0x0007;
+static const uint16_t CMD_PROTOCOL_VER = 0x0002;
+static const uint16_t SYS_MODE_PARAM = 0x0000;
+static const uint16_t MODE_SIMPLE = 0x0064;
+/*
+ * Presence semantics (ESPHome / HLK):
+ *  - move OR still energy → occupied
+ *  - presence_timeout keeps ON after last hit; only then OFF
+ * Factory still thresholds are low so sitting still stays detected.
+ */
+static const uint32_t CFG_MIN_GATE = 1;    /* ~0.7 m */
+static const uint32_t CFG_MAX_GATE = 12;   /* ~8.4 m */
+static const uint32_t CFG_TIMEOUT_S = 10;  /* seconds after leave before OFF */
+
+/* ESPHome factory thresholds — still must stay sensitive */
+static const uint32_t CFG_MOVE_THRESH[16] = {
+    60000, 30000, 400, 300, 250, 250, 250, 250,
+    300, 250, 250, 250, 250, 200, 200, 200};
+static const uint32_t CFG_STILL_THRESH[16] = {
+    40000, 20000, 200, 250, 150, 150, 150, 150,
+    150, 150, 150, 150, 100, 100, 100, 100};
+
+static const lv_color_t COL_BG = lv_color_hex(0x0A1018);
+static const lv_color_t COL_PANEL = lv_color_hex(0x121C2A);
+static const lv_color_t COL_EDGE = lv_color_hex(0x1E2C40);
+static const lv_color_t COL_TEXT = lv_color_hex(0xF2F5FA);
+static const lv_color_t COL_MUTED = lv_color_hex(0x7E90A8);
+static const lv_color_t COL_DIST = lv_color_hex(0x4DA3FF);
+static const lv_color_t COL_PRES = lv_color_hex(0x3DBF8C);
+static const lv_color_t COL_OK = lv_color_hex(0x4CAF7A);
+static const lv_color_t COL_WARN = lv_color_hex(0xE6B84D);
+static const lv_color_t COL_BAD = lv_color_hex(0xE05A5A);
+static const lv_color_t COL_ARC_BG = lv_color_hex(0x243247);
+static const lv_color_t COL_CHART_BG = lv_color_hex(0x0E1622);
+
+SPIClass touchscreenSPI = SPIClass(VSPI);
+XPT2046_Touchscreen touchscreen(XPT2046_CS, XPT2046_IRQ);
+HardwareSerial RadarSerial(2);
+
+static uint32_t draw_buf[DRAW_BUF_SIZE / 4];
+
+static lv_obj_t *arc_dist;
+static lv_obj_t *arc_pres;
+static lv_obj_t *lbl_dist_val;
+static lv_obj_t *lbl_pres_val;
+static lv_obj_t *lbl_dist_range;
+static lv_obj_t *lbl_pres_hint;
+static lv_obj_t *lbl_state;
+static lv_obj_t *lbl_fw;
+static lv_obj_t *lbl_baud;
+static lv_obj_t *lbl_status;
+static lv_obj_t *lbl_uptime;
+static lv_obj_t *lbl_hint;
+static lv_obj_t *led_status;
+static lv_obj_t *bar_presence;
+static lv_obj_t *chart;
+static lv_chart_series_t *ser_dist;
+static lv_chart_series_t *ser_pres;
+
+static float disp_dist = NAN;
+static float min_dist = NAN;
+static float max_dist = NAN;
+static bool presence = false;
+static bool sensor_ok = false;
+static bool fw_ok = false;
+static char fw_version[24] = "----";
+static uint32_t radar_baud = 115200;
+static bool energy_mode = false;
+static uint32_t last_ok_ms = 0;
+static uint32_t last_ui_ms = 0;
+static uint32_t last_chart_ms = 0;
+static uint32_t last_dbg_ms = 0;
+static uint32_t presence_since_ms = 0;
+static uint8_t bright_level = 2;
+static const uint8_t BRIGHT_PWM[4] = {40, 90, 160, 255};
+static uint32_t hint_until_ms = 0;
+static uint32_t last_seen_ms = 0; /* last time module reported presence energy */
+
+static uint8_t rx_buf[512];
+static uint16_t rx_pos = 0;
+
+static void set_backlight(uint8_t level) {
+  bright_level = level & 0x03;
+  ledcWrite(0, BRIGHT_PWM[bright_level]);
+}
+
+static void show_hint(const char *text, uint32_t ms) {
+  lv_label_set_text(lbl_hint, text);
+  lv_obj_remove_flag(lbl_hint, LV_OBJ_FLAG_HIDDEN);
+  lv_obj_move_foreground(lbl_hint);
+  hint_until_ms = millis() + ms;
+}
+
+static void reset_minmax(void) {
+  if (!isnan(disp_dist)) {
+    min_dist = max_dist = disp_dist;
+  } else {
+    min_dist = max_dist = NAN;
+  }
+  show_hint("min/max reset", 1200);
+}
+
+static void touchscreen_read(lv_indev_t *indev, lv_indev_data_t *data) {
+  LV_UNUSED(indev);
+  static bool was_pressed = false;
+  static uint32_t press_ms = 0;
+
+  if (touchscreen.tirqTouched() && touchscreen.touched()) {
+    TS_Point p = touchscreen.getPoint();
+    data->point.x = map(p.y, 240, 3800, 1, SCREEN_WIDTH);
+    data->point.y = map(p.x, 200, 3700, SCREEN_HEIGHT, 1);
+    data->state = LV_INDEV_STATE_PRESSED;
+    if (!was_pressed) {
+      was_pressed = true;
+      press_ms = millis();
+    }
+  } else {
+    data->state = LV_INDEV_STATE_RELEASED;
+    if (was_pressed) {
+      was_pressed = false;
+      uint32_t held = millis() - press_ms;
+      if (held >= 700) {
+        reset_minmax();
+      } else if (held < 400) {
+        set_backlight((bright_level + 1) & 0x03);
+        char buf[20];
+        lv_snprintf(buf, sizeof(buf), "brightness %u/3", (unsigned)bright_level);
+        show_hint(buf, 900);
+      }
+    }
+  }
+}
+
+static void arc_anim_exec(void *obj, int32_t v) {
+  lv_arc_set_value((lv_obj_t *)obj, v);
+}
+
+static void anim_arc(lv_obj_t *arc, int32_t value) {
+  int32_t cur = lv_arc_get_value(arc);
+  if (cur == value) return;
+  lv_anim_t a;
+  lv_anim_init(&a);
+  lv_anim_set_var(&a, arc);
+  lv_anim_set_values(&a, cur, value);
+  lv_anim_set_duration(&a, 420);
+  lv_anim_set_exec_cb(&a, arc_anim_exec);
+  lv_anim_set_path_cb(&a, lv_anim_path_ease_out);
+  lv_anim_start(&a);
+}
+
+static void bar_anim_exec(void *obj, int32_t v) {
+  lv_bar_set_value((lv_obj_t *)obj, v, LV_ANIM_OFF);
+}
+
+static void anim_bar(lv_obj_t *bar, int32_t value) {
+  int32_t cur = lv_bar_get_value(bar);
+  if (cur == value) return;
+  lv_anim_t a;
+  lv_anim_init(&a);
+  lv_anim_set_var(&a, bar);
+  lv_anim_set_values(&a, cur, value);
+  lv_anim_set_duration(&a, 320);
+  lv_anim_set_exec_cb(&a, bar_anim_exec);
+  lv_anim_set_path_cb(&a, lv_anim_path_ease_out);
+  lv_anim_start(&a);
+}
+
+static lv_obj_t *make_panel(lv_obj_t *parent, int x, int y, int w, int h) {
+  lv_obj_t *p = lv_obj_create(parent);
+  lv_obj_set_pos(p, x, y);
+  lv_obj_set_size(p, w, h);
+  lv_obj_set_style_bg_color(p, COL_PANEL, 0);
+  lv_obj_set_style_bg_opa(p, LV_OPA_COVER, 0);
+  lv_obj_set_style_border_color(p, COL_EDGE, 0);
+  lv_obj_set_style_border_width(p, 1, 0);
+  lv_obj_set_style_radius(p, 12, 0);
+  lv_obj_set_style_pad_all(p, 6, 0);
+  lv_obj_clear_flag(p, LV_OBJ_FLAG_SCROLLABLE);
+  lv_obj_remove_flag(p, LV_OBJ_FLAG_SCROLLABLE);
+  return p;
+}
+
+static lv_obj_t *make_gauge(lv_obj_t *parent, lv_color_t accent, int max_val) {
+  lv_obj_t *arc = lv_arc_create(parent);
+  lv_obj_set_size(arc, UI_ARC, UI_ARC);
+  lv_obj_align(arc, LV_ALIGN_TOP_MID, 0, 2);
+  lv_arc_set_rotation(arc, 135);
+  lv_arc_set_bg_angles(arc, 0, 270);
+  lv_arc_set_range(arc, 0, max_val);
+  lv_arc_set_value(arc, 0);
+  lv_obj_remove_style(arc, NULL, LV_PART_KNOB);
+  lv_obj_clear_flag(arc, LV_OBJ_FLAG_CLICKABLE);
+  lv_obj_set_style_arc_color(arc, COL_ARC_BG, LV_PART_MAIN);
+  lv_obj_set_style_arc_width(arc, 10, LV_PART_MAIN);
+  lv_obj_set_style_arc_color(arc, accent, LV_PART_INDICATOR);
+  lv_obj_set_style_arc_width(arc, 10, LV_PART_INDICATOR);
+  lv_obj_set_style_arc_rounded(arc, true, LV_PART_MAIN);
+  lv_obj_set_style_arc_rounded(arc, true, LV_PART_INDICATOR);
+  return arc;
+}
+
+static lv_color_t dist_color(float cm) {
+  if (isnan(cm)) return COL_MUTED;
+  if (cm < 150.0f) return COL_PRES;
+  if (cm < 400.0f) return COL_DIST;
+  if (cm < 600.0f) return COL_WARN;
+  return COL_BAD;
+}
+
+static int fw_to_int(const char *ver) {
+  const char *p = (*ver == 'v' || *ver == 'V') ? ver + 1 : ver;
+  int result = 0;
+  for (; *p; p++) {
+    if (*p == '.') continue;
+    if (*p < '0' || *p > '9') break;
+    result = result * 10 + (*p - '0');
+  }
+  return result;
+}
+
+/* ---- LD2420 command helpers ---- */
+
+static void radar_flush(void) {
+  while (RadarSerial.available()) RadarSerial.read();
+  rx_pos = 0;
+}
+
+static void radar_write_frame(uint16_t cmd, const uint8_t *data, uint16_t data_len) {
+  uint8_t buf[64];
+  uint16_t len = 0;
+  uint16_t frame_data = (uint16_t)(data_len + 2);
+  memcpy(&buf[len], CMD_HDR_B, 4); len += 4;
+  memcpy(&buf[len], &frame_data, 2); len += 2;
+  memcpy(&buf[len], &cmd, 2); len += 2;
+  if (data && data_len) {
+    memcpy(&buf[len], data, data_len);
+    len += data_len;
+  }
+  memcpy(&buf[len], CMD_FTR_B, 4); len += 4;
+  RadarSerial.write(buf, len);
+  RadarSerial.flush();
+}
+
+static bool radar_wait_ack(uint16_t expect_cmd, uint8_t *out, uint16_t out_cap, uint16_t *out_len,
+                           uint32_t timeout_ms) {
+  uint8_t buf[128];
+  uint16_t pos = 0;
+  uint32_t start = millis();
+  uint16_t reply_cmd = (uint16_t)(expect_cmd | 0x0100);
+
+  while ((millis() - start) < timeout_ms) {
+    while (RadarSerial.available() && pos < sizeof(buf)) {
+      buf[pos++] = (uint8_t)RadarSerial.read();
+      if (pos >= 8) {
+        for (uint16_t i = 0; i + 4 <= pos; i++) {
+          if (memcmp(&buf[i], CMD_HDR_B, 4) != 0) continue;
+          if (i + 10 > pos) continue;
+          uint16_t flen = 0;
+          memcpy(&flen, &buf[i + 4], 2);
+          uint16_t total = (uint16_t)(4 + 2 + flen + 4);
+          if (i + total > pos) continue;
+          if (memcmp(&buf[i + total - 4], CMD_FTR_B, 4) != 0) continue;
+          uint16_t cmd = 0;
+          memcpy(&cmd, &buf[i + 6], 2);
+          if (cmd != reply_cmd && cmd != expect_cmd) continue;
+          uint16_t copy = total;
+          if (copy > out_cap) copy = out_cap;
+          memcpy(out, &buf[i], copy);
+          *out_len = copy;
+          return true;
+        }
+      }
+    }
+    delay(2);
+  }
+  return false;
+}
+
+static bool radar_write_abd_u32(uint16_t param, uint32_t value) {
+  uint8_t data[6];
+  memcpy(&data[0], &param, 2);
+  memcpy(&data[2], &value, 4);
+  radar_write_frame(CMD_WRITE_ABD, data, 6);
+  uint8_t ack[64];
+  uint16_t ack_len = 0;
+  return radar_wait_ack(CMD_WRITE_ABD, ack, sizeof(ack), &ack_len, 1200);
+}
+
+static bool radar_read_abd_u32(uint16_t param, uint32_t *value) {
+  uint8_t data[2];
+  memcpy(data, &param, 2);
+  radar_write_frame(0x0008, data, 2); /* CMD_READ_ABD */
+  uint8_t ack[64];
+  uint16_t ack_len = 0;
+  if (!radar_wait_ack(0x0008, ack, sizeof(ack), &ack_len, 1200)) return false;
+  if (ack_len < 14) return false;
+  memcpy(value, &ack[10], 4);
+  return true;
+}
+
+static bool radar_apply_detection_window(void) {
+  bool ok = true;
+  if (!radar_write_abd_u32(0x0000, CFG_MIN_GATE)) ok = false;
+  delay(20);
+  if (!radar_write_abd_u32(0x0001, CFG_MAX_GATE)) ok = false;
+  delay(20);
+  if (!radar_write_abd_u32(0x0004, CFG_TIMEOUT_S)) ok = false;
+  delay(20);
+  for (uint8_t g = 0; g < 16; g++) {
+    if (!radar_write_abd_u32((uint16_t)(0x0010 + g), CFG_MOVE_THRESH[g])) ok = false;
+    delay(12);
+    if (!radar_write_abd_u32((uint16_t)(0x0020 + g), CFG_STILL_THRESH[g])) ok = false;
+    delay(12);
+  }
+  uint32_t rmin = 0, rmax = 0, rto = 0;
+  radar_read_abd_u32(0x0000, &rmin);
+  radar_read_abd_u32(0x0001, &rmax);
+  radar_read_abd_u32(0x0004, &rto);
+  Serial.printf("  set gates %lu..%lu to=%lus (%s)\n",
+                (unsigned long)CFG_MIN_GATE, (unsigned long)CFG_MAX_GATE,
+                (unsigned long)CFG_TIMEOUT_S, ok ? "OK" : "FAIL");
+  Serial.printf("  readback min=%lu max=%lu timeout=%lu\n",
+                (unsigned long)rmin, (unsigned long)rmax, (unsigned long)rto);
+  return ok;
+}
+
+static bool radar_enable_config(bool enable) {
+  uint8_t ack[64];
+  uint16_t ack_len = 0;
+  if (enable) {
+    uint8_t data[2];
+    memcpy(data, &CMD_PROTOCOL_VER, 2);
+    radar_write_frame(CMD_ENABLE_CONF, data, 2);
+    return radar_wait_ack(CMD_ENABLE_CONF, ack, sizeof(ack), &ack_len, 1200);
+  }
+  radar_write_frame(CMD_DISABLE_CONF, NULL, 0);
+  return radar_wait_ack(CMD_DISABLE_CONF, ack, sizeof(ack), &ack_len, 1200);
+}
+
+static bool radar_read_version(char *out, size_t out_sz) {
+  uint8_t ack[96];
+  uint16_t ack_len = 0;
+  radar_write_frame(CMD_READ_VERSION, NULL, 0);
+  if (!radar_wait_ack(CMD_READ_VERSION, ack, sizeof(ack), &ack_len, 1500)) return false;
+  if (ack_len < 13) return false;
+  uint8_t ver_len = ack[10];
+  if (ver_len == 0 || (uint16_t)(12 + ver_len) > ack_len - 4) {
+    /* some firmwares put ASCII after error word without length prefix */
+    size_t n = 0;
+    for (uint16_t i = 10; i + 4 < ack_len && n + 1 < out_sz; i++) {
+      char c = (char)ack[i];
+      if (c < 32 || c > 126) break;
+      out[n++] = c;
+    }
+    out[n] = '\0';
+    return n > 0;
+  }
+  if (ver_len >= out_sz) ver_len = (uint8_t)(out_sz - 1);
+  memcpy(out, &ack[12], ver_len);
+  out[ver_len] = '\0';
+  return true;
+}
+
+static bool radar_set_mode(uint16_t mode) {
+  uint8_t data[8];
+  memcpy(&data[0], &SYS_MODE_PARAM, 2);
+  uint32_t m = mode;
+  memcpy(&data[2], &m, 4);
+  radar_write_frame(CMD_WRITE_SYS, data, 6);
+  uint8_t ack[64];
+  uint16_t ack_len = 0;
+  return radar_wait_ack(CMD_WRITE_SYS, ack, sizeof(ack), &ack_len, 1200);
+}
+
+static bool radar_probe_at_baud(uint32_t baud) {
+  Serial.printf("LD2420 probe @ %lu baud RX=%d TX=%d\n",
+                (unsigned long)baud, LD2420_RX_PIN, LD2420_TX_PIN);
+  RadarSerial.end();
+  delay(20);
+  RadarSerial.begin(baud, SERIAL_8N1, LD2420_RX_PIN, LD2420_TX_PIN);
+  delay(80);
+  radar_flush();
+
+  if (!radar_enable_config(true)) {
+    Serial.println("  enable config FAIL");
+    return false;
+  }
+
+  char ver[24] = {0};
+  bool got = radar_read_version(ver, sizeof(ver));
+  if (!got) {
+    Serial.println("  read version FAIL");
+    radar_enable_config(false);
+    return false;
+  }
+
+  strncpy(fw_version, ver, sizeof(fw_version) - 1);
+  fw_version[sizeof(fw_version) - 1] = '\0';
+  fw_ok = true;
+  radar_baud = baud;
+
+  /* Simple text ON/OFF is more reliable for presence; energy optional later */
+  energy_mode = false;
+  Serial.printf("  FW=%s  mode=simple\n", fw_version);
+  (void)fw_to_int(fw_version);
+
+  radar_apply_detection_window();
+
+  if (!radar_set_mode(MODE_SIMPLE)) {
+    Serial.println("  set mode FAIL (continue with default)");
+  }
+
+  radar_enable_config(false);
+  radar_flush();
+  return true;
+}
+
+static bool radar_init(void) {
+  static const uint32_t bauds[] = {115200, 256000};
+  for (uint8_t i = 0; i < 2; i++) {
+    if (radar_probe_at_baud(bauds[i])) return true;
+  }
+  /* last resort: open 115200 and hope for simple-mode text */
+  RadarSerial.begin(115200, SERIAL_8N1, LD2420_RX_PIN, LD2420_TX_PIN);
+  radar_baud = 115200;
+  energy_mode = false;
+  strncpy(fw_version, "N/A", sizeof(fw_version) - 1);
+  fw_ok = false;
+  Serial.println("LD2420: no ACK — listening for simple-mode text");
+  return false;
+}
+
+/*
+ * Trust module ON/OFF. Module already applies presence_timeout for still/leave.
+ * Extra software hold only bridges brief UART glitches (not for filtering people out).
+ */
+static void set_occupied(bool on, float cm) {
+  bool was = presence;
+  uint32_t now = millis();
+
+  if (on) {
+    last_seen_ms = now;
+    presence = true;
+    if (!was) {
+      presence_since_ms = now;
+      Serial.println("UI: OCCUPIED");
+    }
+    if (!isnan(cm) && cm > 0.0f) {
+      disp_dist = cm;
+      if (isnan(min_dist) || cm < min_dist) min_dist = cm;
+      if (isnan(max_dist) || cm > max_dist) max_dist = cm;
+    }
+  } else {
+    /* Module said OFF — clear immediately (timeout already elapsed on radar) */
+    presence = false;
+    presence_since_ms = 0;
+    disp_dist = 0.0f;
+    if (was) Serial.println("UI: CLEAR");
+  }
+
+  sensor_ok = true;
+  last_ok_ms = now;
+}
+
+static void handle_simple_line(const uint8_t *inbuf, int len) {
+  /* Lines: "ON", "OFF", "Range 123" */
+  while (len > 0 && (inbuf[len - 1] == '\r' || inbuf[len - 1] == '\n' || inbuf[len - 1] == 0)) {
+    len--;
+  }
+  if (len <= 0) return;
+
+  char line[48];
+  uint8_t n = (len < (int)sizeof(line) - 1) ? (uint8_t)len : (uint8_t)(sizeof(line) - 1);
+  memcpy(line, inbuf, n);
+  line[n] = '\0';
+
+  if (n == 3 && line[0] == 'O' && line[1] == 'F' && line[2] == 'F') {
+    set_occupied(false, NAN);
+    return;
+  }
+  if (n == 2 && line[0] == 'O' && line[1] == 'N') {
+    set_occupied(true, disp_dist); /* keep last range until Range line updates */
+    return;
+  }
+
+  if (n >= 6 && strncmp(line, "Range", 5) == 0) {
+    const char *p = line + 5;
+    while (*p == ' ' || *p == '\t') p++;
+    if (*p >= '0' && *p <= '9') {
+      float cm = (float)strtol(p, NULL, 10);
+      /* Range with value implies target; latch occupied + distance */
+      set_occupied(true, cm);
+    }
+    return;
+  }
+}
+
+static void handle_energy_frame(const uint8_t *buf, int len) {
+  if (len < 6 + 1 + 2 + 4) return;
+  uint8_t index = 6;
+  bool present = (buf[index++] == 1);
+  uint16_t range = 0;
+  memcpy(&range, &buf[index], 2);
+  if (range > 2000) return;
+  set_occupied(present, present ? (float)range : NAN);
+}
+
+static void radar_poll(void) {
+  while (RadarSerial.available()) {
+    int b = RadarSerial.read();
+    if (b < 0) break;
+    if (rx_pos >= sizeof(rx_buf) - 1) rx_pos = 0;
+    rx_buf[rx_pos++] = (uint8_t)b;
+    rx_buf[rx_pos] = 0;
+
+    if (rx_pos < 4) continue;
+
+    /* discard command ACK frames */
+    if (memcmp(&rx_buf[rx_pos - 4], CMD_FTR_B, 4) == 0) {
+      rx_pos = 0;
+      continue;
+    }
+
+    if (energy_mode && memcmp(&rx_buf[rx_pos - 4], ENERGY_FTR_B, 4) == 0) {
+      for (int i = (int)rx_pos - 4; i >= 0; i--) {
+        if (memcmp(&rx_buf[i], ENERGY_HDR_B, 4) == 0) {
+          handle_energy_frame(&rx_buf[i], rx_pos - (uint16_t)i);
+          break;
+        }
+      }
+      rx_pos = 0;
+      continue;
+    }
+
+    if (rx_pos >= 2 && rx_buf[rx_pos - 2] == 0x0D && rx_buf[rx_pos - 1] == 0x0A) {
+      handle_simple_line(rx_buf, rx_pos);
+      rx_pos = 0;
+    }
+  }
+}
+
+/* ---- UI ---- */
+
+static void create_ui(void) {
+  lv_obj_t *scr = lv_screen_active();
+  lv_obj_set_style_bg_color(scr, COL_BG, 0);
+  lv_obj_set_style_bg_opa(scr, LV_OPA_COVER, 0);
+  lv_obj_clear_flag(scr, LV_OBJ_FLAG_SCROLLABLE);
+
+  lv_obj_t *title = lv_label_create(scr);
+  lv_label_set_text(title, "RADAR");
+  lv_obj_set_style_text_font(title, &lv_font_montserrat_14, 0);
+  lv_obj_set_style_text_color(title, COL_TEXT, 0);
+  lv_obj_set_pos(title, UI_M, 4);
+
+  lbl_uptime = lv_label_create(scr);
+  lv_label_set_text(lbl_uptime, "up 00:00");
+  lv_obj_set_style_text_font(lbl_uptime, &lv_font_montserrat_12, 0);
+  lv_obj_set_style_text_color(lbl_uptime, COL_MUTED, 0);
+  lv_obj_align_to(lbl_uptime, title, LV_ALIGN_OUT_RIGHT_MID, 8, 1);
+
+  led_status = lv_led_create(scr);
+  lv_obj_set_size(led_status, 9, 9);
+  lv_obj_align(led_status, LV_ALIGN_TOP_RIGHT, -UI_M, 6);
+  lv_led_set_color(led_status, COL_WARN);
+  lv_led_on(led_status);
+
+  lbl_status = lv_label_create(scr);
+  lv_label_set_text(lbl_status, "INIT");
+  lv_obj_set_style_text_font(lbl_status, &lv_font_montserrat_12, 0);
+  lv_obj_set_style_text_color(lbl_status, COL_MUTED, 0);
+  lv_obj_align(lbl_status, LV_ALIGN_TOP_RIGHT, -(UI_M + 16), 4);
+
+  lbl_hint = lv_label_create(scr);
+  lv_label_set_text(lbl_hint, "");
+  lv_obj_set_style_text_font(lbl_hint, &lv_font_montserrat_12, 0);
+  lv_obj_set_style_text_color(lbl_hint, COL_WARN, 0);
+  lv_obj_set_style_bg_color(lbl_hint, COL_BG, 0);
+  lv_obj_set_style_bg_opa(lbl_hint, LV_OPA_COVER, 0);
+  lv_obj_set_style_pad_hor(lbl_hint, 6, 0);
+  lv_obj_align(lbl_hint, LV_ALIGN_TOP_MID, 0, 4);
+  lv_obj_add_flag(lbl_hint, LV_OBJ_FLAG_HIDDEN);
+
+  const int gy = UI_HDR_H + UI_G;
+
+  lv_obj_t *p_dist = make_panel(scr, UI_M, gy, UI_GAUGE_W, UI_GAUGE_H);
+  lv_obj_t *d_cap = lv_label_create(p_dist);
+  lv_label_set_text(d_cap, "DIST");
+  lv_obj_set_style_text_font(d_cap, &lv_font_montserrat_12, 0);
+  lv_obj_set_style_text_color(d_cap, COL_MUTED, 0);
+  lv_obj_align(d_cap, LV_ALIGN_TOP_LEFT, 0, -2);
+
+  arc_dist = make_gauge(p_dist, COL_DIST, DIST_ARC_MAX);
+  lbl_dist_val = lv_label_create(p_dist);
+  lv_label_set_text(lbl_dist_val, "---");
+  lv_obj_set_style_text_font(lbl_dist_val, &lv_font_montserrat_24, 0);
+  lv_obj_set_style_text_color(lbl_dist_val, COL_DIST, 0);
+  lv_obj_align(lbl_dist_val, LV_ALIGN_TOP_MID, -6, 32);
+
+  lv_obj_t *d_unit = lv_label_create(p_dist);
+  lv_label_set_text(d_unit, "cm");
+  lv_obj_set_style_text_font(d_unit, &lv_font_montserrat_12, 0);
+  lv_obj_set_style_text_color(d_unit, COL_MUTED, 0);
+  lv_obj_align_to(d_unit, lbl_dist_val, LV_ALIGN_OUT_RIGHT_MID, 2, 2);
+
+  lbl_dist_range = lv_label_create(p_dist);
+  lv_label_set_text(lbl_dist_range, "-- / --");
+  lv_obj_set_style_text_font(lbl_dist_range, &lv_font_montserrat_12, 0);
+  lv_obj_set_style_text_color(lbl_dist_range, COL_MUTED, 0);
+  lv_obj_align(lbl_dist_range, LV_ALIGN_BOTTOM_MID, 0, 2);
+
+  lv_obj_t *p_pres = make_panel(scr, UI_M + UI_GAUGE_W + UI_G, gy, UI_GAUGE_W, UI_GAUGE_H);
+  lv_obj_t *p_cap = lv_label_create(p_pres);
+  lv_label_set_text(p_cap, "PRESENCE");
+  lv_obj_set_style_text_font(p_cap, &lv_font_montserrat_12, 0);
+  lv_obj_set_style_text_color(p_cap, COL_MUTED, 0);
+  lv_obj_align(p_cap, LV_ALIGN_TOP_LEFT, 0, -2);
+
+  arc_pres = make_gauge(p_pres, COL_PRES, 100);
+  lbl_pres_val = lv_label_create(p_pres);
+  lv_label_set_text(lbl_pres_val, "----");
+  lv_obj_set_style_text_font(lbl_pres_val, &lv_font_montserrat_20, 0);
+  lv_obj_set_style_text_color(lbl_pres_val, COL_MUTED, 0);
+  lv_obj_align(lbl_pres_val, LV_ALIGN_TOP_MID, 0, 34);
+
+  lbl_pres_hint = lv_label_create(p_pres);
+  lv_label_set_text(lbl_pres_hint, "waiting");
+  lv_obj_set_style_text_font(lbl_pres_hint, &lv_font_montserrat_12, 0);
+  lv_obj_set_style_text_color(lbl_pres_hint, COL_MUTED, 0);
+  lv_obj_align(lbl_pres_hint, LV_ALIGN_BOTTOM_MID, 0, 2);
+
+  lv_obj_t *p_bot = make_panel(scr, UI_M, UI_BOT_Y, UI_BOT_W, UI_BOT_H);
+
+  lv_obj_t *info = lv_obj_create(p_bot);
+  lv_obj_set_size(info, UI_INFO_W, UI_BOT_H - 12);
+  lv_obj_align(info, LV_ALIGN_LEFT_MID, 0, 0);
+  lv_obj_set_style_bg_opa(info, LV_OPA_TRANSP, 0);
+  lv_obj_set_style_border_width(info, 0, 0);
+  lv_obj_set_style_pad_all(info, 0, 0);
+  lv_obj_clear_flag(info, LV_OBJ_FLAG_SCROLLABLE);
+
+  lbl_state = lv_label_create(info);
+  lv_label_set_text(lbl_state, "WAIT");
+  lv_obj_set_style_text_font(lbl_state, &lv_font_montserrat_14, 0);
+  lv_obj_set_style_text_color(lbl_state, COL_WARN, 0);
+  lv_obj_set_width(lbl_state, UI_INFO_W);
+  lv_label_set_long_mode(lbl_state, LV_LABEL_LONG_CLIP);
+  lv_obj_align(lbl_state, LV_ALIGN_TOP_LEFT, 0, 0);
+
+  bar_presence = lv_bar_create(info);
+  lv_obj_set_size(bar_presence, UI_INFO_W - 4, 8);
+  lv_obj_align(bar_presence, LV_ALIGN_TOP_LEFT, 0, 20);
+  lv_bar_set_range(bar_presence, 0, 100);
+  lv_bar_set_value(bar_presence, 0, LV_ANIM_OFF);
+  lv_obj_set_style_bg_color(bar_presence, COL_ARC_BG, LV_PART_MAIN);
+  lv_obj_set_style_bg_opa(bar_presence, LV_OPA_COVER, LV_PART_MAIN);
+  lv_obj_set_style_radius(bar_presence, 4, LV_PART_MAIN);
+  lv_obj_set_style_bg_color(bar_presence, COL_WARN, LV_PART_INDICATOR);
+  lv_obj_set_style_radius(bar_presence, 4, LV_PART_INDICATOR);
+
+  lbl_fw = lv_label_create(info);
+  lv_label_set_text(lbl_fw, "FW ----");
+  lv_obj_set_style_text_font(lbl_fw, &lv_font_montserrat_12, 0);
+  lv_obj_set_style_text_color(lbl_fw, COL_TEXT, 0);
+  lv_obj_set_width(lbl_fw, UI_INFO_W);
+  lv_label_set_long_mode(lbl_fw, LV_LABEL_LONG_CLIP);
+  lv_obj_align(lbl_fw, LV_ALIGN_TOP_LEFT, 0, 34);
+
+  lbl_baud = lv_label_create(info);
+  lv_label_set_text(lbl_baud, "UART --");
+  lv_obj_set_style_text_font(lbl_baud, &lv_font_montserrat_12, 0);
+  lv_obj_set_style_text_color(lbl_baud, COL_MUTED, 0);
+  lv_obj_set_width(lbl_baud, UI_INFO_W);
+  lv_label_set_long_mode(lbl_baud, LV_LABEL_LONG_CLIP);
+  lv_obj_align(lbl_baud, LV_ALIGN_TOP_LEFT, 0, 48);
+
+  chart = lv_chart_create(p_bot);
+  lv_obj_set_size(chart, UI_CHART_W, UI_BOT_H - 16);
+  lv_obj_align(chart, LV_ALIGN_RIGHT_MID, 0, 0);
+  lv_chart_set_type(chart, LV_CHART_TYPE_LINE);
+  lv_chart_set_point_count(chart, HISTORY_LEN);
+  lv_chart_set_range(chart, LV_CHART_AXIS_PRIMARY_Y, 0, DIST_ARC_MAX);
+  lv_chart_set_range(chart, LV_CHART_AXIS_SECONDARY_Y, 0, 100);
+  lv_chart_set_update_mode(chart, LV_CHART_UPDATE_MODE_SHIFT);
+  lv_obj_set_style_bg_color(chart, COL_CHART_BG, 0);
+  lv_obj_set_style_bg_opa(chart, LV_OPA_COVER, 0);
+  lv_obj_set_style_border_color(chart, COL_EDGE, 0);
+  lv_obj_set_style_border_width(chart, 1, 0);
+  lv_obj_set_style_radius(chart, 8, 0);
+  lv_obj_set_style_pad_all(chart, 4, 0);
+  lv_obj_set_style_line_width(chart, 2, LV_PART_ITEMS);
+  lv_chart_set_div_line_count(chart, 2, 4);
+  lv_obj_set_style_line_color(chart, COL_EDGE, LV_PART_MAIN);
+  lv_obj_set_style_line_opa(chart, LV_OPA_40, LV_PART_MAIN);
+  ser_dist = lv_chart_add_series(chart, COL_DIST, LV_CHART_AXIS_PRIMARY_Y);
+  ser_pres = lv_chart_add_series(chart, COL_PRES, LV_CHART_AXIS_SECONDARY_Y);
+
+  lv_obj_move_foreground(title);
+  lv_obj_move_foreground(lbl_uptime);
+  lv_obj_move_foreground(lbl_status);
+  lv_obj_move_foreground(led_status);
+  lv_obj_move_foreground(lbl_hint);
+}
+
+static void refresh_meta(void) {
+  char buf[48];
+  uint32_t up = millis() / 1000;
+  lv_snprintf(buf, sizeof(buf), "up %02lu:%02lu  bl%u",
+              (unsigned long)(up / 60), (unsigned long)(up % 60), (unsigned)bright_level);
+  lv_label_set_text(lbl_uptime, buf);
+
+  if (hint_until_ms && (int32_t)(millis() - hint_until_ms) >= 0) {
+    hint_until_ms = 0;
+    lv_obj_add_flag(lbl_hint, LV_OBJ_FLAG_HIDDEN);
+  }
+
+  if (sensor_ok && (millis() - last_ok_ms) < SENSOR_STALE_MS) {
+    uint32_t age = (millis() - last_ok_ms) / 1000;
+    lv_snprintf(buf, sizeof(buf), "LIVE %lus", (unsigned long)age);
+    lv_label_set_text(lbl_status, buf);
+    lv_led_set_color(led_status, presence ? COL_PRES : COL_OK);
+  } else if (fw_ok) {
+    lv_label_set_text(lbl_status, "IDLE");
+    lv_led_set_color(led_status, COL_WARN);
+  } else {
+    lv_label_set_text(lbl_status, "NO LINK");
+    lv_led_set_color(led_status, COL_BAD);
+  }
+}
+
+static void update_ui(void) {
+  char buf[40];
+
+  lv_snprintf(buf, sizeof(buf), "FW %s", fw_version);
+  lv_label_set_text(lbl_fw, buf);
+  lv_obj_set_style_text_color(lbl_fw, fw_ok ? COL_TEXT : COL_BAD, 0);
+
+  lv_snprintf(buf, sizeof(buf), "%lu %s", (unsigned long)radar_baud,
+              energy_mode ? "E" : "S");
+  lv_label_set_text(lbl_baud, buf);
+
+  if (!sensor_ok && !fw_ok) {
+    lv_label_set_text(lbl_state, "NO LINK");
+    lv_obj_set_style_text_color(lbl_state, COL_BAD, 0);
+    lv_label_set_text(lbl_pres_val, "----");
+    lv_obj_set_style_text_color(lbl_pres_val, COL_MUTED, 0);
+    anim_bar(bar_presence, 0);
+    refresh_meta();
+    return;
+  }
+
+  if (presence) {
+    lv_label_set_text(lbl_state, "OCCUPIED");
+    lv_obj_set_style_text_color(lbl_state, COL_PRES, 0);
+    lv_label_set_text(lbl_pres_val, "ON");
+    lv_obj_set_style_text_color(lbl_pres_val, COL_PRES, 0);
+    anim_arc(arc_pres, 100);
+    anim_bar(bar_presence, 100);
+    lv_obj_set_style_bg_color(bar_presence, COL_PRES, LV_PART_INDICATOR);
+    if (presence_since_ms) {
+      uint32_t sec = (millis() - presence_since_ms) / 1000;
+      lv_snprintf(buf, sizeof(buf), "held %lus", (unsigned long)sec);
+      lv_label_set_text(lbl_pres_hint, buf);
+    }
+  } else {
+    lv_label_set_text(lbl_state, "CLEAR");
+    lv_obj_set_style_text_color(lbl_state, COL_MUTED, 0);
+    lv_label_set_text(lbl_pres_val, "OFF");
+    lv_obj_set_style_text_color(lbl_pres_val, COL_MUTED, 0);
+    anim_arc(arc_pres, 0);
+    anim_bar(bar_presence, 0);
+    lv_obj_set_style_bg_color(bar_presence, COL_MUTED, LV_PART_INDICATOR);
+    lv_label_set_text(lbl_pres_hint, "no target");
+  }
+
+  if (!isnan(disp_dist)) {
+    lv_color_t dc = dist_color(disp_dist);
+    lv_snprintf(buf, sizeof(buf), "%.0f", disp_dist);
+    lv_label_set_text(lbl_dist_val, buf);
+    lv_obj_set_style_text_color(lbl_dist_val, dc, 0);
+    lv_obj_set_style_arc_color(arc_dist, dc, LV_PART_INDICATOR);
+    anim_arc(arc_dist, (int)lroundf(constrain(disp_dist, 0.0f, (float)DIST_ARC_MAX)));
+
+    if (!isnan(min_dist) && !isnan(max_dist)) {
+      lv_snprintf(buf, sizeof(buf), "%.0f / %.0f", min_dist, max_dist);
+      lv_label_set_text(lbl_dist_range, buf);
+    }
+  }
+
+  uint32_t now = millis();
+  if (now - last_chart_ms >= CHART_PUSH_MS) {
+    last_chart_ms = now;
+    int32_t d = isnan(disp_dist) ? 0 : (int32_t)lroundf(constrain(disp_dist, 0.0f, (float)DIST_ARC_MAX));
+    lv_chart_set_next_value(chart, ser_dist, d);
+    lv_chart_set_next_value(chart, ser_pres, presence ? 100 : 0);
+  }
+
+  refresh_meta();
+}
+
+void setup() {
+  Serial.begin(115200);
+  delay(200);
+
+  ledcSetup(0, 5000, 8);
+  ledcAttachPin(TFT_BL_PIN, 0);
+  set_backlight(2);
+
+  Serial.println("CYD LVGL LD2420 Radar Dashboard");
+  Serial.printf("LVGL %d.%d.%d  OT1->GPIO%d  RX->GPIO%d\n",
+                lv_version_major(), lv_version_minor(), lv_version_patch(),
+                LD2420_RX_PIN, LD2420_TX_PIN);
+
+  lv_init();
+
+  touchscreenSPI.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
+  touchscreen.begin(touchscreenSPI);
+  touchscreen.setRotation(2);
+
+  lv_display_t *disp = lv_tft_espi_create(240, 320, draw_buf, sizeof(draw_buf));
+  lv_display_set_rotation(disp, LV_DISPLAY_ROTATION_270);
+
+  lv_indev_t *indev = lv_indev_create();
+  lv_indev_set_type(indev, LV_INDEV_TYPE_POINTER);
+  lv_indev_set_read_cb(indev, touchscreen_read);
+
+  create_ui();
+
+  bool linked = radar_init();
+  if (linked) {
+    char hint[32];
+    lv_snprintf(hint, sizeof(hint), "FW %s", fw_version);
+    show_hint(hint, 2000);
+  } else {
+    show_hint("radar no ACK", 2500);
+  }
+  update_ui();
+}
+
+void loop() {
+  radar_poll();
+
+  uint32_t now = millis();
+  if (now - last_ui_ms >= UI_REFRESH_MS) {
+    last_ui_ms = now;
+    update_ui();
+  }
+
+  static uint32_t last_meta_ms = 0;
+  if (now - last_meta_ms >= 1000) {
+    last_meta_ms = now;
+    refresh_meta();
+  }
+
+  if (now - last_dbg_ms >= 1000) {
+    last_dbg_ms = now;
+    Serial.printf("pres=%s dist=%.0f cm  FW=%s\n",
+                  presence ? "ON" : "OFF",
+                  isnan(disp_dist) ? -1.0f : disp_dist,
+                  fw_version);
+  }
+
+  lv_timer_handler();
+  lv_tick_inc(5);
+  delay(5);
+}