Add INMP441 WAV recorder for CYD 2.8/3.5.

Record 16 kHz mono PCM to microSD /rec, with level meter and DAC2 playback. Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-27 21:16:13 +08:00
commit ddff48d05b
33 changed files with 1975 additions and 0 deletions
--- 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,88 @@
+# CYD INMP441 录音
+
+ESP32 Cheap Yellow Display + INMP441（I2S）→ microSD **WAV 录音**，支持 DAC 回放。
+
+默认 **2.8" ESP32-2432S028R**；可选 **3.5" ESP32-3248S035C**（`cyd_35r`）。  
+引脚约定见同目录 [CYD_PROJECT_GUIDE.md](../CYD_PROJECT_GUIDE.md)；麦克风接线参考 [inmp441test](../inmp441test)。
+
+## 硬件
+
+| 项目 | 2.8" · 2432S028R | 3.5" C · 3248S035C |
+|------|------------------|---------------------|
+| 屏驱 | ILI9341 | ST7796 |
+| 触控 | XPT2046 SoftSPI | GT911 Wire1（SDA33/SCL32/INT21/RST25） |
+| 背光 TFT_BL | **GPIO21** | **GPIO27** |
+| INMP441 WS | **GPIO22**（CN1/P3） | **GPIO22** |
+| INMP441 SCK | **GPIO27**（CN1） | **GPIO21**（CN1；勿占 27=BL） |
+| INMP441 SD | **GPIO35**（P3，仅输入） | **GPIO35** |
+| microSD | CS5 / SCK18 / MISO19 / MOSI23 | 同左 |
+| 喇叭 | **GPIO26**（DAC2，P4） | 同左 |
+
+接线：
+
+| INMP441 | CYD |
+|---------|-----|
+| VDD | 3.3V（CN1） |
+| GND | GND |
+| L/R | GND（左声道，勿悬空） |
+| WS | IO22 |
+| SCK | IO27（2.8）/ IO21（3.5） |
+| SD | IO35（P3） |
+
+> 不要接 5V；不要占用背光脚。I2S 需要三根信号线（22 + 27/21 + 35）。  
+> **3.5C**：`SCK=GPIO21` 与 GT911 INT 同脚；固件先完成触控选址，再把 21 交给 I2S，触控仅轮询。
+
+## 功能
+
+- 触控 **REC / STOP**：录制 16 kHz / 16-bit 单声道 PCM WAV 到 `/rec/Rxxxx.WAV`
+- 最长约 **120 秒**（自动停）
+- 实时电平条（近似 dB，与 inmp441test 同一换算）
+- **PLAY / STOP**：用板载喇叭（GPIO26）回放最近一条录音
+- 短按顶部标题栏切换背光 4 档
+- 需插入 **FAT32 microSD**
+
+## 构建与烧录
+
+依赖 [PlatformIO](https://platformio.org/)。
+
+```bash
+pio run -e cyd_28r -t upload          # 2.8"
+pio run -e cyd_35r -t upload          # 3.5C
+pio device monitor -b 115200
+```
+
+### 预编译固件
+
+| 板型 | 目录 |
+|------|------|
+| 2.8" | [`firmware/cyd_28r/`](firmware/cyd_28r/) |
+| 3.5" | [`firmware/cyd_35r/`](firmware/cyd_35r/) |
+
+```powershell
+cd firmware\cyd_28r   # 或 cyd_35r
+.\flash.ps1
+```
+
+重新打包：
+
+```powershell
+.\firmware\export_from_build.ps1
+.\firmware\export_from_build.ps1 -Env cyd_35r
+```
+
+## 项目结构
+
+```
+platformio.ini
+include/pins.h lv_conf.h touch.h sdcard.h recorder.h player.h
+src/main.cpp touch.cpp sdcard.cpp recorder.cpp player.cpp
+scripts/exclude_lvgl_asm.py
+firmware/
+README.md
+```
+
+## 变更记录
+
+| 日期 | 说明 |
+|------|------|
+| 2026-10-27 | 初版：INMP441 → microSD WAV 录音 + DAC 回放；双板 `cyd_28r` / `cyd_35r` |
--- a/firmware/README.md
+++ b/firmware/README.md
@@ -0,0 +1,26 @@
+# 预编译固件（可随时刷写）
+
+| 目录 | 板子 | INMP441 | 背光 |
+|------|------|---------|------|
+| [`cyd_28r/`](cyd_28r/) | ESP32-2432S028R（ILI9341） | WS=22 / SCK=27 / SD=35 | GPIO21 |
+| [`cyd_35r/`](cyd_35r/) | ESP32-3248S035C（ST7796 + GT911） | WS=22 / SCK=21 / SD=35 | GPIO27 |
+
+版本信息见各目录 `VERSION.txt`。引脚约定见 [`../CYD_PROJECT_GUIDE.md`](../../CYD_PROJECT_GUIDE.md)。
+
+录音写入 microSD `/rec/Rxxxx.WAV`；回放经 GPIO26 DAC2。
+
+## 直接刷写
+
+```powershell
+cd firmware\cyd_28r   # 或 cyd_35r
+.\flash.ps1
+# .\flash.ps1 -Port COM3
+```
+
+## 从源码重新打包
+
+```powershell
+.\firmware\export_from_build.ps1
+.\firmware\export_from_build.ps1 -Env cyd_35r
+.\firmware\export_from_build.ps1 -SkipBuild
+```
--- a/firmware/cyd_28r/VERSION.txt
+++ b/firmware/cyd_28r/VERSION.txt
@@ -0,0 +1,18 @@
+name: CYD inmp441recondtest (cyd_28r)
+git: unknown
+date: 2026-10-27
+board: ESP32-2432S028R (ILI9341)
+inmp441: WS=GPIO22 SCK=GPIO27 SD=GPIO35
+tft_bl: GPIO21
+audio: record WAV /rec + play DAC2 GPIO26
+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    8BDD28C452BF7406295B7E76FDC387917FE6BF223BE0FD18B6988BABD4EFF12E
+  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 INMP441 WAV recorder 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/meta.json
+++ b/firmware/cyd_28r/meta.json
@@ -0,0 +1,7 @@
+{
+  "boardId": "esp32-2432s028",
+  "name": "CYD INMP441 WAV recorder",
+  "summary": "Record INMP441 audio to microSD as WAV; play via DAC2",
+  "description": "INMP441 on WS=GPIO22 / SCK=GPIO27 / SD=GPIO35. Saves 16 kHz mono PCM to /rec/Rxxxx.WAV. Playback on GPIO26. Requires FAT32 microSD.",
+  "tags": ["record", "inmp441", "i2s", "wav", "sd", "mic"]
+}
--- a/firmware/cyd_28r/partitions.bin
+++ b/firmware/cyd_28r/partitions.bin
--- a/firmware/cyd_35r/VERSION.txt
+++ b/firmware/cyd_35r/VERSION.txt
@@ -0,0 +1,18 @@
+name: CYD inmp441recondtest (cyd_35r)
+git: unknown
+date: 2026-10-27
+board: ESP32-3248S035 (ST7796 + GT911)
+inmp441: WS=GPIO22 SCK=GPIO21 SD=GPIO35
+tft_bl: GPIO27
+audio: record WAV /rec + play DAC2 GPIO26
+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    0AFB4B303FDC198E8216D0BEEEC1BC8C9776E7BAE21FC798C4861C2FB2F6B0AC
+  partitions.bin  0A8B5720E7B77FF11F1462458C3A509DEE79224E5279898F26D6A2E3AE0517B7
--- a/firmware/cyd_35r/boot_app0.bin
+++ b/firmware/cyd_35r/boot_app0.bin
--- a/firmware/cyd_35r/bootloader.bin
+++ b/firmware/cyd_35r/bootloader.bin
--- a/firmware/cyd_35r/firmware.bin
+++ b/firmware/cyd_35r/firmware.bin
--- a/firmware/cyd_35r/flash.bat
+++ b/firmware/cyd_35r/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_35r/flash.ps1
+++ b/firmware/cyd_35r/flash.ps1
@@ -0,0 +1,84 @@
+# Flash archived CYD INMP441 WAV recorder firmware for 3.5C (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_35r/meta.json
+++ b/firmware/cyd_35r/meta.json
@@ -0,0 +1,7 @@
+{
+  "boardId": "esp32-3248s035",
+  "name": "CYD INMP441 WAV recorder (3.5C)",
+  "summary": "Record INMP441 audio to microSD as WAV; play via DAC2",
+  "description": "INMP441 on WS=GPIO22 / SCK=GPIO21 / SD=GPIO35. TFT_BL=27. Saves 16 kHz mono PCM to /rec/Rxxxx.WAV. Playback on GPIO26. Requires FAT32 microSD.",
+  "tags": ["record", "inmp441", "i2s", "wav", "sd", "mic", "3.5"]
+}
--- a/firmware/cyd_35r/partitions.bin
+++ b/firmware/cyd_35r/partitions.bin
--- a/firmware/export_from_build.ps1
+++ b/firmware/export_from_build.ps1
@@ -0,0 +1,74 @@
+# Export firmware bins from PlatformIO build.
+# Default: 2.8" (cyd_28r -> firmware/cyd_28r)
+# 3.5":    .\firmware\export_from_build.ps1 -Env cyd_35r
+
+param(
+  [switch]$SkipBuild,
+  [ValidateSet("cyd_28r", "cyd_35r")]
+  [string]$Env = "cyd_28r"
+)
+
+$ErrorActionPreference = "Stop"
+$root = Split-Path -Parent (Split-Path -Parent $MyInvocation.MyCommand.Path)
+Set-Location $root
+
+$env:Path = "C:\Users\dsx2016\AppData\Local\Programs\Python\Python312\Scripts;" + $env:Path
+
+if (-not $SkipBuild) {
+  pio run -e $Env
+  if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+}
+
+$src = Join-Path $root (".pio\build\" + $Env)
+if ($Env -eq "cyd_35r") {
+  $dstName = "cyd_35r"
+  $boardLine = "board: ESP32-3248S035 (ST7796 + GT911)"
+  $micLine = "inmp441: WS=GPIO22 SCK=GPIO21 SD=GPIO35"
+  $blLine = "tft_bl: GPIO27"
+} else {
+  $dstName = "cyd_28r"
+  $boardLine = "board: ESP32-2432S028R (ILI9341)"
+  $micLine = "inmp441: WS=GPIO22 SCK=GPIO27 SD=GPIO35"
+  $blLine = "tft_bl: GPIO21"
+}
+$dst = Join-Path $root ("firmware\" + $dstName)
+New-Item -ItemType Directory -Force -Path $dst | Out-Null
+
+foreach ($f in @("bootloader.bin", "partitions.bin", "firmware.bin")) {
+  $p = Join-Path $src $f
+  if (-not (Test-Path $p)) { Write-Error "Missing build artifact: $p — build with: pio run -e $Env" }
+  Copy-Item $p $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 = ""
+try { $git = (git -C $root rev-parse --short HEAD).Trim() } catch { $git = "unknown" }
+$date = Get-Date -Format "yyyy-MM-dd"
+$hashes = Get-ChildItem (Join-Path $dst "*.bin") | Get-FileHash -Algorithm SHA256
+$lines = @(
+  "name: CYD inmp441recondtest ($dstName)",
+  "git: $git",
+  "date: $date",
+  $boardLine,
+  $micLine,
+  $blLine,
+  "audio: record WAV /rec + play DAC2 GPIO26",
+  "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 (env=$Env 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/include/pins.h
+++ b/include/pins.h
@@ -0,0 +1,37 @@
+#pragma once
+
+/* CYD + INMP441 record pin truth — see ../CYD_PROJECT_GUIDE.md */
+
+#if defined(CYD_BOARD_3248S035)
+  /* 3.5C ESP32-3248S035C: BL=27; free peripheral pair is 22+21 */
+  #define TFT_BL_PIN 27
+  #define I2S_WS_PIN 22
+  #define I2S_SCK_PIN 21
+  #define I2S_SD_PIN 35
+  #define SCREEN_WIDTH 480
+  #define SCREEN_HEIGHT 320
+  #define CYD_GT911_SDA 33
+  #define CYD_GT911_SCL 32
+  #define CYD_GT911_INT 21
+  #define CYD_GT911_RST 25
+#else
+  /* 2.8 ESP32-2432S028R: BL=21; free peripheral pair is 22+27; SD on P3 IO35 */
+  #define TFT_BL_PIN 21
+  #define I2S_WS_PIN 22
+  #define I2S_SCK_PIN 27
+  #define I2S_SD_PIN 35
+  #define SCREEN_WIDTH 320
+  #define SCREEN_HEIGHT 240
+  #define CYD_TOUCH_IRQ 36
+  #define CYD_TOUCH_MOSI 32
+  #define CYD_TOUCH_MISO 39
+  #define CYD_TOUCH_CLK 25
+  #define CYD_TOUCH_CS 33
+#endif
+
+/* On-board microSD (VSPI) + speaker amp (DAC2 only — never GPIO25) */
+#define SD_MISO 19
+#define SD_MOSI 23
+#define SD_SCK 18
+#define SD_CS 5
+#define SPEAKER_PIN 26
--- a/include/player.h
+++ b/include/player.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <stdint.h>
+
+void player_init(void);
+bool player_play(const char *path);
+void player_stop(void);
+bool player_is_playing(void);
+const char *player_status(void);
+void player_tick(void); /* stream next chunk to DAC */
--- a/include/recorder.h
+++ b/include/recorder.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <stdint.h>
+
+#define REC_SAMPLE_RATE 16000
+#define REC_MAX_SECONDS 120
+
+bool recorder_mic_init(void);
+bool recorder_start(void);
+void recorder_stop(void);
+bool recorder_is_active(void);
+float recorder_level_db(void);          /* smoothed approx dBFS+offset, or NAN */
+uint32_t recorder_elapsed_ms(void);
+uint32_t recorder_bytes_written(void);
+const char *recorder_last_path(void);   /* e.g. /rec/R0003.WAV */
+const char *recorder_status(void);
+void recorder_tick(void);               /* call from loop; drains I2S → SD */
--- a/include/sdcard.h
+++ b/include/sdcard.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <stdint.h>
+
+bool sd_init(void);
+void sd_deinit(void);
+bool sd_ready(void);
+uint64_t sd_free_bytes(void);
+uint64_t sd_total_bytes(void);
--- a/include/touch.h
+++ b/include/touch.h
@@ -0,0 +1,6 @@
+#pragma once
+
+#include <lvgl.h>
+
+void touch_init();
+void touch_read_cb(lv_indev_t *indev, lv_indev_data_t *data);
--- a/platformio.ini
+++ b/platformio.ini
@@ -0,0 +1,90 @@
+; CYD LVGL INMP441 WAV recorder (microSD)
+; 2.8: WS=22 SCK=27 SD=35 BL=21; 3.5C: WS=22 SCK=21 SD=35 BL=27
+; see ../CYD_PROJECT_GUIDE.md
+[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
+
+; Optional 3.5" CYD ESP32-3248S035C (ST7796 + GT911 capacitive). Default remains cyd_28r.
+; Build: pio run -e cyd_35r
+; Keep TOUCH_CS=-1 — GPIO33 is GT911 SDA, not resistive touch CS.
+; TFT_BL=27 (not 21 — 21 is GT911 INT / I2S SCK). GT911 uses Wire1.
+[env:cyd_35r]
+lib_deps =
+  lvgl/lvgl@9.2.2
+  bodmer/TFT_eSPI@2.5.43
+build_flags =
+  ${env.build_flags}
+  -UILI9341_2_DRIVER
+  -DST7796_DRIVER=1
+  -UTFT_WIDTH
+  -UTFT_HEIGHT
+  -DTFT_WIDTH=320
+  -DTFT_HEIGHT=480
+  -UTFT_BL
+  -DTFT_BL=27
+  -DCYD_BOARD_3248S035=1
+  -DSUPPORT_TRANSACTIONS
+  -DTFT_RGB_ORDER=TFT_BGR
+  -ULV_MEM_SIZE
+  -DLV_MEM_SIZE=32768
--- 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,451 @@
+/**
+ * CYD LVGL INMP441 WAV recorder
+ * 2.8 (2432S028R): WS=22 SCK=27 SD=35, TFT_BL=21
+ * 3.5C (3248S035C): WS=22 SCK=21 SD=35, TFT_BL=27 — see ../CYD_PROJECT_GUIDE.md
+ *
+ * Record mono 16 kHz PCM WAV to microSD /rec/Rxxxx.WAV
+ * Playback via DAC2 GPIO26 only (never GPIO25).
+ */
+
+#include <Arduino.h>
+#include <lvgl.h>
+#include <TFT_eSPI.h>
+#include <math.h>
+#include <string.h>
+
+#include "pins.h"
+#include "touch.h"
+#include "sdcard.h"
+#include "recorder.h"
+#include "player.h"
+
+#if defined(CYD_BOARD_3248S035)
+#define DRAW_BUF_SIZE (SCREEN_WIDTH * SCREEN_HEIGHT / 20 * (LV_COLOR_DEPTH / 8))
+#else
+#define DRAW_BUF_SIZE (SCREEN_WIDTH * SCREEN_HEIGHT / 10 * (LV_COLOR_DEPTH / 8))
+#endif
+
+#if defined(CYD_BOARD_3248S035)
+#define UI_M 12
+#define UI_G 10
+#define UI_BTN_H 52
+#define UI_BAR_H 18
+#else
+#define UI_M 8
+#define UI_G 6
+#define UI_BTN_H 40
+#define UI_BAR_H 14
+#endif
+
+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_ACCENT = 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_REC = lv_color_hex(0xE04545);
+static const lv_color_t COL_ARC_BG = lv_color_hex(0x243247);
+
+static uint32_t draw_buf[DRAW_BUF_SIZE / 4];
+
+static lv_obj_t *lbl_status;
+static lv_obj_t *lbl_uptime;
+static lv_obj_t *lbl_hint;
+static lv_obj_t *lbl_time;
+static lv_obj_t *lbl_file;
+static lv_obj_t *lbl_level;
+static lv_obj_t *lbl_sd;
+static lv_obj_t *led_status;
+static lv_obj_t *bar_level;
+static lv_obj_t *btn_rec;
+static lv_obj_t *lbl_rec;
+static lv_obj_t *btn_play;
+static lv_obj_t *lbl_play;
+
+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_ui_ms = 0;
+static bool mic_ok = false;
+static bool card_ok = false;
+
+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 const char *basename_of(const char *path) {
+  if (!path || !path[0]) return "-";
+  const char *p = strrchr(path, '/');
+  return p ? p + 1 : path;
+}
+
+static void touchscreen_read(lv_indev_t *indev, lv_indev_data_t *data) {
+  static bool was_pressed = false;
+  static uint32_t press_ms = 0;
+  static bool consumed = false;
+
+  touch_read_cb(indev, data);
+
+  if (data->state == LV_INDEV_STATE_PRESSED) {
+    if (!was_pressed) {
+      was_pressed = true;
+      press_ms = millis();
+      consumed = false;
+    }
+  } else if (was_pressed) {
+    was_pressed = false;
+    uint32_t held = millis() - press_ms;
+    if (!consumed && held < 350) {
+      /* Brightness only if press was not on a button — LVGL already handled
+       * buttons; use short idle-area taps via header region. */
+      if (data->point.y < 28) {
+        set_backlight((bright_level + 1) & 0x03);
+        char buf[24];
+        lv_snprintf(buf, sizeof(buf), "brightness %u/3", (unsigned)bright_level);
+        show_hint(buf, 900);
+      }
+    }
+  }
+}
+
+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, 8, 0);
+  lv_obj_clear_flag(p, LV_OBJ_FLAG_SCROLLABLE);
+  return p;
+}
+
+static void style_btn(lv_obj_t *btn, lv_color_t bg) {
+  lv_obj_set_style_bg_color(btn, bg, 0);
+  lv_obj_set_style_bg_opa(btn, LV_OPA_COVER, 0);
+  lv_obj_set_style_radius(btn, 12, 0);
+  lv_obj_set_style_border_width(btn, 0, 0);
+  lv_obj_set_style_shadow_width(btn, 0, 0);
+  lv_obj_set_ext_click_area(btn, 8);
+}
+
+static void on_rec_clicked(lv_event_t *e) {
+  (void)e;
+  if (player_is_playing()) {
+    player_stop();
+    show_hint("stopped play", 800);
+  }
+
+  if (recorder_is_active()) {
+    recorder_stop();
+    show_hint("saved", 1200);
+  } else {
+    if (!card_ok && !sd_init()) {
+      show_hint("insert microSD", 2000);
+      return;
+    }
+    card_ok = sd_ready();
+    if (!recorder_start()) {
+      show_hint(recorder_status(), 2000);
+      return;
+    }
+    show_hint("recording…", 1000);
+  }
+}
+
+static void on_play_clicked(lv_event_t *e) {
+  (void)e;
+  if (recorder_is_active()) {
+    show_hint("stop REC first", 1200);
+    return;
+  }
+  if (player_is_playing()) {
+    player_stop();
+    show_hint("stopped", 800);
+    return;
+  }
+  const char *path = recorder_last_path();
+  if (!path || !path[0]) {
+    show_hint("no recording", 1200);
+    return;
+  }
+  if (!player_play(path)) {
+    show_hint(player_status(), 1500);
+    return;
+  }
+  show_hint("playing", 800);
+}
+
+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, "RECORD");
+  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 content_w = SCREEN_WIDTH - 2 * UI_M;
+  const int y0 = 28;
+
+  lv_obj_t *p_main = make_panel(scr, UI_M, y0, content_w,
+                                SCREEN_HEIGHT - y0 - UI_M);
+
+  lbl_time = lv_label_create(p_main);
+  lv_label_set_text(lbl_time, "00:00");
+  lv_obj_set_style_text_font(lbl_time, &lv_font_montserrat_28, 0);
+  lv_obj_set_style_text_color(lbl_time, COL_TEXT, 0);
+  lv_obj_align(lbl_time, LV_ALIGN_TOP_LEFT, 0, 0);
+
+  lbl_level = lv_label_create(p_main);
+  lv_label_set_text(lbl_level, "--.- dB");
+  lv_obj_set_style_text_font(lbl_level, &lv_font_montserrat_14, 0);
+  lv_obj_set_style_text_color(lbl_level, COL_MUTED, 0);
+  lv_obj_align(lbl_level, LV_ALIGN_TOP_RIGHT, 0, 8);
+
+  bar_level = lv_bar_create(p_main);
+  lv_obj_set_size(bar_level, content_w - 16, UI_BAR_H);
+  lv_obj_align(bar_level, LV_ALIGN_TOP_MID, 0, 40);
+  lv_bar_set_range(bar_level, 30, 110);
+  lv_bar_set_value(bar_level, 30, LV_ANIM_OFF);
+  lv_obj_set_style_bg_color(bar_level, COL_ARC_BG, LV_PART_MAIN);
+  lv_obj_set_style_bg_opa(bar_level, LV_OPA_COVER, LV_PART_MAIN);
+  lv_obj_set_style_radius(bar_level, 6, LV_PART_MAIN);
+  lv_obj_set_style_bg_color(bar_level, COL_ACCENT, LV_PART_INDICATOR);
+  lv_obj_set_style_radius(bar_level, 6, LV_PART_INDICATOR);
+
+  lbl_file = lv_label_create(p_main);
+  lv_label_set_text(lbl_file, "file: -");
+  lv_obj_set_style_text_font(lbl_file, &lv_font_montserrat_12, 0);
+  lv_obj_set_style_text_color(lbl_file, COL_MUTED, 0);
+  lv_obj_align(lbl_file, LV_ALIGN_TOP_LEFT, 0, 40 + UI_BAR_H + 10);
+
+  lbl_sd = lv_label_create(p_main);
+  lv_label_set_text(lbl_sd, "SD: -");
+  lv_obj_set_style_text_font(lbl_sd, &lv_font_montserrat_12, 0);
+  lv_obj_set_style_text_color(lbl_sd, COL_MUTED, 0);
+  lv_obj_align(lbl_sd, LV_ALIGN_TOP_LEFT, 0, 40 + UI_BAR_H + 28);
+
+  const int btn_y = 40 + UI_BAR_H + 52;
+  const int btn_w = (content_w - 16 - UI_G) / 2;
+
+  btn_rec = lv_button_create(p_main);
+  lv_obj_set_size(btn_rec, btn_w, UI_BTN_H);
+  lv_obj_align(btn_rec, LV_ALIGN_TOP_LEFT, 0, btn_y);
+  style_btn(btn_rec, COL_REC);
+  lv_obj_add_event_cb(btn_rec, on_rec_clicked, LV_EVENT_CLICKED, nullptr);
+  lbl_rec = lv_label_create(btn_rec);
+  lv_label_set_text(lbl_rec, "REC");
+  lv_obj_set_style_text_font(lbl_rec, &lv_font_montserrat_16, 0);
+  lv_obj_set_style_text_color(lbl_rec, COL_TEXT, 0);
+  lv_obj_center(lbl_rec);
+
+  btn_play = lv_button_create(p_main);
+  lv_obj_set_size(btn_play, btn_w, UI_BTN_H);
+  lv_obj_align(btn_play, LV_ALIGN_TOP_RIGHT, 0, btn_y);
+  style_btn(btn_play, COL_ACCENT);
+  lv_obj_add_event_cb(btn_play, on_play_clicked, LV_EVENT_CLICKED, nullptr);
+  lbl_play = lv_label_create(btn_play);
+  lv_label_set_text(lbl_play, "PLAY");
+  lv_obj_set_style_text_font(lbl_play, &lv_font_montserrat_16, 0);
+  lv_obj_set_style_text_color(lbl_play, COL_TEXT, 0);
+  lv_obj_center(lbl_play);
+
+  lv_obj_t *hint2 = lv_label_create(p_main);
+  lv_label_set_text(hint2, "tap header: brightness  |  max 120s");
+  lv_obj_set_style_text_font(hint2, &lv_font_montserrat_12, 0);
+  lv_obj_set_style_text_color(hint2, COL_MUTED, 0);
+  lv_obj_align(hint2, LV_ALIGN_BOTTOM_MID, 0, 0);
+}
+
+static void refresh_ui(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);
+  }
+
+  const bool rec = recorder_is_active();
+  const bool play = player_is_playing();
+
+  if (rec) {
+    uint32_t ms = recorder_elapsed_ms();
+    lv_snprintf(buf, sizeof(buf), "%02lu:%02lu",
+                (unsigned long)(ms / 60000),
+                (unsigned long)((ms / 1000) % 60));
+    lv_label_set_text(lbl_time, buf);
+    lv_obj_set_style_text_color(lbl_time, COL_REC, 0);
+    lv_label_set_text(lbl_rec, "STOP");
+    lv_obj_set_style_bg_color(btn_rec, COL_WARN, 0);
+    lv_label_set_text(lbl_status, "REC");
+    lv_led_set_color(led_status, COL_REC);
+  } else if (play) {
+    lv_label_set_text(lbl_time, "PLAY");
+    lv_obj_set_style_text_color(lbl_time, COL_ACCENT, 0);
+    lv_label_set_text(lbl_rec, "REC");
+    lv_obj_set_style_bg_color(btn_rec, COL_REC, 0);
+    lv_label_set_text(lbl_play, "STOP");
+    lv_obj_set_style_bg_color(btn_play, COL_WARN, 0);
+    lv_label_set_text(lbl_status, "PLAY");
+    lv_led_set_color(led_status, COL_ACCENT);
+  } else {
+    lv_label_set_text(lbl_time, "00:00");
+    lv_obj_set_style_text_color(lbl_time, COL_TEXT, 0);
+    lv_label_set_text(lbl_rec, "REC");
+    lv_obj_set_style_bg_color(btn_rec, COL_REC, 0);
+    lv_label_set_text(lbl_play, "PLAY");
+    lv_obj_set_style_bg_color(btn_play, COL_ACCENT, 0);
+    if (!mic_ok) {
+      lv_label_set_text(lbl_status, "NO MIC");
+      lv_led_set_color(led_status, COL_BAD);
+    } else if (!card_ok) {
+      lv_label_set_text(lbl_status, "NO SD");
+      lv_led_set_color(led_status, COL_WARN);
+    } else {
+      lv_label_set_text(lbl_status, "READY");
+      lv_led_set_color(led_status, COL_OK);
+    }
+  }
+
+  float db = recorder_level_db();
+  if (!isnan(db)) {
+    lv_snprintf(buf, sizeof(buf), "%.0f dB", db);
+    lv_label_set_text(lbl_level, buf);
+    int v = (int)lroundf(constrain(db, 30.0f, 110.0f));
+    lv_bar_set_value(bar_level, v, LV_ANIM_OFF);
+    lv_color_t c = (db < 70) ? COL_ACCENT : ((db < 90) ? COL_WARN : COL_BAD);
+    lv_obj_set_style_bg_color(bar_level, c, LV_PART_INDICATOR);
+    lv_obj_set_style_text_color(lbl_level, c, 0);
+  } else {
+    lv_label_set_text(lbl_level, "-- dB");
+  }
+
+  lv_snprintf(buf, sizeof(buf), "file: %s", basename_of(recorder_last_path()));
+  lv_label_set_text(lbl_file, buf);
+
+  if (card_ok) {
+    uint64_t free_mb = sd_free_bytes() / (1024ULL * 1024ULL);
+    uint64_t tot_mb = sd_total_bytes() / (1024ULL * 1024ULL);
+    lv_snprintf(buf, sizeof(buf), "SD: %llu/%llu MB free  16kHz WAV",
+                (unsigned long long)free_mb, (unsigned long long)tot_mb);
+    lv_label_set_text(lbl_sd, buf);
+    lv_obj_set_style_text_color(lbl_sd, COL_MUTED, 0);
+  } else {
+    lv_label_set_text(lbl_sd, "SD: not mounted — insert card");
+    lv_obj_set_style_text_color(lbl_sd, COL_BAD, 0);
+  }
+}
+
+void setup() {
+  Serial.begin(115200);
+  delay(200);
+
+  ledcSetup(0, 5000, 8);
+  ledcAttachPin(TFT_BL_PIN, 0);
+  set_backlight(2);
+
+  Serial.println("CYD LVGL INMP441 WAV Recorder");
+  Serial.printf("LVGL %d.%d.%d  WS=%d SCK=%d SD=%d  BL=%d  spk=%d\n",
+                lv_version_major(), lv_version_minor(), lv_version_patch(),
+                I2S_WS_PIN, I2S_SCK_PIN, I2S_SD_PIN, TFT_BL_PIN, SPEAKER_PIN);
+
+  /* 3.5: GT911 may pulse INT(=21) during addr select; release before I2S SCK. */
+  touch_init();
+
+  card_ok = sd_init();
+  mic_ok = recorder_mic_init();
+  player_init();
+
+  Serial.println(mic_ok ? "I2S mic OK" : "I2S mic FAIL — check wiring");
+  Serial.println(card_ok ? "SD OK" : "SD FAIL — insert FAT32 microSD");
+#if defined(CYD_BOARD_3248S035)
+  Serial.println("3.5C: SCK=GPIO21 (shared GT911 INT; touch is poll-only)");
+#endif
+
+  lv_init();
+
+#if defined(CYD_BOARD_3248S035)
+  lv_display_t *disp = lv_tft_espi_create(320, 480, draw_buf, sizeof(draw_buf));
+#else
+  lv_display_t *disp = lv_tft_espi_create(240, 320, draw_buf, sizeof(draw_buf));
+#endif
+  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);
+  lv_indev_set_display(indev, disp);
+
+  create_ui();
+  if (!mic_ok) show_hint("mic init fail", 3000);
+  else if (!card_ok) show_hint("insert microSD", 3000);
+
+  refresh_ui();
+}
+
+void loop() {
+  /* Drain mic (and write WAV while recording) often enough for DMA. */
+  recorder_tick();
+  recorder_tick();
+  player_tick();
+
+  uint32_t now = millis();
+  if (now - last_ui_ms >= 100) {
+    last_ui_ms = now;
+    refresh_ui();
+  }
+
+  lv_timer_handler();
+  lv_tick_inc(5);
+  delay(5);
+}
--- a/src/player.cpp
+++ b/src/player.cpp
@@ -0,0 +1,261 @@
+/**
+ * Stream 16-bit mono/stereo PCM WAV → DAC2 (GPIO26) only.
+ * Never touches GPIO25 (touch CLK / GT911 RST).
+ */
+
+#include "player.h"
+#include "pins.h"
+#include "sdcard.h"
+
+#include <Arduino.h>
+#include <SD.h>
+#include <driver/dac.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+#include <string.h>
+
+static File play_file;
+static volatile bool playing = false;
+static volatile bool stop_req = false;
+static const char *status = "idle";
+static TaskHandle_t play_task = nullptr;
+static char play_path[48] = "";
+static uint8_t volume = 45;
+
+static void release_dac(void) {
+  dac_output_disable(DAC_CHANNEL_1);
+  dac_output_disable(DAC_CHANNEL_2);
+  pinMode(SPEAKER_PIN, OUTPUT);
+  digitalWrite(SPEAKER_PIN, LOW);
+}
+
+static bool read_u16(File &f, uint16_t &v) {
+  uint8_t b[2];
+  if (f.read(b, 2) != 2) return false;
+  v = (uint16_t)b[0] | ((uint16_t)b[1] << 8);
+  return true;
+}
+
+static bool read_u32(File &f, uint32_t &v) {
+  uint8_t b[4];
+  if (f.read(b, 4) != 4) return false;
+  v = (uint32_t)b[0] | ((uint32_t)b[1] << 8) | ((uint32_t)b[2] << 16) |
+      ((uint32_t)b[3] << 24);
+  return true;
+}
+
+static uint8_t scale_u8(int16_t s16) {
+  int c = ((int)s16 * (int)volume) / 100;
+  c = (c * 40) / 100;
+  int o = 128 + (c / 256);
+  if (o < 0) o = 0;
+  if (o > 255) o = 255;
+  return (uint8_t)o;
+}
+
+static bool open_and_parse(const char *path, uint16_t *channels, uint16_t *bits,
+                           uint32_t *sample_rate, uint32_t *data_left) {
+  play_file = SD.open(path, FILE_READ);
+  if (!play_file) {
+    status = "open fail";
+    return false;
+  }
+
+  uint32_t tag = 0;
+  if (!read_u32(play_file, tag) || tag != 0x46464952) {
+    play_file.close();
+    status = "not RIFF";
+    return false;
+  }
+  uint32_t riff_size = 0;
+  read_u32(play_file, riff_size);
+  (void)riff_size;
+  if (!read_u32(play_file, tag) || tag != 0x45564157) {
+    play_file.close();
+    status = "not WAVE";
+    return false;
+  }
+
+  bool got_fmt = false;
+  bool got_data = false;
+  *channels = 1;
+  *bits = 16;
+  *sample_rate = 16000;
+  *data_left = 0;
+
+  while (play_file.available() >= 8) {
+    uint32_t ckid = 0, cksize = 0;
+    if (!read_u32(play_file, ckid) || !read_u32(play_file, cksize)) break;
+
+    if (ckid == 0x20746D66) {
+      uint16_t audio_fmt = 0;
+      read_u16(play_file, audio_fmt);
+      read_u16(play_file, *channels);
+      read_u32(play_file, *sample_rate);
+      uint32_t byte_rate = 0;
+      uint16_t block_align = 0;
+      read_u32(play_file, byte_rate);
+      (void)byte_rate;
+      read_u16(play_file, block_align);
+      (void)block_align;
+      read_u16(play_file, *bits);
+      if (cksize > 16) {
+        play_file.seek(play_file.position() + (cksize - 16));
+      }
+      if (audio_fmt != 1 && audio_fmt != 0xFFFE) {
+        play_file.close();
+        status = "not PCM";
+        return false;
+      }
+      got_fmt = true;
+    } else if (ckid == 0x61746164) {
+      *data_left = cksize;
+      got_data = true;
+      break;
+    } else {
+      play_file.seek(play_file.position() + cksize + (cksize & 1));
+    }
+  }
+
+  if (!got_fmt || !got_data || *data_left == 0) {
+    play_file.close();
+    status = "bad WAV";
+    return false;
+  }
+  if (*bits != 16 && *bits != 8) {
+    play_file.close();
+    status = "bits?";
+    return false;
+  }
+  if (*channels < 1 || *channels > 2) {
+    play_file.close();
+    status = "ch?";
+    return false;
+  }
+  return true;
+}
+
+static void play_task_fn(void * /*arg*/) {
+  uint16_t channels = 1;
+  uint16_t bits = 16;
+  uint32_t sample_rate = 16000;
+  uint32_t data_left = 0;
+
+  if (!open_and_parse(play_path, &channels, &bits, &sample_rate, &data_left)) {
+    playing = false;
+    vTaskDelete(nullptr);
+    return;
+  }
+
+  if (sample_rate < 4000) sample_rate = 4000;
+  if (sample_rate > 48000) sample_rate = 48000;
+  const uint32_t period_us = 1000000UL / sample_rate;
+
+  dac_output_disable(DAC_CHANNEL_1);
+  dac_output_enable(DAC_CHANNEL_2);
+  dac_output_voltage(DAC_CHANNEL_2, 128);
+
+  status = "play";
+  Serial.printf("PLAY %s %uHz %ubit %uch\n", play_path, (unsigned)sample_rate,
+                (unsigned)bits, (unsigned)channels);
+
+  uint32_t next_us = micros();
+  while (!stop_req && data_left > 0) {
+    int32_t mono = 0;
+    for (uint16_t c = 0; c < channels; c++) {
+      if (bits == 8) {
+        int b = play_file.read();
+        if (b < 0) {
+          data_left = 0;
+          break;
+        }
+        data_left--;
+        mono += (b - 128) * 256;
+      } else {
+        uint16_t s;
+        if (!read_u16(play_file, s) || data_left < 2) {
+          data_left = 0;
+          break;
+        }
+        data_left -= 2;
+        mono += (int16_t)s;
+      }
+    }
+    if (channels == 2) mono /= 2;
+
+    dac_output_voltage(DAC_CHANNEL_2, scale_u8((int16_t)mono));
+
+    next_us += period_us;
+    int32_t wait = (int32_t)(next_us - micros());
+    if (wait > 0) {
+      delayMicroseconds((uint32_t)wait);
+    } else if (wait < -2000) {
+      next_us = micros();
+    }
+  }
+
+  if (play_file) play_file.close();
+  release_dac();
+  playing = false;
+  status = stop_req ? "stopped" : "done";
+  play_task = nullptr;
+  vTaskDelete(nullptr);
+}
+
+void player_init(void) {
+  release_dac();
+  status = "idle";
+}
+
+void player_stop(void) {
+  if (!playing && !play_task) {
+    release_dac();
+    return;
+  }
+  stop_req = true;
+  for (int i = 0; i < 50 && play_task; i++) {
+    delay(10);
+  }
+  if (play_file) play_file.close();
+  playing = false;
+  play_task = nullptr;
+  release_dac();
+  status = "stopped";
+}
+
+bool player_is_playing(void) { return playing; }
+
+const char *player_status(void) { return status; }
+
+bool player_play(const char *path) {
+  player_stop();
+  if (!path || !path[0]) {
+    status = "no file";
+    return false;
+  }
+  if (!sd_ready() && !sd_init()) {
+    status = "no SD";
+    return false;
+  }
+
+  strncpy(play_path, path, sizeof(play_path) - 1);
+  play_path[sizeof(play_path) - 1] = '\0';
+  stop_req = false;
+  playing = true;
+  status = "start";
+
+  BaseType_t ok =
+      xTaskCreatePinnedToCore(play_task_fn, "wavdac", 4096, nullptr, 4,
+                              &play_task, 0);
+  if (ok != pdPASS) {
+    playing = false;
+    play_task = nullptr;
+    status = "task fail";
+    return false;
+  }
+  return true;
+}
+
+void player_tick(void) {
+  /* playback runs in its own task */
+}
--- a/src/recorder.cpp
+++ b/src/recorder.cpp
@@ -0,0 +1,322 @@
+/**
+ * INMP441 I2S → 16-bit mono PCM WAV on microSD (/rec/Rxxxx.WAV)
+ * Stereo DMA slots: pick louder even/odd (ESP32 L/R vs mic L/R often inverted).
+ */
+
+#include "recorder.h"
+#include "pins.h"
+#include "sdcard.h"
+
+#include <Arduino.h>
+#include <FS.h>
+#include <SD.h>
+#include <driver/i2s.h>
+#include <math.h>
+#include <string.h>
+
+#define I2S_PORT I2S_NUM_0
+#define DMA_BUF_COUNT 8
+#define DMA_BUF_LEN 256
+#define READ_SAMPLES 512
+#define MIC_DB_OFFSET 120.0f
+#define EMA_ALPHA 0.35f
+#define WAV_HDR_SIZE 44
+#define REC_DIR "/rec"
+
+static int32_t i2s_raw[READ_SAMPLES];
+static int16_t pcm_out[READ_SAMPLES / 2 + 8];
+
+static bool mic_ok = false;
+static bool recording = false;
+static File rec_file;
+static char last_path[40] = "";
+static char status_buf[32] = "idle";
+static uint32_t data_bytes = 0;
+static uint32_t start_ms = 0;
+static float level_db = NAN;
+static uint16_t next_index = 1;
+static int preferred_slot = -1; /* -1=auto, 0=even, 1=odd */
+
+static void write_u16(File &f, uint16_t v) {
+  uint8_t b[2] = {(uint8_t)(v & 0xFF), (uint8_t)(v >> 8)};
+  f.write(b, 2);
+}
+
+static void write_u32(File &f, uint32_t v) {
+  uint8_t b[4] = {(uint8_t)(v & 0xFF), (uint8_t)((v >> 8) & 0xFF),
+                  (uint8_t)((v >> 16) & 0xFF), (uint8_t)((v >> 24) & 0xFF)};
+  f.write(b, 4);
+}
+
+static void write_wav_header(File &f, uint32_t pcm_bytes) {
+  const uint32_t sample_rate = REC_SAMPLE_RATE;
+  const uint16_t channels = 1;
+  const uint16_t bits = 16;
+  const uint32_t byte_rate = sample_rate * channels * (bits / 8);
+  const uint16_t block_align = channels * (bits / 8);
+
+  f.seek(0);
+  f.write((const uint8_t *)"RIFF", 4);
+  write_u32(f, 36 + pcm_bytes);
+  f.write((const uint8_t *)"WAVE", 4);
+  f.write((const uint8_t *)"fmt ", 4);
+  write_u32(f, 16);
+  write_u16(f, 1); /* PCM */
+  write_u16(f, channels);
+  write_u32(f, sample_rate);
+  write_u32(f, byte_rate);
+  write_u16(f, block_align);
+  write_u16(f, bits);
+  f.write((const uint8_t *)"data", 4);
+  write_u32(f, pcm_bytes);
+}
+
+static void ensure_rec_dir(void) {
+  if (!SD.exists(REC_DIR)) {
+    SD.mkdir(REC_DIR);
+  }
+}
+
+static uint16_t scan_next_index(void) {
+  ensure_rec_dir();
+  uint16_t max_n = 0;
+  File root = SD.open(REC_DIR);
+  if (!root || !root.isDirectory()) {
+    if (root) root.close();
+    return 1;
+  }
+  File f = root.openNextFile();
+  while (f) {
+    const char *name = f.name();
+    /* SD lib may return "/rec/R0001.WAV" or "R0001.WAV" */
+    const char *base = strrchr(name, '/');
+    base = base ? base + 1 : name;
+    if (base[0] == 'R' || base[0] == 'r') {
+      int n = atoi(base + 1);
+      if (n > 0 && (uint16_t)n > max_n) max_n = (uint16_t)n;
+    }
+    f = root.openNextFile();
+  }
+  root.close();
+  return (uint16_t)(max_n + 1);
+}
+
+bool recorder_mic_init(void) {
+  i2s_config_t cfg = {};
+  cfg.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX);
+  cfg.sample_rate = REC_SAMPLE_RATE;
+  cfg.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT;
+  cfg.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT;
+  cfg.communication_format = I2S_COMM_FORMAT_STAND_I2S;
+  cfg.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1;
+  cfg.dma_buf_count = DMA_BUF_COUNT;
+  cfg.dma_buf_len = DMA_BUF_LEN;
+  cfg.use_apll = false;
+  cfg.tx_desc_auto_clear = false;
+  cfg.fixed_mclk = 0;
+
+  i2s_pin_config_t pins = {};
+  pins.bck_io_num = I2S_SCK_PIN;
+  pins.ws_io_num = I2S_WS_PIN;
+  pins.data_out_num = I2S_PIN_NO_CHANGE;
+  pins.data_in_num = I2S_SD_PIN;
+
+  if (i2s_driver_install(I2S_PORT, &cfg, 0, NULL) != ESP_OK) {
+    strncpy(status_buf, "i2s fail", sizeof(status_buf));
+    return false;
+  }
+  if (i2s_set_pin(I2S_PORT, &pins) != ESP_OK) {
+    strncpy(status_buf, "i2s pin", sizeof(status_buf));
+    return false;
+  }
+  i2s_zero_dma_buffer(I2S_PORT);
+  mic_ok = true;
+  strncpy(status_buf, "ready", sizeof(status_buf));
+  Serial.printf("I2S mic WS=%d SCK=%d SD=%d @%u Hz\n", I2S_WS_PIN, I2S_SCK_PIN,
+                I2S_SD_PIN, (unsigned)REC_SAMPLE_RATE);
+  return true;
+}
+
+bool recorder_start(void) {
+  if (recording) return true;
+  if (!mic_ok) {
+    strncpy(status_buf, "no mic", sizeof(status_buf));
+    return false;
+  }
+  if (!sd_ready() && !sd_init()) {
+    strncpy(status_buf, "no SD", sizeof(status_buf));
+    return false;
+  }
+  if (sd_free_bytes() < 64 * 1024) {
+    strncpy(status_buf, "SD full", sizeof(status_buf));
+    return false;
+  }
+
+  next_index = scan_next_index();
+  ensure_rec_dir();
+  snprintf(last_path, sizeof(last_path), "%s/R%04u.WAV", REC_DIR,
+           (unsigned)next_index);
+
+  if (SD.exists(last_path)) {
+    SD.remove(last_path);
+  }
+
+  rec_file = SD.open(last_path, FILE_WRITE);
+  if (!rec_file) {
+    strncpy(status_buf, "open fail", sizeof(status_buf));
+    last_path[0] = '\0';
+    return false;
+  }
+
+  /* Placeholder header; finalize on stop. */
+  uint8_t zeros[WAV_HDR_SIZE] = {0};
+  if (rec_file.write(zeros, WAV_HDR_SIZE) != WAV_HDR_SIZE) {
+    rec_file.close();
+    strncpy(status_buf, "hdr fail", sizeof(status_buf));
+    return false;
+  }
+
+  data_bytes = 0;
+  start_ms = millis();
+  preferred_slot = -1;
+  level_db = NAN;
+  recording = true;
+  strncpy(status_buf, "REC", sizeof(status_buf));
+  Serial.printf("REC start %s\n", last_path);
+  return true;
+}
+
+void recorder_stop(void) {
+  if (!recording) return;
+  recording = false;
+
+  if (rec_file) {
+    write_wav_header(rec_file, data_bytes);
+    rec_file.flush();
+    rec_file.close();
+  }
+
+  uint32_t sec = data_bytes / (REC_SAMPLE_RATE * 2);
+  Serial.printf("REC stop %s bytes=%lu (~%lus)\n", last_path,
+                (unsigned long)data_bytes, (unsigned long)sec);
+  strncpy(status_buf, "saved", sizeof(status_buf));
+}
+
+bool recorder_is_active(void) { return recording; }
+
+float recorder_level_db(void) { return level_db; }
+
+uint32_t recorder_elapsed_ms(void) {
+  if (!recording) return 0;
+  return millis() - start_ms;
+}
+
+uint32_t recorder_bytes_written(void) { return data_bytes; }
+
+const char *recorder_last_path(void) { return last_path; }
+
+const char *recorder_status(void) { return status_buf; }
+
+static float ema(float prev, float sample) {
+  if (isnan(prev)) return sample;
+  return prev + EMA_ALPHA * (sample - prev);
+}
+
+void recorder_tick(void) {
+  if (!mic_ok) return;
+
+  size_t bytes_read = 0;
+  /* Non-blocking when idle; short wait while recording so LVGL stays responsive. */
+  esp_err_t err =
+      i2s_read(I2S_PORT, (void *)i2s_raw, sizeof(i2s_raw), &bytes_read,
+               recording ? pdMS_TO_TICKS(8) : 0);
+  if (err != ESP_OK || bytes_read < sizeof(int32_t) * 32) {
+    return;
+  }
+
+  int n = (int)(bytes_read / sizeof(int32_t));
+  if (n < 32) return;
+
+  /* Unpack 24-bit left-justified. */
+  static int32_t unpacked[READ_SAMPLES];
+  for (int i = 0; i < n; i++) {
+    unpacked[i] = i2s_raw[i] >> 8;
+  }
+
+  double mean_even = 0.0, mean_odd = 0.0;
+  int n_even = 0, n_odd = 0;
+  for (int i = 0; i < n; i++) {
+    if ((i & 1) == 0) {
+      mean_even += unpacked[i];
+      n_even++;
+    } else {
+      mean_odd += unpacked[i];
+      n_odd++;
+    }
+  }
+  if (n_even < 8 || n_odd < 8) return;
+  mean_even /= (double)n_even;
+  mean_odd /= (double)n_odd;
+
+  double sum_even = 0.0, sum_odd = 0.0;
+  for (int i = 0; i < n; i++) {
+    double v;
+    if ((i & 1) == 0) {
+      v = (double)unpacked[i] - mean_even;
+      sum_even += v * v;
+    } else {
+      v = (double)unpacked[i] - mean_odd;
+      sum_odd += v * v;
+    }
+  }
+  double rms_even = sqrt(sum_even / (double)n_even);
+  double rms_odd = sqrt(sum_odd / (double)n_odd);
+
+  if (preferred_slot < 0) {
+    preferred_slot = (rms_even >= rms_odd) ? 0 : 1;
+  }
+  const int slot = preferred_slot;
+  const double mean = (slot == 0) ? mean_even : mean_odd;
+  const double rms = (slot == 0) ? rms_even : rms_odd;
+
+  if (rms >= 1.0) {
+    float dbfs = 20.0f * log10f((float)rms / 8388607.0f);
+    float db = dbfs + MIC_DB_OFFSET;
+    if (db < 0.0f) db = 0.0f;
+    if (db > 140.0f) db = 140.0f;
+    level_db = ema(level_db, db);
+  } else {
+    level_db = ema(level_db, 0.0f);
+  }
+
+  if (!recording) return;
+
+  /* Convert selected slot → int16 PCM */
+  int out_n = 0;
+  for (int i = slot; i < n; i += 2) {
+    int32_t v = unpacked[i] - (int32_t)mean;
+    /* 24-bit → 16-bit with headroom (>> 8) */
+    int32_t s = v >> 8;
+    if (s > 32767) s = 32767;
+    if (s < -32768) s = -32768;
+    pcm_out[out_n++] = (int16_t)s;
+  }
+
+  if (out_n > 0) {
+    size_t want = (size_t)out_n * sizeof(int16_t);
+    size_t wr = rec_file.write((const uint8_t *)pcm_out, want);
+    if (wr != want) {
+      Serial.println("REC write error — stopping");
+      strncpy(status_buf, "write err", sizeof(status_buf));
+      recorder_stop();
+      return;
+    }
+    data_bytes += (uint32_t)wr;
+  }
+
+  if (recorder_elapsed_ms() >= (uint32_t)REC_MAX_SECONDS * 1000U) {
+    Serial.println("REC max duration — auto stop");
+    strncpy(status_buf, "max time", sizeof(status_buf));
+    recorder_stop();
+  }
+}
--- a/src/sdcard.cpp
+++ b/src/sdcard.cpp
@@ -0,0 +1,54 @@
+#include "sdcard.h"
+#include "pins.h"
+
+#include <Arduino.h>
+#include <FS.h>
+#include <SD.h>
+#include <SPI.h>
+
+static SPIClass sd_spi(VSPI);
+static bool g_ready = false;
+
+bool sd_init(void) {
+  if (g_ready) return true;
+
+  pinMode(SD_CS, OUTPUT);
+  digitalWrite(SD_CS, HIGH);
+#if !defined(CYD_BOARD_3248S035)
+  /* Keep XPT2046 CS high so SD SPI does not steal the bus. */
+  pinMode(CYD_TOUCH_CS, OUTPUT);
+  digitalWrite(CYD_TOUCH_CS, HIGH);
+#endif
+
+  sd_spi.begin(SD_SCK, SD_MISO, SD_MOSI, SD_CS);
+  if (!SD.begin(SD_CS, sd_spi, 25000000)) {
+    g_ready = false;
+    Serial.println("SD mount FAIL");
+    return false;
+  }
+
+  g_ready = true;
+  Serial.printf("SD OK total=%llu free=%llu\n",
+                (unsigned long long)SD.totalBytes(),
+                (unsigned long long)(SD.totalBytes() - SD.usedBytes()));
+  return true;
+}
+
+void sd_deinit(void) {
+  if (g_ready) {
+    SD.end();
+    g_ready = false;
+  }
+}
+
+bool sd_ready(void) { return g_ready; }
+
+uint64_t sd_free_bytes(void) {
+  if (!g_ready) return 0;
+  return SD.totalBytes() - SD.usedBytes();
+}
+
+uint64_t sd_total_bytes(void) {
+  if (!g_ready) return 0;
+  return SD.totalBytes();
+}
--- a/src/touch.cpp
+++ b/src/touch.cpp
@@ -0,0 +1,195 @@
+#include "touch.h"
+
+#include <Arduino.h>
+
+/**
+ * 2.8": XPT2046 resistive SoftSPI bus (CS33).
+ * 3.5C (3248S035C): GT911 capacitive on Wire1 SDA33/SCL32/INT21/RST25.
+ * Feed coords are always native panel 320x480 for LVGL ROTATION_270.
+ * Wire1 keeps GT911 off the INMP441 pins (WS22 / SCK21). After touch_init(),
+ * main claims GPIO21 as I2S BCK — touch stays poll-only (no INT IRQ).
+ * TFT_BL=27 on 3.5C.
+ */
+
+static int16_t clampi(int32_t v, int32_t lo, int32_t hi) {
+  if (v < lo) return (int16_t)lo;
+  if (v > hi) return (int16_t)hi;
+  return (int16_t)v;
+}
+
+#if defined(CYD_BOARD_3248S035)
+
+#include <Wire.h>
+
+/* Native panel size — not UI landscape SCREEN_* (480x320). */
+static constexpr int16_t PANEL_W = 320;
+static constexpr int16_t PANEL_H = 480;
+
+#define CYD_GT911_SDA 33
+#define CYD_GT911_SCL 32
+#define CYD_GT911_INT 21
+#define CYD_GT911_RST 25
+
+/* Minimal GT911 — no config rewrite (TAMC setResolution can hang Wire). */
+static uint8_t s_gt_addr = 0x5D;
+static constexpr uint16_t GT_POINT_INFO = 0x814E;
+static constexpr uint16_t GT_POINT_1 = 0x814F;
+
+static bool gt_write8(uint16_t reg, uint8_t val) {
+  Wire1.beginTransmission(s_gt_addr);
+  Wire1.write((uint8_t)(reg >> 8));
+  Wire1.write((uint8_t)(reg & 0xFF));
+  Wire1.write(val);
+  return Wire1.endTransmission() == 0;
+}
+
+static bool gt_read(uint16_t reg, uint8_t *buf, uint8_t len) {
+  Wire1.beginTransmission(s_gt_addr);
+  Wire1.write((uint8_t)(reg >> 8));
+  Wire1.write((uint8_t)(reg & 0xFF));
+  if (Wire1.endTransmission(false) != 0) {
+    return false;
+  }
+  const uint8_t n = Wire1.requestFrom(s_gt_addr, len);
+  if (n != len) {
+    return false;
+  }
+  for (uint8_t i = 0; i < len; i++) {
+    buf[i] = Wire1.read();
+  }
+  return true;
+}
+
+static bool gt_probe(uint8_t addr) {
+  Wire1.beginTransmission(addr);
+  return Wire1.endTransmission() == 0;
+}
+
+/* TAMC-compatible address select: INT low => 0x5D, INT high => 0x14 */
+static void gt_hw_reset(bool addr_0x14) {
+  pinMode(CYD_GT911_INT, OUTPUT);
+  pinMode(CYD_GT911_RST, OUTPUT);
+  digitalWrite(CYD_GT911_INT, LOW);
+  digitalWrite(CYD_GT911_RST, LOW);
+  delay(10);
+  digitalWrite(CYD_GT911_INT, addr_0x14 ? HIGH : LOW);
+  delay(1);
+  digitalWrite(CYD_GT911_RST, HIGH);
+  delay(5);
+  digitalWrite(CYD_GT911_INT, LOW);
+  delay(50);
+  /* BL=27. Release INT(21) before main reuses it as INMP441 I2S SCK. */
+  pinMode(CYD_GT911_INT, INPUT);
+  delay(50);
+}
+
+static bool gt_find_addr() {
+  for (uint8_t a : {uint8_t(0x5D), uint8_t(0x14)}) {
+    if (gt_probe(a)) {
+      s_gt_addr = a;
+      return true;
+    }
+  }
+  return false;
+}
+
+void touch_init() {
+  Serial.println("Touch: GT911 I2C capacitive (3.5C) minimal Wire1");
+  Wire1.begin(CYD_GT911_SDA, CYD_GT911_SCL);
+  Wire1.setClock(100000);
+#if defined(WIRE_HAS_TIMEOUT) || defined(ESP32)
+  Wire1.setTimeOut(50);
+#endif
+
+  if (!gt_find_addr()) {
+    Serial.println("GT911 not found — hw reset 0x5D");
+    gt_hw_reset(false);
+    if (!gt_find_addr()) {
+      Serial.println("GT911 not found — hw reset 0x14");
+      gt_hw_reset(true);
+      gt_find_addr();
+    }
+  }
+
+  Serial.printf("GT911 probe 0x5D=%s 0x14=%s using=0x%02X\n",
+                gt_probe(0x5D) ? "OK" : "no", gt_probe(0x14) ? "OK" : "no",
+                s_gt_addr);
+  Serial.printf("GT911 SDA=%d SCL=%d INT=%d RST=%d\n", CYD_GT911_SDA,
+                CYD_GT911_SCL, CYD_GT911_INT, CYD_GT911_RST);
+}
+
+void touch_read_cb(lv_indev_t * /*indev*/, lv_indev_data_t *data) {
+  uint8_t info = 0;
+
+  if (!gt_read(GT_POINT_INFO, &info, 1)) {
+    data->state = LV_INDEV_STATE_RELEASED;
+    return;
+  }
+
+  const uint8_t touches = info & 0x0F;
+  const bool buffered = (info & 0x80) != 0;
+
+  if (!buffered || touches == 0) {
+    if (buffered) {
+      gt_write8(GT_POINT_INFO, 0);
+    }
+    data->state = LV_INDEV_STATE_RELEASED;
+    return;
+  }
+
+  uint8_t pt[7];
+  if (!gt_read(GT_POINT_1, pt, 7)) {
+    gt_write8(GT_POINT_INFO, 0);
+    data->state = LV_INDEV_STATE_RELEASED;
+    return;
+  }
+  gt_write8(GT_POINT_INFO, 0);
+
+  const int16_t raw_x = (int16_t)(pt[1] | (pt[2] << 8));
+  const int16_t raw_y = (int16_t)(pt[3] | (pt[4] << 8));
+
+  /* Native 320x480 → LVGL 270. UI ≈ (H-1-raw_y, raw_x). */
+  const int16_t nx = clampi(raw_x, 0, PANEL_W - 1);
+  const int16_t ny = clampi(raw_y, 0, PANEL_H - 1);
+  data->point.x = (int16_t)((PANEL_W - 1) - nx);
+  data->point.y = (int16_t)((PANEL_H - 1) - ny);
+  data->state = LV_INDEV_STATE_PRESSED;
+}
+
+#else
+
+#include <SPI.h>
+#include <XPT2046_Touchscreen.h>
+
+#define XPT2046_IRQ 36
+#define XPT2046_MOSI 32
+#define XPT2046_MISO 39
+#define XPT2046_CLK 25
+#define XPT2046_CS 33
+
+/* 2.8 UI landscape feed (unchanged from prior main.cpp). */
+static constexpr int16_t UI_W = 320;
+static constexpr int16_t UI_H = 240;
+
+static SPIClass touchscreenSPI = SPIClass(VSPI);
+static XPT2046_Touchscreen touchscreen(XPT2046_CS, XPT2046_IRQ);
+
+void touch_init() {
+  touchscreenSPI.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
+  touchscreen.begin(touchscreenSPI);
+  touchscreen.setRotation(2);
+  Serial.println("Touch: XPT2046 resistive (2.8)");
+}
+
+void touch_read_cb(lv_indev_t * /*indev*/, lv_indev_data_t *data) {
+  if (touchscreen.tirqTouched() && touchscreen.touched()) {
+    TS_Point p = touchscreen.getPoint();
+    data->point.x = map(p.y, 240, 3800, 1, UI_W);
+    data->point.y = map(p.x, 200, 3700, UI_H, 1);
+    data->state = LV_INDEV_STATE_PRESSED;
+  } else {
+    data->state = LV_INDEV_STATE_RELEASED;
+  }
+}
+
+#endif