discstation 0.1.23 → 0.1.26

package/arduino/v1/DiscStation.ino

@@ -3,9 +3,20 @@
 #include <Adafruit_SSD1306.h>
 #include "esp_task_wdt.h"
 #include <WiFi.h>
+#include "esp_mac.h"
+#include <WiFiManager.h>
+#include <ESPmDNS.h>
+#include <Preferences.h>
 #include <ArduinoOTA.h>
 #include <QRCode.h>
 
+// Optional build-time Wi-Fi override for power users: copy secrets.h.example
+// to secrets.h (git-ignored) and set WIFI_SSID / WIFI_PASS / OTA_PASSWORD.
+// If WIFI_SSID is defined the runtime setup portal is skipped entirely.
+#if __has_include("secrets.h")
+  #include "secrets.h"
+#endif
+
 #define SCREEN_WIDTH 128
 #define SCREEN_HEIGHT 64
 #define OLED_RESET    -1
@@ -23,9 +34,14 @@
 #define POT_READ_MS      200
 #define DONE_RESET_MS    30000
 #define STANDBY_BLANK_MS 60000
+#define IDLE_BLANK_MS    45000   // blank the OLED after this long with no input on HOME/STANDBY
 #define PING_TIMEOUT_MS  30000
 #define LED_BLINK_MS     250
 
+#define WIFI_RESET_HOLD_MS      10000  // hold SELECT this long on HOME to wipe Wi-Fi creds
+#define WIFI_CONNECT_TIMEOUT_MS 18000  // give a stored-creds join this long before falling to the portal
+#define WIFI_RETRY_MS           30000  // if a live link drops, force a re-join after this
+
 #define MAX_HOME_MODES 5
 #define BURN_COUNT 4
 #define SPEED_COUNT 4
@@ -36,8 +52,17 @@ String homeModes[MAX_HOME_MODES] = {"BURN", "PLAY", "RIP"};
 
 WiFiServer tcpServer(TCP_PORT);
 WiFiClient tcpClient;
+WiFiManager wm;
+Preferences prefs;
 bool wifiConnected = false;
 bool wifiInitDone = false;
+bool portalActive = false;
+bool otaEnabled = false;
+bool credsJustSaved = false;
+bool wifiResetArmed = false;
+unsigned long wifiDropAt = 0;
+String apName = "DiscStation";
+String mdnsHost = "discstation";
 
 class DualPrint : public Print {
 public:
@@ -56,23 +81,105 @@ private:
   WiFiClient* _client = nullptr;
 } Out;
 
