fix: clap the RIGHT antenna into the held LEFT (was the non-colliding mirror)

Both SDKs order antennas [right, left] (init pose [-0.1745, +0.1745]). My
Python calibration wrote antennas=[a,b] assuming index 0 was LEFT — it is
RIGHT — so the motion I recorded clean decodes from was right-slams/left-held.
The JS app's setAntennasDeg(right,left) was called fixed-first/moving-second,
which slammed the LEFT antenna: the mirror image, which does NOT collide on
this robot (confirmed by Rémi). Now the right antenna slams (0->54deg) into the
held left (-39deg), matching the validated motion. Re-confirmed on hardware:
strong click (mic peak 0.146 vs 0.004 for the mirror). Added a gentle preroll
ramp into the rest pose so the held antenna doesn't snap. Renamed profile
fields (heldDeg/slamRestDeg) + settings label to match.

lib/robot-tapper.js

@@ -3,33 +3,34 @@
  * onset produces an audible click. Consumes the same onset schedule from
  * wire.js that the speaker Synth uses, so robot and device speak one wire code.
  *
- * Physics (from marionette/tests/test_antenna_collision.py, proven safe):
- *   - Right antenna held at a fixed angle.
- *   - Left antenna slams in past the contact point and is commanded to hold
- *     briefly — the low-PID antennas stall at contact (no damage) and make a
- *     crisp click — then returns to rest.
+ * ── Antenna order: a bug worth remembering ───────────────────────────────
+ * Both the Python and JS SDKs order antennas as [right, left] (the init pose
+ * is [-0.1745, +0.1745] = [right, left]). When calibrating I drove the robot
+ * from a Python script and wrote `antennas=[a, b]` thinking index 0 was the
+ * LEFT antenna — it is actually the RIGHT. So the motion I recorded clean
+ * decodes from was: RIGHT antenna slams (0 → +54°), LEFT antenna held (-39°).
+ * The first version of this file called `setAntennasDeg(right, left)` with the
+ * fixed value first and the moving value second, which slammed the LEFT
+ * antenna instead — the mirror image (still collided + clicked, but the wrong
+ * antenna moved). Fixed here: the RIGHT antenna (first arg) is the slammer, the
+ * LEFT (second arg) is held, matching the validated motion exactly.
  *
- * We drive it in real time with `reachy.setAntennasDeg(right, left)` at
- * ~50 Hz, shaping the left antenna's target as a function of time. All
- * geometry/timing is configurable so it can be calibrated on hardware
- * (contact angle, hold, command→sound latency) without touching logic.
+ * Physics (from marionette/tests/test_antenna_collision.py): low-PID antennas
+ * stall at contact (no damage) and make a crisp click. All geometry/timing is
+ * configurable so it can be calibrated on hardware without touching logic.
  */
 
