Smoother first movement, more robustness to port collision

Theremini/config.json

@@ -2,7 +2,6 @@
   "active_instruments": [
     "choir_aahs",
     "orchestra_hit",
-    "taiko_drum",
     "trumpet",
     "french_horn",
     "soundtrack"

Theremini/dashboard.py

@@ -113,12 +113,25 @@ class DashboardHandler(http.server.SimpleHTTPRequestHandler):
         self._send_json({"ok": True, "active_instruments": updated})
 
 
+class ReusableHTTPServer(http.server.ThreadingHTTPServer):
+    allow_reuse_address = True
+
+
 class DashboardServer:
-    def __init__(self, host: str = "0.0.0.0", port: int = DASHBOARD_PORT) -> None:
+    def __init__(
+        self,
+        host: str = "0.0.0.0",
+        port: int = DASHBOARD_PORT,
+        max_port_hops: int = 8,
+    ) -> None:
         self.host = host
         self.port = port
         self._thread: threading.Thread | None = None
         self._stop = threading.Event()
+        self._ready = threading.Event()
+        self._error: OSError | None = None
+        self._actual_port: int | None = None
+        self._max_port_hops = max(1, max_port_hops)
 
     def start(self) -> None:
         if self._thread and self._thread.is_alive():
@@ -126,18 +139,40 @@ class DashboardServer:
         self._stop.clear()
         self._thread = threading.Thread(target=self._run, daemon=True)
         self._thread.start()
+        self._ready.wait(timeout=2.0)
+        if self._error:
+            print(
+                f"Dashboard server failed to bind on {self.host}:{self.port}"
+                f" after trying {self._max_port_hops} ports: {self._error}"
+            )
 
     def stop(self) -> None:
         self._stop.set()
         if self._thread:
             self._thread.join(timeout=1.5)
 
+    @property
+    def port_in_use(self) -> int:
+        return self._actual_port or self.port
+
     def _run(self) -> None:
         handler = functools.partial(DashboardHandler)
-        with http.server.ThreadingHTTPServer((self.host, self.port), handler) as httpd:
-            httpd.timeout = 0.5
-            while not self._stop.is_set():
-                httpd.handle_request()
+        last_exc: OSError | None = None
+        for hop in range(self._max_port_hops):
+            candidate_port = self.port + hop
+            try:
+                with ReusableHTTPServer((self.host, candidate_port), handler) as httpd:
+                    self._actual_port = httpd.server_address[1]
+                    self._ready.set()
+                    httpd.timeout = 0.5
+                    while not self._stop.is_set():
+                        httpd.handle_request()
+                return
+            except OSError as exc:
+                last_exc = exc
+                continue
+        self._error = last_exc or OSError("unable to bind dashboard server")
+        self._ready.set()
 
 
 __all__ = ["DashboardServer", "DASHBOARD_PORT", "set_status", "get_status"]

Theremini/main.py

@@ -59,6 +59,8 @@ class Theremini(ReachyMiniApp):
         self._note_handle: Any | None = None
         self._current_pitch: int | None = None
         self._current_prog: int | None = None
+        self._dashboard_port = DASHBOARD_PORT
+        self.custom_app_url = f"http://localhost:{self._dashboard_port}/index.html"
 
     def _get_part_for_prog(self, prog: int):
         name = self._active_parts[prog]
@@ -77,8 +79,14 @@ class Theremini(ReachyMiniApp):
     def run(self, reachy_mini: ReachyMini, stop_event: threading.Event) -> None:
         print("Roll → Pitch\nZ → Volume\nRight antenna → Instrument\n")
 
-        dashboard_server = DashboardServer(port=DASHBOARD_PORT)
+        dashboard_server = DashboardServer(port=self._dashboard_port)
         dashboard_server.start()
+        self._dashboard_port = dashboard_server.port_in_use
+        self.custom_app_url = f"http://localhost:{self._dashboard_port}/index.html"
+        if self._dashboard_port != DASHBOARD_PORT:
+            print(
+                f"Dashboard port {DASHBOARD_PORT} busy, now serving on http://localhost:{self._dashboard_port}/index.html"
+            )
         set_status(self._build_status_payload(0.0, 0.0, 0.0, 0.0, None, None, False))
 
         reachy_mini.enable_motors()
@@ -240,6 +248,7 @@ class Theremini(ReachyMiniApp):
             current_roll,
             target_roll=-28.0,
             duration=1.6,
+            use_goto=True,
         )
         self._demo_pause(reachy_mini, stop_event, 0.45)
 
@@ -337,8 +346,18 @@ class Theremini(ReachyMiniApp):
         start_roll: float,
         target_roll: float,
         duration: float,
+        use_goto: bool = False,
     ) -> float:
         duration = max(0.3, duration)
+        if use_goto:
+            pose = create_head_pose(z=0.0, roll=target_roll, degrees=True)
+            reachy_mini.goto_target(head=pose, duration=duration)
+            end = time.time() + duration
+            while not stop_event.is_set() and time.time() < end:
+                self._tick_from_robot(reachy_mini)
+                time.sleep(0.02)
+            return target_roll
+
         start_time = time.time()
         while not stop_event.is_set():
             elapsed = time.time() - start_time