discstation 0.1.29 → 0.1.31

package/arduino/{v1 → DiscStation}/DiscStation.ino

@@ -22,20 +22,31 @@
 #define OLED_RESET    -1
 #define I2C_ADDRESS   0x3C
 
-#define BTN_SELECT_PIN  14
-#define BTN_UP_PIN      13
-#define BTN_DOWN_PIN    15
-#define POT_PIN         34
+#define BTN_EJECT_PIN     14  // was SELECT
+#define BTN_HOME_PIN      13  // was UP; also carries the 10s Wi-Fi-reset hold
+#define BTN_PLAYPAUSE_PIN 15  // was DOWN
+#define ENC_CLK_PIN       32  // freed ex-LED pin
+#define ENC_DT_PIN        33  // freed ex-LED pin
+#define ENC_SW_PIN         4  // encoder's click switch
 
 #define DEBOUNCE_MS      50
 #define LONG_PRESS_MS    1000
-#define POT_READ_MS      200
+#define ENC_CLICK_GUARD_MS 200  // ignore new SW presses this soon after a rotation tick (rotation vibration can bounce SW low)
 #define DONE_RESET_MS    30000
 #define STANDBY_BLANK_MS 60000
-#define IDLE_BLANK_MS    45000   // no input this long on HOME/STANDBY -> spinning-disc screensaver
+#define IDLE_BLANK_MS    15000   // no input this long on HOME/STANDBY -> spinning-disc screensaver
+                                 // (this power bank's no-load auto-shutoff trips at ~30s idle; keep this
+                                 // well under that so the screensaver's current draw beats it there)
 #define SAVER_FRAME_MS   90      // screensaver frame interval (~11fps)
 #define PING_TIMEOUT_MS  30000
 
+#define VU_BARS       16   // must match the host's VU: band count
+#define VU_TIMEOUT_MS 1200 // no VU: update this long -> host isn't sending (paused/stopped), fall back to text
+                           // (generous on purpose: the host's capture thread can jitter under load on a Pi -
+                           // too tight and normal jitter flickers between bars and the text screen)
+#define VU_ENTRY_DELAY_MS  10000  // stay on the text status screen this long after entering PLAY
+#define VU_RESUME_DELAY_MS  7000  // ...and this long after any input while already in PLAY
+
 #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           15000  // if a live link drops, force a re-join after this
@@ -81,6 +92,7 @@ private:
 
 void drawSetup();       // fwd decls (defined with the other draw* below)
 void drawWifiReset();