+void drawSetup();       // fwd decls (defined with the other draw* below)
+void drawWifiReset();
+
+String deviceSuffix() {
+  uint8_t mac[6];
+  esp_read_mac(mac, ESP_MAC_WIFI_STA);  // factory MAC from eFuse - valid before the Wi-Fi driver starts
+  char buf[5];
+  snprintf(buf, sizeof(buf), "%02X%02X", mac[4], mac[5]);
+  return String(buf);
+}
+
+void loadCreds(String& ssid, String& pass) {
+  prefs.begin("discstation", true);
+  ssid = prefs.getString("ssid", "");
+  pass = prefs.getString("pass", "");
+  prefs.end();
+}
+
+void saveCreds(const String& ssid, const String& pass) {
+  prefs.begin("discstation", false);
+  prefs.putString("ssid", ssid);
+  prefs.putString("pass", pass);
+  prefs.end();
+}
+
+void clearCreds() {
+  prefs.begin("discstation", false);
+  prefs.clear();
+  prefs.end();
+  WiFi.disconnect(true, true);   // also wipe the ESP's own persisted creds
+}
+
+void wmSaveCallback() {
+  saveCreds(wm.getWiFiSSID(), wm.getWiFiPass());
+  credsJustSaved = true;         // loop() reboots cleanly into STA mode
+}
+
+void onWifiUp() {
+  portalActive = false;
+  wifiConnected = true;
+  wifiDropAt = 0;
+  WiFi.setSleep(WIFI_PS_MIN_MODEM);
+  tcpServer.begin();
+  if (MDNS.begin(mdnsHost.c_str())) {
+    MDNS.addService("discstation", "tcp", TCP_PORT);
+  }
+#ifdef OTA_PASSWORD
+  ArduinoOTA.setHostname(mdnsHost.c_str());
+  ArduinoOTA.setPassword(OTA_PASSWORD);
+  ArduinoOTA.begin();
+  otaEnabled = true;
+#endif
+  Out.print("WiFi OK "); Out.println(WiFi.localIP());
+}
+
+void startPortal() {
+  Out.print("WiFi: setup portal '"); Out.print(apName); Out.println("'");
+  portalActive = true;
+  WiFi.mode(WIFI_AP_STA);
+  wm.setConfigPortalBlocking(false);
+  wm.setConfigPortalTimeout(0);
+  wm.setSaveConfigCallback(wmSaveCallback);
+  wm.startConfigPortal(apName.c_str());   // open AP at 192.168.4.1
+  drawSetup();
+}
+
 void initWiFi() {
-  Out.print("WiFi Tez...");
+  apName   = "DiscStation-" + deviceSuffix();
+  mdnsHost = "discstation-" + deviceSuffix();
+  mdnsHost.toLowerCase();
+
   WiFi.mode(WIFI_STA);
-  WiFi.begin("Tez", "Dellwin8#$");
-  for (int i = 0; i < 80; i++) {
-    if (WiFi.status() == WL_CONNECTED) break;
-    delay(250);
+  WiFi.setAutoReconnect(true);
+  WiFi.setSleep(WIFI_PS_MIN_MODEM);
+
+  String ssid, pass;
+#ifdef WIFI_SSID
+  ssid = WIFI_SSID;
+  pass = WIFI_PASS;
+#else
+  loadCreds(ssid, pass);
+#endif
+
+  if (ssid.length() > 0) {
+    Out.print("WiFi "); Out.print(ssid); Out.print("...");
+    WiFi.begin(ssid.c_str(), pass.c_str());
+    unsigned long t0 = millis();
+    while (WiFi.status() != WL_CONNECTED && millis() - t0 < WIFI_CONNECT_TIMEOUT_MS) {
+      esp_task_wdt_reset();
+      delay(200);
+    }
   }
+
   if (WiFi.status() == WL_CONNECTED) {
-    wifiConnected = true;
-    tcpServer.begin();
-    ArduinoOTA.begin();
-    ArduinoOTA.setHostname("discstation-v1");
-    ArduinoOTA.setPassword("dvdstation");
-    Out.print(" OK "); Out.println(WiFi.localIP());
+    Out.println(" OK");
+    onWifiUp();
   } else {
-    Out.println(" fail");
+    if (ssid.length() > 0) Out.println(" fail (2.4GHz band / wrong password?)");
+    startPortal();
   }
 }
 String discName = "";
@@ -89,7 +196,8 @@ enum UiState {
   UI_STANDBY,
   UI_WAITING,
   UI_IP,
-  UI_DISCONNECTED
+  UI_DISCONNECTED,
+  UI_SETUP
 };
 
 const char* BURN_MODES[BURN_COUNT] = {"AUTO", "BEST", "LONG", "TEST"};
@@ -143,6 +251,7 @@ bool editingSpeed = false;
 int playVolume = 50;
 unsigned long standbyStartTime = 0;
 unsigned long lastMsgTime = 0;
+unsigned long lastInputTime = 0;   // last button press / screen change; drives OLED idle-blank
 bool displayBlank = false;
 bool audioPlayMode = false;
 int displayRotation = 0;
@@ -210,6 +319,7 @@ void drawHeader() {
 void drawHome() {
   uiState = UI_HOME;
   returnToHomeAt = 0;
+  lastInputTime = millis();
   if (!displayOk) return;
 
   display.clearDisplay();
@@ -360,9 +470,13 @@ void drawIP() {
 }
 
 void drawStandby() {
+  // While the Wi-Fi setup portal is up and the appliance is otherwise idle,
+  // the standby screen doubles as the setup instructions.
+  if (portalActive) { drawSetup(); return; }
   uiState = UI_STANDBY;
   returnToHomeAt = 0;
   standbyStartTime = millis();
+  lastInputTime = millis();
   displayBlank = false;
   if (!displayOk) return;
 
@@ -375,6 +489,39 @@ void drawStandby() {
   display.display();
 }
 
+void drawSetup() {
+  uiState = UI_SETUP;
+  returnToHomeAt = 0;
+  displayBlank = false;
+  lastInputTime = millis();
+  if (!displayOk) return;
+
+  display.clearDisplay();
+  drawHeader();
+  display.setCursor(2, 16);
+  display.print("WIFI SETUP");
+  display.setCursor(2, 28);
+  display.print("JOIN:");
+  display.setCursor(2, 38);
+  printUpper(apName);
+  display.setCursor(2, 50);
+  display.print("THEN 192.168.4.1");
+  display.display();
+}
+
+void drawWifiReset() {
+  uiState = UI_SETUP;
+  displayBlank = false;
+  if (!displayOk) return;
+  display.clearDisplay();
+  drawHeader();
+  display.setCursor(2, 25);
+  display.print("WIFI RESET");
+  display.setCursor(2, 40);
+  display.print("REBOOTING...");
+  display.display();
+}
+
 void drawDisconnected() {
   uiState = UI_DISCONNECTED;
   returnToHomeAt = 0;
@@ -403,6 +550,7 @@ void wakeDisplay() {
     case UI_WAITING: drawWaiting(); break;
     case UI_STANDBY: drawStandby(); break;
     case UI_DISCONNECTED: drawDisconnected(); break;
+    case UI_SETUP: drawSetup(); break;
   }
 }
 
@@ -602,6 +750,7 @@ void parseMessage(String msg) {
 }
 
 void setup() {
+  setCpuFrequencyMhz(160);  // 240 -> 160: ~halves CPU power, Wi-Fi/I2C/OTA all fine at 160
   Serial.begin(115200);
   esp_task_wdt_add(NULL);
   Wire.begin(21, 22);
@@ -639,11 +788,13 @@ void setup() {
 
   drawStandby();
   lastMsgTime = millis();
+  lastInputTime = millis();
   Out.println("DISCSTATION_READY");
 }
 
 void handleSelectPress(bool longPress) {
   wakeDisplay();
+  lastInputTime = millis();
   if (uiState == UI_HOME) {
     if (longPress) {
       Out.println("EJECT");
@@ -733,6 +884,7 @@ void handleSelectPress(bool longPress) {
 
 void handleUp(bool longPress) {
   wakeDisplay();
+  lastInputTime = millis();
   if (uiState == UI_HOME) {
     if (homeCount > 0) {
       homeIndex = (homeIndex - 1 + homeCount) % homeCount;
@@ -772,6 +924,7 @@ void handleUp(bool longPress) {
 
 void handleDown(bool longPress) {
   wakeDisplay();
+  lastInputTime = millis();
   if (uiState == UI_HOME) {
     if (homeCount > 0) {
       homeIndex = (homeIndex + 1) % homeCount;
@@ -814,8 +967,33 @@ void loop() {
     wifiInitDone = true;
     initWiFi();
   }
-  if (wifiConnected) {
-    ArduinoOTA.handle();
+
+  if (credsJustSaved) {          // portal saved new creds -> reboot into clean STA
+    drawWifiReset();
+    delay(600);
+    ESP.restart();
+  }
+
+  if (portalActive) {
+    wm.process();
+    if (WiFi.status() == WL_CONNECTED) onWifiUp();
+  }
+
+  // Live link dropped: WiFi.setAutoReconnect handles most; if still down after
+  // WIFI_RETRY_MS, force a fresh join.
+  if (wifiConnected && WiFi.status() != WL_CONNECTED) {
+    if (wifiDropAt == 0) wifiDropAt = millis();
+    else if (millis() - wifiDropAt > WIFI_RETRY_MS) {
+      wifiDropAt = millis();
+      WiFi.disconnect();
+      WiFi.begin();
+    }
+  } else if (wifiConnected) {
+    wifiDropAt = 0;
+  }
+
+  if (wifiConnected && WiFi.status() == WL_CONNECTED) {
+    if (otaEnabled) ArduinoOTA.handle();
     if (tcpServer.hasClient()) {
       if (tcpClient) tcpClient.stop();
       tcpClient = tcpServer.available();
@@ -865,11 +1043,27 @@ void loop() {
     if (sel && !selectDown && millis() - selectLastDebounce > DEBOUNCE_MS) {
       selectDown = true;
       selectDownAt = millis();
+      wifiResetArmed = false;
+    }
+    // 10s hold on HOME (or SETUP) = wipe Wi-Fi creds + reboot to portal. Fires
+    // while still held so the eventual release doesn't also trigger EJECT.
+    if (sel && selectDown && !wifiResetArmed &&
+        (uiState == UI_HOME || uiState == UI_SETUP || uiState == UI_STANDBY) &&
+        millis() - selectDownAt >= WIFI_RESET_HOLD_MS) {
+      wifiResetArmed = true;
+      Out.println("WiFi: creds wiped, rebooting");
+      clearCreds();
+      drawWifiReset();
+      delay(800);
+      ESP.restart();
     }
     if (!sel && selectDown) {
       selectDown = false;
       selectLastDebounce = millis();
-      handleSelectPress(millis() - selectDownAt >= LONG_PRESS_MS);
+      if (!wifiResetArmed) {
+        handleSelectPress(millis() - selectDownAt >= LONG_PRESS_MS);
+      }
+      wifiResetArmed = false;
     }
   }
 
@@ -915,9 +1109,10 @@ void loop() {
     if (!displayBlank) drawStatus();
   }
 
-  // --- Standby blanking ---
-  if (displayOk && uiState == UI_STANDBY && !displayBlank &&
-      (long)(millis() - standbyStartTime) >= STANDBY_BLANK_MS) {
+  // --- OLED idle blanking (HOME + STANDBY) ---
+  if (displayOk && !displayBlank &&
+      (uiState == UI_HOME || uiState == UI_STANDBY) &&
+      (long)(millis() - lastInputTime) >= IDLE_BLANK_MS) {
     display.ssd1306_command(0xAE);
     displayBlank = true;
     digitalWrite(LED_POWER_PIN, LOW);

package/arduino/v1/secrets.h.example

@@ -0,0 +1,14 @@
+// Optional build-time Wi-Fi override for the ESP32 DevKit remote.
+//
+//   cp secrets.h.example secrets.h      (secrets.h is git-ignored)
+//
+// If WIFI_SSID is defined, the firmware connects straight to this network and
+// the runtime setup portal is skipped entirely. Leave secrets.h absent to use
+// the normal captive-portal provisioning ("DiscStation-XXXX" AP).
+
+#define WIFI_SSID  "YourNetwork"
+#define WIFI_PASS  "YourPassword"
+
+// Optional: enable Arduino OTA updates with this password. Omit to keep OTA off
+// (recommended unless you actually use it).
+// #define OTA_PASSWORD "change-me"

package/discstation.env.example

@@ -7,6 +7,13 @@ YTDLP_FRAGMENT_RETRIES=3
 DISC_OUTPUT_LIMIT_BYTES=4300000000
 DISC_DL_OUTPUT_LIMIT_BYTES=8000000000
 
+# Wi-Fi appliance remote. Default (unset) = "auto": if no USB cable is
+# present, find the remote by mDNS / discstation.local. Set an IP or
+# hostname to skip discovery (connects on TCP 2323); set "off" to never
+# look. The remote's OLED shows its IP after you provision its Wi-Fi.
+# DISC_REMOTE_HOST=192.168.1.50
+# DISC_REMOTE_HOST=off
+
 # TMDb API key for video (DVD / burned movie) metadata lookup. Get a free key at
 # https://www.themoviedb.org/settings/api . Without it, ripped videos keep their
 # disc-label / filename naming. Alternatively put the key in

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discstation",
-  "version": "0.1.23",
+  "version": "0.1.26",
   "description": "DiscStation optical-media appliance host — one cross-OS installer",
   "bin": {
     "discstation-setup": "scripts/setup.mjs",

package/requirements.txt

@@ -3,3 +3,4 @@ pyserial>=3.5
 mutagen>=1.45
 requests>=2.28
 yt-dlp>=2024.1.1
+zeroconf>=0.131   # auto-discover a Wi-Fi appliance remote (DISC_REMOTE_HOST=auto, the default)

package/src/discstation.py

@@ -114,9 +114,87 @@ class VirtualSerial:
         pass
 
 
+class TcpSerial:
+    """serial.Serial look-alike over a TCP socket to the ESP32's Wi-Fi link
+    (firmware's WiFiServer on port 2323). Exposes the same tiny surface
+    station_loop and the flow functions use - write / readline / in_waiting /
+    read / close / setDTR - so nothing downstream knows it isn't a wire.
+    A dead link raises serial.SerialException from in_waiting/write, which is
+    what check_serial_alive() / main()'s reconnect loop already expect."""
+
+    def __init__(self, host, port=2323, connect_timeout=5):
+        if host.count(":") == 1 and not host.startswith("["):  # "ip:port"
+            host, _, p = host.rpartition(":")
+            if p.isdigit():
+                port = int(p)
+        self._sock = socket.create_connection((host, port), timeout=connect_timeout)
+        self._sock.settimeout(0.05)
+        self._buf = b""
+        self._lock = threading.Lock()
+        self._alive = True
+        self._reader = threading.Thread(target=self._pump, daemon=True)
+        self._reader.start()
+
+    def _pump(self):
+        while self._alive:
+            try:
+                chunk = self._sock.recv(4096)
+            except socket.timeout:
+                continue
+            except OSError:
+                break
+            if not chunk:
+                break
+            with self._lock:
+                self._buf += chunk
+        self._alive = False
+
+    @property
+    def in_waiting(self):
+        if not self._alive:
+            raise serial.SerialException("Wi-Fi remote link closed")
+        with self._lock:
+            return len(self._buf)
+
+    def read(self, n=1):
+        with self._lock:
+            data, self._buf = self._buf[:n], self._buf[n:]
+            return data
+
+    def readline(self):
+        with self._lock:
+            idx = self._buf.find(b"\n")
+            if idx < 0:
+                data, self._buf = self._buf, b""
+                return data
+            line, self._buf = self._buf[:idx + 1], self._buf[idx + 1:]
+            return line
+
+    def write(self, data):
+        if not self._alive:
+            raise serial.SerialException("Wi-Fi remote link closed")
+        try:
+            self._sock.sendall(data)
+            return len(data) if data else 0
+        except OSError as e:
+            self._alive = False
+            raise serial.SerialException(f"Wi-Fi remote write failed: {e}") from e
+
+    def close(self):
+        self._alive = False
+        try:
+            self._sock.close()
+        except OSError:
+            pass
+
+    def setDTR(self, value):
+        pass
+
+
 class _HardwareAttached(Exception):
-    """Raised out of station_loop when a real ESP32 appears while running on
-    a VirtualSerial, so main() can hand control over to it."""
+    """Raised out of station_loop when a real link (USB serial or the Wi-Fi
+    remote) appears while running on a VirtualSerial, so main() can hand
+    control over to it."""
 
 
 class _WebHandler(http.server.BaseHTTPRequestHandler):
@@ -825,7 +903,12 @@ _line_buf = b""
 def read_serial_line(ser, timeout=0.1):
     global _line_buf
     deadline = time.monotonic() + timeout
-    while time.monotonic() < deadline:
+    # Always make at least one non-blocking pass, even for timeout<=0 - the
+    # `remaining <= 0: break` at the bottom still ends it after that pass.
+    # (`while time.monotonic() < deadline` used to skip the body entirely for
+    # timeout=0, which is exactly how _check_cancel() calls this - so cancel
+    # detection during rips silently never read the port.)
+    while True:
         if _line_buf:
             _line_buf = _line_buf.lstrip(b'\r\n')
             if _line_buf:
@@ -870,6 +953,10 @@ def read_serial_line(ser, timeout=0.1):
     return None
 
 
+# Let the burn pipeline's check_cancel() share this buffered reader.
+discstation_burn.line_reader = read_serial_line
+
+
 def check_serial_alive(ser=None):
     """Raise serial.SerialException if the ESP32 link looks dead, so main()'s
     reconnect loop can re-scan for the (possibly renumbered) serial port.
@@ -2526,6 +2613,15 @@ def _check_cancel(ser):
         return False
 
 
+def _raise_if_cancelled(ser):
+    """Poll for a CANCEL press between blocking phases that have no
+    subprocess loop of their own (metadata lookups, scans, cover-art
+    downloads). Doesn't interrupt a call in progress, but catches the press
+    the moment the phase returns."""
+    if _check_cancel(ser):
+        raise CancelError
+
+
 def iter_process_events(proc, idle_seconds=1.0, ser=None):
     lines = Queue()
     finished = object()
@@ -3221,7 +3317,13 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
         except Exception:
             pass
 
-    proc = subprocess.Popen(run_as_desktop_user(cmd), env=env)
+    # Discard mpv's own output. Its terminal status line ("A: 00:04 / 00:15
+    # ...") prints several times a second; left inheriting our stdout it
+    # floods journald until the pipe backs up and our own print()/status
+    # writes block, wedging the whole play loop. We drive mpv over the IPC
+    # socket, so none of that output is wanted.
+    proc = subprocess.Popen(run_as_desktop_user(cmd), env=env,
+                            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
     try:
         if not wait_for_socket(MPV_SOCKET, proc):
@@ -3275,7 +3377,10 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
                     mpv_command(["set_property", "speed", 1.0])
                     send(ser, "PLAY_STATUS:PAUSED" if paused else "PLAY_STATUS:PLAYING")
 
-                elif line == "PLAY_STOP":
+                elif line in ("PLAY_STOP", "EJECT"):
+                    # EJECT during playback = stop first; the web remote has no
+                    # separate stop button, and without this the command is
+                    # silently dropped here and playback never ends.
                     send(ser, "STATUS:Stopping play")
                     discstation_burn.stop_process(proc)
                     break
@@ -3760,7 +3865,10 @@ def rip_flow(ser, artist_hint=None, album_hint=None):
         time.sleep(3)
         return
 
+    _raise_if_cancelled(ser)
+    send(ser, "STATUS:Scanning disc...")
     scan = handbrake_scan(device)
+    _raise_if_cancelled(ser)
     if scan:
         main = scan["main_feature"]
         mins = next((t["duration_s"] // 60 for t in scan["titles"] if t["index"] == main), 0)
@@ -3863,6 +3971,7 @@ def rip_video_disc(ser, device, kind):
             raise RuntimeError("No video files found")
 
         for index, src in enumerate(files, start=1):
+            _raise_if_cancelled(ser)
             send(ser, f"PROGRESS:File {index}/{len(files)}")
             dest = out_dir / f"{index:02d} - {safe_path_name(src.stem)}.mpg"
             print(f"Ripping {src.name} -> {dest.name}")
@@ -3923,6 +4032,7 @@ def _rip_audio_cd_macos(ser, device, chapters, metadata, cover_path, out_dir):
     if len(wav_files) < len(chapters):
         raise RuntimeError(f"Only ripped {len(wav_files)}/{len(chapters)} tracks")
     for index, wav in enumerate(wav_files[:len(chapters)], start=1):
+        _raise_if_cancelled(ser)
         chapter = chapters[index - 1]
         if metadata and index <= len(metadata["tracks"]):
             track_meta = metadata["tracks"][index - 1]
@@ -3958,8 +4068,10 @@ def rip_audio_cd(ser, device, artist_hint=None, album_hint=None):
     metadata = None
     cover_path = None
 
+    _raise_if_cancelled(ser)
     send(ser, "STATUS:Looking up CD...")
     metadata = audio_metadata_lookup(device, len(chapters), artist_hint, album_hint)
+    _raise_if_cancelled(ser)
 
     if metadata:
         album_folder = safe_path_name(f"{metadata['album_artist']} - {metadata['album']}")
@@ -3978,6 +4090,7 @@ def rip_audio_cd(ser, device, artist_hint=None, album_hint=None):
             out_dir,
             metadata.get("release_group_id"),
         )
+        _raise_if_cancelled(ser)
 
     send(ser, "STATUS:Ripping audio CD")
     if metadata:
@@ -4222,14 +4335,15 @@ def station_loop(ser, url, artist_hint=None, album_hint=None):
             last_ping = now
             safe_send(ser, "PING")
             if isinstance(ser, VirtualSerial):
-                # Safe point (no flow active) to check whether a real ESP32
-                # has appeared - hand off to it instead of the web remote.
+                # Safe point (no flow active) to check whether a real link -
+                # USB serial or the Wi-Fi remote - has appeared, and hand off
+                # to it instead of the web remote.
                 try:
-                    port = discstation_host.serial_port()
+                    link = discstation_host.serial_port() or discstation_host.remote_host()
                 except Exception:
-                    port = None
-                if port:
-                    raise _HardwareAttached(port)
+                    link = None
+                if link:
+                    raise _HardwareAttached(link)
             else:
                 check_serial_alive(ser)
 
@@ -4348,6 +4462,11 @@ def station_loop(ser, url, artist_hint=None, album_hint=None):
 
         except KeyboardInterrupt:
             raise
+        except CancelError:
+            safe_send(ser, "CANCELLED:Cancelled")
+            _last_burn_result = "Cancelled"
+            print(f"{mode} cancelled by user")
+            time.sleep(2)
         except Exception as e:
             safe_send(ser, f"ERROR:{str(e)[:50]}")
             _last_burn_result = f"ERROR: {e}"
@@ -4433,6 +4552,9 @@ def main():
         while True:
             try:
                 _line_buf = b""
+                ser = None
+
+                # 1. USB serial wins whenever it's present (no mDNS scan then).
                 port = discstation_host.serial_port()
                 if port:
                     print(f"Using ESP32 serial port: {port}")
@@ -4444,10 +4566,23 @@ def main():
                     time.sleep(2)
                     discstation_burn.reset_serial_state()
                     _appliance_mode = "hardware"
-                else:
-                    # No ESP32 found - run fully useful off the on-screen web
-                    # remote instead of retrying forever (station_loop already
-                    # publishes status via status_sink regardless of ser).
+
+                # 2. Else look for a Wi-Fi remote (DISC_REMOTE_HOST, default auto/mDNS).
+                if ser is None:
+                    remote = discstation_host.remote_host()
+                    if remote:
+                        try:
+                            print(f"Connecting to Wi-Fi remote at {remote}:2323 ...")
+                            ser = TcpSerial(remote)
+                            discstation_burn.reset_serial_state()
+                            _appliance_mode = "hardware"
+                            print(f"Wi-Fi remote link up ({remote}).")
+                        except OSError as e:
+                            print(f"Wi-Fi remote {remote} unreachable ({e}); using web remote.")
+                            ser = None
+
+                # 3. Else the on-screen web/app remote is the control surface.
+                if ser is None:
                     print("No ESP32 found - running in software-only mode (web remote).")
                     ser = VirtualSerial()
                     _appliance_mode = "software"