-// Calibrated on a Lite robot via tools/robot_clap_test.py (2026-06-01): a
-// firmer contact (54° vs the bare marionette 40°) made each clap clearly
-// audible/detectable to a laptop mic, and a settle tail after the last clap
-// stops a following return-to-pose from jerking the antenna and ringing out
-// spurious clicks that corrupt the final symbol.
 export const DEFAULT_TAP_PROFILE = Object.freeze({
-    rightRestDeg: -39, // right antenna held here (≈ -0.68 rad)
-    leftRestDeg: 0, // left antenna resting position
-    collisionDeg: 54, // left commanded past contact (~34°) so it stalls + clicks
+    heldDeg: -39, // LEFT antenna, held still (≈ -0.68 rad)
+    slamRestDeg: 0, // RIGHT antenna resting position
+    collisionDeg: 54, // RIGHT antenna commanded past contact (~34°) so it stalls + clicks
     approachMs: 80, // ramp rest → collision
-    holdMs: 70, // dwell at collision (stall against right antenna)
+    holdMs: 70, // dwell at collision (stall against the held antenna)
     returnMs: 80, // ramp back to rest
     rateHz: 50, // command rate
     leadMs: 0, // advance whole timeline to offset command→sound latency
     settleMs: 500, // quiet hold after the last clap before resolving (anti-ring)
+    prerollMs: 500, // gentle move into the rest pose before the first clap
 });
 
 export class RobotTapper {
@@ -39,9 +40,9 @@ export class RobotTapper {
         this._timer = null;
     }
 
-    /** Left-antenna angle (deg) at time `t` ms, given the slam windows. */
-    _leftAngleAt(t, onsets) {
-        const { leftRestDeg, collisionDeg, approachMs, holdMs } = this.p;
+    /** Slamming (RIGHT) antenna angle (deg) at time `t` ms within the windows. */
+    _slamAngleAt(t, onsets) {
+        const { slamRestDeg, collisionDeg, approachMs, holdMs } = this.p;
         for (const T of onsets) {
             const a0 = T - approachMs; // start approaching
             const hEnd = T + holdMs; // end of hold
@@ -49,13 +50,18 @@ export class RobotTapper {
             if (t < a0 || t > rEnd) continue;
             if (t <= T) {
                 const f = approachMs > 0 ? (t - a0) / approachMs : 1;
-                return leftRestDeg + (collisionDeg - leftRestDeg) * easeIn(f);
+                return slamRestDeg + (collisionDeg - slamRestDeg) * easeIn(f);
             }
             if (t <= hEnd) return collisionDeg;
             const f = (t - hEnd) / this.p.returnMs;
-            return collisionDeg + (leftRestDeg - collisionDeg) * easeOut(f);
+            return collisionDeg + (slamRestDeg - collisionDeg) * easeOut(f);
         }
-        return leftRestDeg;
+        return slamRestDeg;
+    }
+
+    _send(slam, held) {
+        // setAntennasDeg(right, left): RIGHT is the slammer, LEFT is held.
+        try { this.reachy.setAntennasDeg(slam, held); } catch { /* transient send errors are non-fatal */ }
     }
 
     /**
@@ -67,20 +73,21 @@ export class RobotTapper {
      * @returns {Promise<void>} resolves when the sequence completes/aborts
      */
     tap(onsetsMs, { onTap, signal } = {}) {
-        const onsets = onsetsMs.map((t) => t - this.p.leadMs);
+        const preroll = this.p.prerollMs;
+        // Shift the schedule after the preroll, and apply the latency lead.
+        const onsets = onsetsMs.map((t) => t + preroll - this.p.leadMs);
+        const tapMarks = onsetsMs.map((t) => t + preroll); // for UI highlight
         const period = Math.max(10, Math.round(1000 / this.p.rateHz));
-        const endMs = (onsets.length ? onsets[onsets.length - 1] : 0)
-            + this.p.holdMs + this.p.returnMs + (this.p.settleMs ?? 500);
+        const endMs = (onsets.length ? onsets[onsets.length - 1] : preroll)
+            + this.p.holdMs + this.p.returnMs + this.p.settleMs;
 
         return new Promise((resolve) => {
             const t0 = performance.now();
             let nextTapIdx = 0;
-            const tapMarks = onsetsMs.slice(); // original (UI) onset times
             const finish = () => {
                 clearInterval(this._timer);
                 this._timer = null;
-                // settle antennas back to rest
-                try { this.reachy.setAntennasDeg(this.p.rightRestDeg, this.p.leftRestDeg); } catch { /* ignore */ }
+                this._send(this.p.slamRestDeg, this.p.heldDeg); // settle at rest
                 resolve();
             };
             signal?.addEventListener("abort", finish, { once: true });
@@ -88,11 +95,13 @@ export class RobotTapper {
             this._timer = setInterval(() => {
                 const t = performance.now() - t0;
                 if (t > endMs || signal?.aborted) return finish();
-                const left = this._leftAngleAt(t, onsets);
-                try {
-                    this.reachy.setAntennasDeg(this.p.rightRestDeg, left);
-                } catch { /* transient send errors are non-fatal */ }
-                // UI tap highlight when we cross an original onset time
+                if (t < preroll) {
+                    // Ease the held (LEFT) antenna into place; slammer waits at rest.
+                    const f = preroll > 0 ? t / preroll : 1;
+                    this._send(this.p.slamRestDeg, this.p.heldDeg * easeOut(f));
+                } else {
+                    this._send(this._slamAngleAt(t, onsets), this.p.heldDeg);
+                }
                 while (nextTapIdx < tapMarks.length && t >= tapMarks[nextTapIdx]) {
                     onTap?.(nextTapIdx);
                     nextTapIdx += 1;
@@ -103,7 +112,7 @@ export class RobotTapper {
 
     /** One calibration clap right now (no schedule). */
     async testClap() {
-        await this.tap([100]);
+        await this.tap([0]);
     }
 
     stop() {
@@ -111,7 +120,7 @@ export class RobotTapper {
             clearInterval(this._timer);
             this._timer = null;
         }
-        try { this.reachy.setAntennasDeg(this.p.rightRestDeg, this.p.leftRestDeg); } catch { /* ignore */ }
+        this._send(this.p.slamRestDeg, this.p.heldDeg);
     }
 }
 

lib/version.js

@@ -1,3 +1,3 @@
 // Deployment version label, shown in Settings so you can verify which build
 // is actually loaded after a push. Format: "YYYY-MM-DD rN", bumped on push.
-export const APP_VERSION = "2026-06-01 r3 robot-calibrated";
+export const APP_VERSION = "2026-06-01 r4 antenna-fix + one-page";

views/settings.js

@@ -39,8 +39,8 @@ export function createSettings(ctx) {
 
         el("h3", {}, "Robot clap (calibration)"),
         rangeRow("Contact angle", () => c.tap.collisionDeg, (v) => { c.tap.collisionDeg = v; },
-            { min: 10, max: 55, step: 1, fmt: (v) => `${v}°` }),
-        rangeRow("Right antenna", () => c.tap.rightRestDeg, (v) => { c.tap.rightRestDeg = v; },
+            { min: 10, max: 60, step: 1, fmt: (v) => `${v}°` }),
+        rangeRow("Held antenna", () => c.tap.heldDeg, (v) => { c.tap.heldDeg = v; },
             { min: -55, max: 0, step: 1, fmt: (v) => `${v}°` }),
         rangeRow("Hold", () => c.tap.holdMs, (v) => { c.tap.holdMs = v; },
             { min: 20, max: 150, step: 10, fmt: (v) => `${v} ms` }),