+void drawPlayVisualizer();
 
 String deviceSuffix() {
   uint8_t mac[6];
@@ -218,32 +230,32 @@ bool displayOk = false;
 unsigned long returnToHomeAt = 0;
 unsigned long playStatusAt = 0;
 bool playStatusTemp = false;
-unsigned long lastPotRead = 0;
 
-// Select button state
-unsigned long selectDownAt = 0;
-bool selectDown = false;
-unsigned long selectLastDebounce = 0;
+// Encoder click (SW) - short/long press state, same shape as the old SELECT button
+unsigned long encClickDownAt = 0;
+bool encClickDown = false;
+unsigned long encClickLastDebounce = 0;
 
-// Up button state
-unsigned long upDownAt = 0;
-bool upDown = false;
-unsigned long upLastDebounce = 0;
+// EJECT button - single press, no long-press timer needed
+bool ejectDown = false;
+unsigned long ejectLastDebounce = 0;
 
-// Down button state
-unsigned long downDownAt = 0;
-bool downDown = false;
-unsigned long downLastDebounce = 0;
+// HOME/BACK button - single press; also carries the 10s Wi-Fi-reset hold
+unsigned long homeDownAt = 0;
+bool homeDown = false;
+unsigned long homeLastDebounce = 0;
 
-// FF/REW speed state (used by UP/DOWN during playback)
-int ffSpeedIndex = 0;
-int rewSpeedIndex = 0;
+// PLAY/PAUSE button - short = pause/resume, long = stop
+unsigned long playpauseDownAt = 0;
+bool playpauseDown = false;
+unsigned long playpauseLastDebounce = 0;
 
 int homeIndex = 0;
 int burnModeIndex = 0;
 int burnSpeedIndex = 0;
 bool editingSpeed = false;
 int playVolume = 50;
+bool playSeekMode = false;   // false = encoder rotate adjusts volume (default); true = seek/track-skip
 unsigned long standbyStartTime = 0;
 unsigned long lastMsgTime = 0;
 unsigned long lastInputTime = 0;   // last button press / screen change; drives the idle screensaver
@@ -251,26 +263,70 @@ bool displayBlank = false;          // true = real UI hidden, disc screensaver r
 unsigned long lastSaverFrame = 0;
 int saverStep = 0;
 bool audioPlayMode = false;
+
+// Spectrum visualizer: host streams real playback levels as "VU:v0,v1,...".
+// While they keep arriving, PLAY shows full-screen bars instead of the usual
+// status text; VU_TIMEOUT_MS after they stop (paused/stopped host-side) it
+// falls back to the normal drawPlay() screen.
+uint8_t vuLevel[VU_BARS];
+bool visualizerActive = false;
+unsigned long lastVuAt = 0;
+unsigned long vuSuppressUntil = 0;   // bars withheld (text screen shown instead) until millis() reaches this
 int displayRotation = 0;
 
 // Indeterminate progress animation
 int indeterminateCount = 0;
 unsigned long lastIndeterminateAnim = 0;
 
-int readBucket(int count) {
-  int raw = analogRead(POT_PIN);
-  int idx = raw * count / 4096;
-  if (idx < 0) idx = 0;
-  if (idx >= count) idx = count - 1;
-  return idx;
-}
+// --- Rotary encoder decode ---
+// Ben Buxton's full-step quadrature state machine (the standard robust
+// rotary-encoder algorithm, e.g. the basis of the Arduino "Rotary" library).
+// Reads BOTH pins on every change and only commits a tick after a complete,
+// valid 4-transition sequence - contact bounce just walks between
+// non-committing states instead of producing a spurious tick, so no time
+// debounce is needed. (An earlier CLK-only + micros()-debounce version read
+// just one pin's level at one instant, which is fragile - CLK and DT edges
+// aren't perfectly synchronized on a mechanical encoder, so bounce right at
+// the sample instant could misread direction or double-fire: skipped,
+// doubled, and wrong-direction ticks. That simpler decode was chosen to
+// lighten interrupt load for the dead XIAO ESP32-C6's fragile native-USB
+// link; the current board's CP2102 bridge isn't affected by that at all.)
+#define ENC_R_START     0x0
+#define ENC_R_CW_FINAL  0x1
+#define ENC_R_CW_BEGIN  0x2
+#define ENC_R_CW_NEXT   0x3
+#define ENC_R_CCW_BEGIN 0x4
+#define ENC_R_CCW_FINAL 0x5
+#define ENC_R_CCW_NEXT  0x6
+#define ENC_DIR_CW  0x10
+#define ENC_DIR_CCW 0x20
+
+const uint8_t ENC_TTABLE[7][4] = {
+  {ENC_R_START,    ENC_R_CW_BEGIN,  ENC_R_CCW_BEGIN, ENC_R_START},
+  {ENC_R_CW_NEXT,  ENC_R_START,     ENC_R_CW_FINAL,  ENC_R_START | ENC_DIR_CW},
+  {ENC_R_CW_NEXT,  ENC_R_CW_BEGIN,  ENC_R_START,     ENC_R_START},
+  {ENC_R_CW_NEXT,  ENC_R_CW_BEGIN,  ENC_R_CW_FINAL,  ENC_R_START},
+  {ENC_R_CCW_NEXT, ENC_R_START,     ENC_R_CCW_BEGIN, ENC_R_START},
+  {ENC_R_CCW_NEXT, ENC_R_CCW_FINAL, ENC_R_START,     ENC_R_START | ENC_DIR_CCW},
+  {ENC_R_CCW_NEXT, ENC_R_CCW_FINAL, ENC_R_CCW_BEGIN, ENC_R_START},
+};
 
-int readPercent() {
-  int raw = analogRead(POT_PIN);
-  int pct = raw * 100 / 4095;
-  if (pct < 0) pct = 0;
-  if (pct > 100) pct = 100;
-  return ((pct + 2) / 5) * 5;
+volatile uint8_t encState = ENC_R_START;
+volatile int16_t encTicks = 0;   // whole detents ready for loop() to drain
+volatile uint32_t encLastActivityMs = 0;   // refreshed on every raw pin transition, not just
+                                            // committed ticks - guards handleSelectPress's SW
+                                            // read against bounce/crosstalk from a spin in progress
+
+void IRAM_ATTR encoderISR() {
+  encLastActivityMs = millis();
+  uint8_t pinState = (digitalRead(ENC_DT_PIN) << 1) | digitalRead(ENC_CLK_PIN);
+  encState = ENC_TTABLE[encState & 0xF][pinState];
+  uint8_t dir = encState & 0x30;
+  // Flipped from the table's literal CW/CCW so the tick sign matches this
+  // encoder's physical wiring: turning the knob clockwise should increase
+  // (next track, volume up), not decrease.
+  if (dir == ENC_DIR_CW) encTicks--;
+  else if (dir == ENC_DIR_CCW) encTicks++;
 }
 
 void sendHomeMode() {
@@ -585,7 +641,11 @@ bool wakeDisplay() {
     case UI_STATUS: drawStatus(); break;
     case UI_IP: drawIP(); break;
     case UI_BURN_READY: drawBurnReady(); break;
-    case UI_PLAY: drawPlay(); break;
+    case UI_PLAY:
+      if (visualizerActive && (long)(millis() - lastVuAt) < VU_TIMEOUT_MS &&
+          (long)(millis() - vuSuppressUntil) >= 0) drawPlayVisualizer();
+      else drawPlay();
+      break;
     case UI_WAITING: drawWaiting(); break;
     case UI_STANDBY: drawStandby(); break;
     case UI_DISCONNECTED: drawDisconnected(); break;
@@ -594,9 +654,35 @@ bool wakeDisplay() {
   return true;
 }
 
+#define VU_TOP_MARGIN 16   // px of empty headroom above the tallest possible bar
+
+// Full-screen-width spectrum bars, no header/chrome, capped short of the top
+// edge (VU_TOP_MARGIN) so a loud peak doesn't run the panel edge-to-edge.
+// Falls back to the normal drawPlay() text screen once VU: updates stop
+// arriving (see VU_TIMEOUT_MS in loop()).
+void drawPlayVisualizer() {
+  uiState = UI_PLAY;
+  returnToHomeAt = 0;
+  if (!displayOk) return;
+
+  display.clearDisplay();
+  const int gap = 2;
+  const int maxH = SCREEN_HEIGHT - VU_TOP_MARGIN;
+  const int barW = (SCREEN_WIDTH - gap * (VU_BARS - 1)) / VU_BARS;
+  int x = (SCREEN_WIDTH - (barW * VU_BARS + gap * (VU_BARS - 1))) / 2;
+  for (int i = 0; i < VU_BARS; i++) {
+    int h = map(vuLevel[i], 0, 63, 0, maxH);
+    if (h > 0) display.fillRect(x, SCREEN_HEIGHT - h, barW, h, SSD1306_WHITE);
+    x += barW + gap;
+  }
+  display.display();
+}
+
 void drawPlay() {
   uiState = UI_PLAY;
   returnToHomeAt = 0;
+  lastInputTime = millis();   // real status content (track change, pause/resume) gets a full
+                               // IDLE_BLANK_MS on screen before the screensaver reclaims it
   if (!displayOk) return;
 
   display.clearDisplay();
@@ -607,13 +693,16 @@ void drawPlay() {
   display.setCursor(2, 30);
   printUpper(line2);
   display.setCursor(2, 44);
-  display.print("VOL // ");
-  display.print(playVolume);
-  display.print("%");
-  if (!audioPlayMode) {
-    display.setCursor(2, 56);
-    display.print("SELECT // PLAY");
+  if (playSeekMode) {
+    display.print(audioPlayMode ? "TURN // SKIP TRACK" : "TURN // SEEK");
+  } else {
+    display.print("VOL // ");
+    display.print(playVolume);
+    display.print("%");
   }
+  display.setCursor(2, 56);
+  display.print("CLICK // ");
+  display.print(playSeekMode ? "VOL MODE" : "SEEK MODE");
 
   display.display();
 }
@@ -628,6 +717,28 @@ void parseMessage(String msg) {
     return;
   }
 
+  if (msg.startsWith("VU:")) {
+    // No wakeDisplay()/RCV echo here - this arrives ~15x/sec while playing,
+    // wakeDisplay() would draw stale bars a frame early, and echoing it
+    // would spam the serial log for no reason.
+    lastMsgTime = millis();
+    String rest = msg.substring(3);
+    for (int i = 0; i < VU_BARS; i++) vuLevel[i] = 0;
+    for (int i = 0; i < VU_BARS && rest.length() > 0; i++) {
+      int comma = rest.indexOf(',');
+      String tok = (comma < 0) ? rest : rest.substring(0, comma);
+      vuLevel[i] = (uint8_t)constrain(tok.toInt(), 0, 63);
+      if (comma < 0) break;
+      rest = rest.substring(comma + 1);
+    }
+    visualizerActive = true;
+    lastVuAt = millis();
+    lastInputTime = millis();   // the visualizer's own continuous redraw already beats the
+                                 // power-bank shutoff - no need for the screensaver too
+    if (uiState == UI_PLAY && (long)(millis() - vuSuppressUntil) >= 0) drawPlayVisualizer();
+    return;
+  }
+
   wakeDisplay();
   lastMsgTime = millis();
 
@@ -635,7 +746,6 @@ void parseMessage(String msg) {
   Out.println(msg);
 
   if (msg.startsWith("HOME:")) {
-    homeIndex = readBucket(homeCount);
     drawHome();
 
   } else if (msg.startsWith("DISC:")) {
@@ -669,7 +779,6 @@ void parseMessage(String msg) {
   } else if (msg.startsWith("TITLE:")) {
     titleLine = msg.substring(6);
     if (titleLine.length() > 20) titleLine = titleLine.substring(0, 20);
-    burnModeIndex = readBucket(BURN_COUNT);
     drawBurnReady();
 
   } else if (msg.startsWith("META:")) {
@@ -685,8 +794,9 @@ void parseMessage(String msg) {
   } else if (msg.startsWith("PLAY:")) {
     line1 = msg.substring(5);
     line2 = "Playing disc";
-    playVolume = readPercent();
-    Out.print("POT:");            // push the knob's current level so playback starts at it
+    playSeekMode = false;          // always start in volume mode
+    vuSuppressUntil = millis() + VU_ENTRY_DELAY_MS;   // text screen first, bars after a beat
+    Out.print("POT:");             // push the last-used volume so playback starts at it
     Out.println(playVolume);
     drawPlay();
 
@@ -796,16 +906,16 @@ void setup() {
   Serial.begin(115200);
   esp_task_wdt_add(NULL);
   Wire.begin(21, 22);
-  pinMode(BTN_SELECT_PIN, INPUT_PULLUP);
-  pinMode(BTN_UP_PIN, INPUT_PULLUP);
-  pinMode(BTN_DOWN_PIN, INPUT_PULLUP);
-  pinMode(POT_PIN, INPUT);
-  analogReadResolution(12);
-  analogSetPinAttenuation(POT_PIN, ADC_11db);
-
-  homeIndex = readBucket(homeCount);
-  burnModeIndex = readBucket(BURN_COUNT);
-  playVolume = readPercent();
+  Wire.setClock(400000);   // SSD1306 supports I2C fast-mode; the default 100kHz was too slow to
+                           // push a full 128x64 frame at the visualizer's ~15fps without stutter
+  pinMode(BTN_EJECT_PIN, INPUT_PULLUP);
+  pinMode(BTN_HOME_PIN, INPUT_PULLUP);
+  pinMode(BTN_PLAYPAUSE_PIN, INPUT_PULLUP);
+  pinMode(ENC_SW_PIN, INPUT_PULLUP);
+  pinMode(ENC_CLK_PIN, INPUT_PULLUP);
+  pinMode(ENC_DT_PIN, INPUT_PULLUP);
+  attachInterrupt(digitalPinToInterrupt(ENC_CLK_PIN), encoderISR, CHANGE);
+  attachInterrupt(digitalPinToInterrupt(ENC_DT_PIN), encoderISR, CHANGE);
 
   displayOk = display.begin(SSD1306_SWITCHCAPVCC, I2C_ADDRESS);
 
@@ -898,100 +1008,163 @@ void handleSelectPress(bool longPress) {
     Out.println("CANCEL");
     drawStandby();
 
-  } else if (uiState == UI_STANDBY) {
-    displayRotation = 2;
-    drawStandby();
   } else if (uiState == UI_PLAY) {
-    ffSpeedIndex = 0;
-    rewSpeedIndex = 0;
+    vuSuppressUntil = millis() + VU_RESUME_DELAY_MS;   // any PLAY input -> back to text for a beat
     if (longPress) {
       Out.println("PLAY_STOP");
     } else {
-      Out.println("PLAY_BUTTON");
+      playSeekMode = !playSeekMode;   // encoder click swaps what rotating does
+      drawPlay();
     }
   }
 }
 
-void handleUp(bool longPress) {
-  if (wakeDisplay()) { lastInputTime = millis(); return; }  // wake-only press, swallow the action
+// Encoder rotation replaces UP/DOWN. One tick = one detent (see encoderISR).
+// STANDBY's displayRotation flip and BURN_READY's mode/speed scroll are
+// otherwise unchanged from the old UP/DOWN behavior. PLAY defaults to
+// adjusting volume; a short encoder click (see handleSelectPress) swaps it
+// to seek/track-skip instead - there's only one rotate axis now, where
+// before the pot (volume) and UP/DOWN (seek) were independent.
+void handleEncoderCW() {
+  if (wakeDisplay()) { lastInputTime = millis(); return; }  // wake-only turn, swallow the action
   lastInputTime = millis();
   if (uiState == UI_HOME) {
     if (homeCount > 0) {
-      homeIndex = (homeIndex - 1 + homeCount) % homeCount;
+      homeIndex = (homeIndex + 1) % homeCount;
       sendHomeMode();
       drawHome();
     }
   } else if (uiState == UI_BURN_READY) {
     if (editingSpeed) {
-      burnSpeedIndex = (burnSpeedIndex - 1 + SPEED_COUNT) % SPEED_COUNT;
+      burnSpeedIndex = (burnSpeedIndex + 1) % SPEED_COUNT;
       Out.print("SPEED:");
       Out.println(SPEED_MODES[burnSpeedIndex]);
       drawBurnReady();
     } else {
-      burnModeIndex = (burnModeIndex - 1 + BURN_COUNT) % BURN_COUNT;
+      burnModeIndex = (burnModeIndex + 1) % BURN_COUNT;
       sendBurnMode();
       drawBurnReady();
     }
   } else if (uiState == UI_STANDBY) {
-    displayRotation = 0;
+    displayRotation = 2;
     drawStandby();
   } else if (uiState == UI_PLAY) {
-    if (audioPlayMode) {
-      Out.println(displayRotation == 0 ? (longPress ? "REW:BIG" : "REW:10") : (longPress ? "FF:BIG" : "FF:10"));
-      return;
-    }
-    rewSpeedIndex = 0;
-    if (longPress) {
-      Out.println("FF:BIG");
+    vuSuppressUntil = millis() + VU_RESUME_DELAY_MS;   // any PLAY input -> back to text for a beat
+    if (!playSeekMode) {
+      playVolume = min(100, playVolume + 5);
+      Out.print("POT:");
+      Out.println(playVolume);
+      drawPlay();
+    } else if (audioPlayMode) {
+      Out.println(displayRotation == 0 ? "FF:BIG" : "REW:BIG");  // next/prev track, screen-flip-aware
     } else {
-      ffSpeedIndex = (ffSpeedIndex + 1) % 4;
-      int seek_sec[] = {10, 20, 30, 60};
-      Out.print("FF:");
-      Out.println(seek_sec[ffSpeedIndex]);
+      Out.println("FF:10");
     }
   }
 }
 
-void handleDown(bool longPress) {
-  if (wakeDisplay()) { lastInputTime = millis(); return; }  // wake-only press, swallow the action
+void handleEncoderCCW() {
+  if (wakeDisplay()) { lastInputTime = millis(); return; }  // wake-only turn, swallow the action
   lastInputTime = millis();
   if (uiState == UI_HOME) {
     if (homeCount > 0) {
-      homeIndex = (homeIndex + 1) % homeCount;
+      homeIndex = (homeIndex - 1 + homeCount) % homeCount;
       sendHomeMode();
       drawHome();
     }
   } else if (uiState == UI_BURN_READY) {
     if (editingSpeed) {
-      burnSpeedIndex = (burnSpeedIndex + 1) % SPEED_COUNT;
+      burnSpeedIndex = (burnSpeedIndex - 1 + SPEED_COUNT) % SPEED_COUNT;
       Out.print("SPEED:");
       Out.println(SPEED_MODES[burnSpeedIndex]);
       drawBurnReady();
     } else {
-      burnModeIndex = (burnModeIndex + 1) % BURN_COUNT;
+      burnModeIndex = (burnModeIndex - 1 + BURN_COUNT) % BURN_COUNT;
       sendBurnMode();
       drawBurnReady();
     }
   } else if (uiState == UI_STANDBY) {
-    displayRotation = 2;
+    displayRotation = 0;
     drawStandby();
   } else if (uiState == UI_PLAY) {
-    if (audioPlayMode) {
-      Out.println(displayRotation == 0 ? (longPress ? "FF:BIG" : "FF:10") : (longPress ? "REW:BIG" : "REW:10"));
-      return;
-    }
-    ffSpeedIndex = 0;
-    if (longPress) {
-      Out.println("REW:BIG");
+    vuSuppressUntil = millis() + VU_RESUME_DELAY_MS;   // any PLAY input -> back to text for a beat
+    if (!playSeekMode) {
+      playVolume = max(0, playVolume - 5);
+      Out.print("POT:");
+      Out.println(playVolume);
+      drawPlay();
+    } else if (audioPlayMode) {
+      Out.println(displayRotation == 0 ? "REW:BIG" : "FF:BIG");
     } else {
-      rewSpeedIndex = (rewSpeedIndex + 1) % 4;
-      int seek_sec[] = {10, 20, 30, 60};
-      Out.print("REW:");
-      Out.println(seek_sec[rewSpeedIndex]);
+      Out.println("REW:10");
     }
   }
 }
 
+// EJECT: fixed shortcut, any idle-ish state. Not during an active burn/rip -
+// don't pull the disc mid-operation (matches the old SELECT-EJECT's implicit
+// restriction, since that branch only ever existed on HOME/STANDBY).
+void handleEjectButton() {
+  if (wakeDisplay()) { lastInputTime = millis(); return; }
+  lastInputTime = millis();
+  if (uiState == UI_HOME || uiState == UI_STANDBY || uiState == UI_DISCONNECTED || uiState == UI_PLAY) {
+    Out.println("EJECT");
+    line1 = "Ejecting...";
+    line2 = "";
+    line3 = "";
+    returnToHomeAt = millis() + 5000;
+    drawStatus();
+  }
+}
+
+// HOME/BACK: universal escape from anywhere back to the top menu.
+void handleHomeButton() {
+  if (wakeDisplay()) { lastInputTime = millis(); return; }
+  lastInputTime = millis();
+  if (uiState == UI_HOME) return;
+  Out.println(uiState == UI_PLAY ? "PLAY_STOP" : "CANCEL");
+  drawHome();
+}
+
+// PLAY/PAUSE: toggles pause while playing; from HOME, jumps straight into
+// PLAY without needing to scroll the menu there first.
+void handlePlayPauseButton(bool longPress) {
+  if (wakeDisplay()) { lastInputTime = millis(); return; }
+  lastInputTime = millis();
+  if (uiState == UI_PLAY) {
+    vuSuppressUntil = millis() + VU_RESUME_DELAY_MS;   // any PLAY input -> back to text for a beat
+    Out.println(longPress ? "PLAY_STOP" : "PLAY_BUTTON");
+  } else if (uiState == UI_HOME && !longPress) {
+    bool hasPlay = false;
+    for (int i = 0; i < homeCount; i++) if (homeModes[i] == "PLAY") hasPlay = true;
+    if (hasPlay) {
+      Out.println("SELECT:PLAY");
+      line1 = "Selected";
+      line2 = "PLAY";
+      line3 = "";
+      drawStatus();
+    }
+  }
+}
+
+// Drains every line currently buffered on a link in one go instead of one
+// per loop() call. VU: frames arrive fast enough (~15/sec) that drawing each
+// one in turn made the display fall further and further behind real-time
+// once a single draw took longer than the send interval - only the last VU:
+// seen in a batch is kept/rendered, so the visualizer always shows "now"
+// instead of working through a backlog. Every other message type still gets
+// parsed in order; only VU: is collapsible like this.
+void drainAndDispatch(Stream &s) {
+  String pendingVu = "";
+  while (s.available()) {
+    String msg = s.readStringUntil('\n');
+    if (msg.length() == 0) continue;
+    if (msg.startsWith("VU:")) pendingVu = msg;
+    else parseMessage(msg);
+  }
+  if (pendingVu.length() > 0) parseMessage(pendingVu);
+}
+
 void loop() {
   if (!wifiInitDone && millis() > 3000) {
     wifiInitDone = true;
@@ -1034,15 +1207,13 @@ void loop() {
       Out.setClient(nullptr);
     }
     if (tcpClient && tcpClient.available()) {
-      String msg = tcpClient.readStringUntil('\n');
-      if (msg.length() > 0) parseMessage(msg);
+      drainAndDispatch(tcpClient);
     }
   }
 
   esp_task_wdt_reset();
   if (Serial.available()) {
-    String msg = Serial.readStringUntil('\n');
-    parseMessage(msg);
+    drainAndDispatch(Serial);
   }
 
   if (returnToHomeAt != 0 && (long)(millis() - returnToHomeAt) >= 0) {
@@ -1055,31 +1226,59 @@ void loop() {
     drawPlay();
   }
 
-  // --- Pot reading (PLAY only, volume) ---
-  if (uiState == UI_PLAY && millis() - lastPotRead > POT_READ_MS) {
-    lastPotRead = millis();
-    int nextVolume = readPercent();
-    if (abs(nextVolume - playVolume) >= 3) {
-      playVolume = nextVolume;
-      Out.print("POT:");
-      Out.println(playVolume);
-      drawPlay();
+  // --- Encoder rotation: drain ticks accumulated by encoderISR ---
+  {
+    noInterrupts();
+    int16_t ticks = encTicks;
+    encTicks = 0;
+    interrupts();
+    while (ticks > 0) { handleEncoderCW(); ticks--; }
+    while (ticks < 0) { handleEncoderCCW(); ticks++; }
+  }
+
+  // --- Encoder click (SW) - same debounce/long-press shape as the old SELECT.
+  // Also guarded against rotation: spinning the knob can momentarily bounce
+  // SW low too, which was being misread as a real click and firing SELECT/PLAY. ---
+  {
+    bool sw = digitalRead(ENC_SW_PIN) == LOW;
+    if (sw && !encClickDown && millis() - encClickLastDebounce > DEBOUNCE_MS &&
+        millis() - encLastActivityMs > ENC_CLICK_GUARD_MS) {
+      encClickDown = true;
+      encClickDownAt = millis();
+    }
+    if (!sw && encClickDown) {
+      encClickDown = false;
+      encClickLastDebounce = millis();
+      handleSelectPress(millis() - encClickDownAt >= LONG_PRESS_MS);
     }
   }
 
-  // --- SELECT button ---
+  // --- EJECT button (single press, no long-press timer) ---
   {
-    bool sel = digitalRead(BTN_SELECT_PIN) == LOW;
-    if (sel && !selectDown && millis() - selectLastDebounce > DEBOUNCE_MS) {
-      selectDown = true;
-      selectDownAt = millis();
+    bool ej = digitalRead(BTN_EJECT_PIN) == LOW;
+    if (ej && !ejectDown && millis() - ejectLastDebounce > DEBOUNCE_MS) {
+      ejectDown = true;
+    }
+    if (!ej && ejectDown) {
+      ejectDown = false;
+      ejectLastDebounce = millis();
+      handleEjectButton();
+    }
+  }
+
+  // --- HOME/BACK button (single press; 10s hold = Wi-Fi reset) ---
+  {
+    bool hm = digitalRead(BTN_HOME_PIN) == LOW;
+    if (hm && !homeDown && millis() - homeLastDebounce > DEBOUNCE_MS) {
+      homeDown = true;
+      homeDownAt = 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 &&
+    // 10s hold on HOME/SETUP/STANDBY = wipe Wi-Fi creds + reboot to portal. Fires
+    // while still held so the eventual release doesn't also trigger the normal action.
+    if (hm && homeDown && !wifiResetArmed &&
         (uiState == UI_HOME || uiState == UI_SETUP || uiState == UI_STANDBY) &&
-        millis() - selectDownAt >= WIFI_RESET_HOLD_MS) {
+        millis() - homeDownAt >= WIFI_RESET_HOLD_MS) {
       wifiResetArmed = true;
       Out.println("WiFi: creds wiped, rebooting");
       clearCreds();
@@ -1087,47 +1286,25 @@ void loop() {
       delay(800);
       ESP.restart();
     }
-    if (!sel && selectDown) {
-      selectDown = false;
-      selectLastDebounce = millis();
-      if (!wifiResetArmed) {
-        handleSelectPress(millis() - selectDownAt >= LONG_PRESS_MS);
-      }
+    if (!hm && homeDown) {
+      homeDown = false;
+      homeLastDebounce = millis();
+      if (!wifiResetArmed) handleHomeButton();
       wifiResetArmed = false;
     }
   }
 
-  // --- UP button ---
-  {
-    bool up = digitalRead(BTN_UP_PIN) == LOW;
-    if (up && !upDown && millis() - upLastDebounce > DEBOUNCE_MS) {
-      upDown = true;
-      upDownAt = millis();
-    }
-    if (!up && upDown) {
-      upDown = false;
-      upLastDebounce = millis();
-      bool lp = millis() - upDownAt >= LONG_PRESS_MS;
-      if (uiState == UI_PLAY || !lp) {
-        handleUp(lp);
-      }
-    }
-  }
-
-  // --- DOWN button ---
+  // --- PLAY/PAUSE button (short = pause/resume, long = stop) ---
   {
-    bool dn = digitalRead(BTN_DOWN_PIN) == LOW;
-    if (dn && !downDown && millis() - downLastDebounce > DEBOUNCE_MS) {
-      downDown = true;
-      downDownAt = millis();
+    bool pp = digitalRead(BTN_PLAYPAUSE_PIN) == LOW;
+    if (pp && !playpauseDown && millis() - playpauseLastDebounce > DEBOUNCE_MS) {
+      playpauseDown = true;
+      playpauseDownAt = millis();
     }
-    if (!dn && downDown) {
-      downDown = false;
-      downLastDebounce = millis();
-      bool lp = millis() - downDownAt >= LONG_PRESS_MS;
-      if (uiState == UI_PLAY || !lp) {
-        handleDown(lp);
-      }
+    if (!pp && playpauseDown) {
+      playpauseDown = false;
+      playpauseLastDebounce = millis();
+      handlePlayPauseButton(millis() - playpauseDownAt >= LONG_PRESS_MS);
     }
   }
 
@@ -1139,9 +1316,18 @@ void loop() {
     if (!displayBlank) drawStatus();
   }
 
-  // --- Idle disc screensaver (HOME + STANDBY) ---
+  // --- Visualizer timeout: host stopped sending VU: (paused/stopped) ---
+  if (visualizerActive && (long)(millis() - lastVuAt) >= VU_TIMEOUT_MS) {
+    visualizerActive = false;
+    if (uiState == UI_PLAY && !displayBlank) drawPlay();
+  }
+
+  // --- Idle disc screensaver (HOME + STANDBY + PLAY) ---
+  // PLAY is included because a static "PLAYING" screen is just as low-current
+  // as HOME/STANDBY were - the power bank doesn't care what's on screen, only
+  // that the draw stays static this long.
   if (displayOk && !displayBlank &&
-      (uiState == UI_HOME || uiState == UI_STANDBY) &&
+      (uiState == UI_HOME || uiState == UI_STANDBY || uiState == UI_PLAY) &&
       (long)(millis() - lastInputTime) >= IDLE_BLANK_MS) {
     displayBlank = true;
     saverStep = 0;