Init

README.md

@@ -10,3 +10,9 @@ tags:
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+```
+uv venv --python 3.12
+source .venv/bin/activate
+```
+

pyproject.toml

@@ -12,6 +12,9 @@ requires-python = ">=3.8"
 # dependencies = ["reachy-mini"]
 dependencies = [
     "reachy-mini@git+https://github.com/pollen-robotics/reachy_mini",
+    "fastapi>=0.115.0",
+    "uvicorn[standard]>=0.32.0",
+    "websockets>=13.0",
 ] # TODO open
 
 [project.entry-points."reachy_mini_apps"]

reachy_mini_app_example/main.py

@@ -1,28 +1,178 @@
 import threading
 import time
+import asyncio
+import json
+from typing import List
+from queue import Queue
 
 import numpy as np
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+import uvicorn
 from reachy_mini import ReachyMiniApp
 from reachy_mini.reachy_mini import ReachyMini
 from scipy.spatial.transform import Rotation as R
 
 
+class ConnectionManager:
+    def __init__(self):
+        self.active_connections: List[WebSocket] = []
+        self.state_queue: Queue = Queue()
+
+    async def connect(self, websocket: WebSocket):
+        await websocket.accept()
+        self.active_connections.append(websocket)
+
+    def disconnect(self, websocket: WebSocket):
+        self.active_connections.remove(websocket)
+
+    async def broadcast(self, message: dict):
+        disconnected = []
+        for connection in self.active_connections:
+            try:
+                await connection.send_json(message)
+            except Exception:
+                disconnected.append(connection)
+        
+        # Clean up disconnected clients
+        for conn in disconnected:
+            if conn in self.active_connections:
+                self.active_connections.remove(conn)
+
+    def queue_state(self, state: dict):
+        """Queue state from sync context"""
+        self.state_queue.put(state)
+
+
 class ExampleApp(ReachyMiniApp):
+    def __init__(self):
+        super().__init__()
+        self.app = FastAPI()
+        self.manager = ConnectionManager()
+        self.current_state = {}
+        self.setup_routes()
+
+    def setup_routes(self):
+        @self.app.get("/")
+        async def read_root():
+            return FileResponse("index.html")
+
+        @self.app.websocket("/api/state/ws/full")
+        async def websocket_endpoint(websocket: WebSocket):
+            await self.manager.connect(websocket)
+            try:
+                while True:
+                    # Check for new state data and broadcast
+                    if not self.manager.state_queue.empty():
+                        state = self.manager.state_queue.get()
+                        await self.manager.broadcast(state)
+                    await asyncio.sleep(0.01)
+            except WebSocketDisconnect:
+                self.manager.disconnect(websocket)
+
     def run(self, reachy_mini: ReachyMini, stop_event: threading.Event):
+        # Start FastAPI server in a separate thread
+        def start_server():
+            uvicorn.run(self.app, host="127.0.0.1", port=8000, log_level="info")
+
+        server_thread = threading.Thread(target=start_server, daemon=True)
+        server_thread.start()
+
+        print("🚀 Web server started at http://127.0.0.1:8000")
+        print("🔌 WebSocket available at ws://127.0.0.1:8000/api/state/ws/full")
+        print("📄 Open http://127.0.0.1:8000 in your browser")
+        print("Press Ctrl+C to stop\n")
+
         t0 = time.time()
-        while not stop_event.is_set():
-            pose = np.eye(4)
-            pose[:3, 3][2] = 0.005 * np.sin(2 * np.pi * 0.3 * time.time() + np.pi)
-            euler_rot = [
-                0,
-                0,
-                0.5 * np.sin(2 * np.pi * 0.3 * time.time() + np.pi),
-            ]
-            rot_mat = R.from_euler("xyz", euler_rot, degrees=False).as_matrix()
-            pose[:3, :3] = rot_mat
-            pose[:3, 3][2] += 0.01 * np.sin(2 * np.pi * 0.5 * time.time())
-            antennas = np.array([1, 1]) * np.sin(2 * np.pi * 0.5 * time.time())
-
-            reachy_mini.set_target(head=pose, antennas=antennas)
-
-            time.sleep(0.02)
+        try:
+            while not stop_event.is_set():
+                pose = np.eye(4)
+                pose[:3, 3][2] = 0.005 * np.sin(2 * np.pi * 0.3 * time.time() + np.pi)
+                euler_rot = [
+                    0,
+                    0,
+                    0.5 * np.sin(2 * np.pi * 0.3 * time.time() + np.pi),
+                ]
+                rot_mat = R.from_euler("xyz", euler_rot, degrees=False).as_matrix()
+                pose[:3, :3] = rot_mat
+                pose[:3, 3][2] += 0.01 * np.sin(2 * np.pi * 0.5 * time.time())
+                antennas = np.array([1, 1]) * np.sin(2 * np.pi * 0.5 * time.time())
+
+                reachy_mini.set_target(head=pose, antennas=antennas)
+
+                # Prepare state data for broadcasting
+                state_data = {
+                    "timestamp": time.time(),
+                    "head_pose": pose.tolist(),
+                    "antennas": antennas.tolist(),
+                    "euler_rotation": euler_rot,
+                }
+
+                # Queue state for WebSocket broadcasting (from sync context)
+                self.manager.queue_state(state_data)
+
+                time.sleep(0.02)
+        except KeyboardInterrupt:
+            pass
+
+
+if __name__ == "__main__":
+    """
+    Standalone testing mode - run this directly to test the app with a Reachy Mini
+    running on the same machine (localhost).
+    
+    Usage:
+        python reachy_mini_app_example/main.py
+        
+    Options:
+        - localhost_only=True: Connect to Reachy on localhost
+        - use_sim=True: Use simulation mode (if available)
+    """
+    import signal
+    import sys
+    
+    # Create the app instance
+    app = ExampleApp()
+    
+    # Create a stop event for clean shutdown
+    stop_event = threading.Event()
+    shutdown_initiated = False
+    
+    def signal_handler(sig, frame):
+        global shutdown_initiated
+        if not shutdown_initiated:
+            shutdown_initiated = True
+            print("\n🛑 Shutting down gracefully...")
+            stop_event.set()
+            sys.exit(0)
+    
+    signal.signal(signal.SIGINT, signal_handler)
+    
+    # Connect to Reachy Mini on localhost
+    print("🤖 Connecting to Reachy Mini...")
+    try:
+        # Connect to Reachy Mini (localhost_only=True connects to local robot)
+        # Set use_sim=True if you want to test with simulation
+        reachy_mini = ReachyMini(
+            localhost_only=True,  # Connect to robot on localhost
+            spawn_daemon=False,   # Don't spawn a new daemon (daemon already running)
+            use_sim=False,        # Set to True for simulation mode
+            timeout=5.0,
+            log_level='INFO'
+        )
+        print("✅ Connected to Reachy Mini!")
+        
+        # Run the app
+        app.run(reachy_mini, stop_event)
+        
+    except KeyboardInterrupt:
+        print("\n🛑 Interrupted by user")
+    except Exception as e:
+        print(f"❌ Error connecting to Reachy Mini: {e}")
+        print("\nMake sure:")
+        print("  1. Reachy Mini daemon is running on this machine")
+        print("  2. The Reachy Mini service is started")
+        print("  3. Try setting use_sim=True for simulation mode")
+    finally:
+        print("👋 Goodbye!")

reachy_mini_app_example/stream.html

@@ -0,0 +1,196 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8" />
+    <title>Joint stream</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <style>
+        body { font-family: system-ui, -apple-system, Segoe UI, Roboto, sans-serif; margin: 16px; }
+        #status { margin-bottom: 8px; }
+        table { border-collapse: collapse; width: 100%; font-variant-numeric: tabular-nums; }
+        th, td { border: 1px solid #ddd; padding: 6px 8px; text-align: left; }
+        th { background: #f4f4f4; position: sticky; top: 0; }
+        pre { background: #f8f8f8; border: 1px solid #eee; padding: 8px; overflow: auto; max-height: 30vh; }
+        .ok { color: #0a0; }
+        .err { color: #a00; }
+    </style>
+</head>
+<body>
+    <h3>Joint stream</h3>
+    <div id="status">Connecting…</div>
+
+    <table id="joint-table" aria-label="Joint table">
+        <thead></thead>
+        <tbody></tbody>
+    </table>
+
+    <h4>Last payload</h4>
+    <pre id="raw"></pre>
+
+    <script>
+        // Change via URL: ?ws=ws://host:port/api/state/ws/full
+        const WS_URL = new URLSearchParams(location.search).get("ws")
+            || "ws://127.0.0.1:8000/api/state/ws/full";
+
+        const statusEl = document.getElementById("status");
+        const rawEl = document.getElementById("raw");
+        const thead = document.querySelector("#joint-table thead");
+        const tbody = document.querySelector("#joint-table tbody");
+
+        let ws;
+        let latestPayload = null;
+        let rafScheduled = false;
+        let columns = ["Joint", "position", "velocity", "torque"]; // default preferred columns
+
+        function setStatus(text, cls="") {
+            statusEl.className = cls;
+            statusEl.textContent = text;
+        }
+
+        function connect() {
+            try {
+                ws = new WebSocket(WS_URL);
+            } catch (e) {
+                setStatus("Invalid WebSocket URL: " + e.message, "err");
+                return;
+            }
+
+            ws.onopen = () => setStatus("Connected: " + WS_URL, "ok");
+            ws.onclose = (e) => setStatus(`Disconnected (${e.code}) — reconnecting in 1s…`, "err");
+            ws.onerror = () => setStatus("WebSocket error — see console", "err");
+            ws.onmessage = (event) => {
+                try {
+                    latestPayload = JSON.parse(event.data);
+                    scheduleRender();
+                } catch (e) {
+                    setStatus("Bad JSON from server", "err");
+                }
+            };
+
+            // simple autoreconnect
+            ws.addEventListener("close", () => setTimeout(connect, 1000), { once: true });
+        }
+
+        function scheduleRender() {
+            if (rafScheduled) return;
+            rafScheduled = true;
+            requestAnimationFrame(() => {
+                rafScheduled = false;
+                if (latestPayload) render(latestPayload);
+            });
+        }
+
+        function render(payload) {
+            rawEl.textContent = JSON.stringify(payload, null, 2);
+            const joints = pickJoints(payload);
+            const rows = normalizeJoints(joints);
+            if (!rows.length) {
+                thead.innerHTML = "";
+                tbody.innerHTML = "";
+                return;
+            }
+            // build dynamic column set (prefer known order)
+            const fieldSet = new Set(["Joint", ...columns.slice(1)]);
+            for (const r of rows) for (const k of Object.keys(r)) fieldSet.add(k);
+            // ensure "Joint" first
+            const cols = ["Joint", ...[...fieldSet].filter(c => c !== "Joint")];
+            if (JSON.stringify(cols) !== JSON.stringify(columns)) {
+                columns = cols;
+                renderHeader(columns);
+            }
+            renderBody(rows, columns);
+        }
+
+        function renderHeader(cols) {
+            const tr = document.createElement("tr");
+            for (const c of cols) {
+                const th = document.createElement("th");
+                th.textContent = c;
+                tr.appendChild(th);
+            }
+            thead.innerHTML = "";
+            thead.appendChild(tr);
+        }
+
+        function renderBody(rows, cols) {
+            const frag = document.createDocumentFragment();
+            for (const r of rows) {
+                const tr = document.createElement("tr");
+                for (const c of cols) {
+                    const td = document.createElement("td");
+                    const v = r[c];
+                    td.textContent = v === undefined ? "" : (typeof v === "number" ? Number(v).toFixed(4) : String(v));
+                    tr.appendChild(td);
+                }
+                frag.appendChild(tr);
+            }
+            tbody.innerHTML = "";
+            tbody.appendChild(frag);
+        }
+
+        function pickJoints(obj) {
+            if (!obj || typeof obj !== "object") return null;
+            // Common placements
+            if (obj.joints) return obj.joints;
+            if (obj.state && obj.state.joints) return obj.state.joints;
+            if (obj.motors) return obj.motors;
+            if (obj.body && obj.body.joints) return obj.body.joints;
+            return obj.joints_state || null;
+        }
+
+        function normalizeJoints(joints) {
+            if (!joints) return [];
+            const out = [];
+
+            const preferredKeys = ["position","pos","angle","velocity","vel","speed","torque","effort","current","temperature","temp","value"];
+
+            const extractFields = (o) => {
+                const row = {};
+                for (const k of preferredKeys) {
+                    if (o && typeof o === "object" && k in o && isFinite(o[k])) row[k] = Number(o[k]);
+                }
+                // fallback: include any top-level numeric fields
+                for (const [k,v] of Object.entries(o || {})) {
+                    if (!(k in row) && isFinite(v)) row[k] = Number(v);
+                }
+                return row;
+            };
+
+            if (Array.isArray(joints)) {
+                for (const item of joints) {
+                    if (item == null) continue;
+                    let name = item.name ?? item.id ?? item.label ?? "";
+                    // if the array is like [{jointName: {..}}, ...]
+                    if (!name && typeof item === "object" && !Array.isArray(item)) {
+                        const keys = Object.keys(item);
+                        if (keys.length === 1) {
+                            name = keys[0];
+                            const fields = extractFields(item[name]);
+                            out.push({ Joint: name, ...fields });
+                            continue;
+                        }
+                    }
+                    const fields = extractFields(item);
+                    out.push({ Joint: String(name || out.length), ...fields });
+                }
+                return out;
+            }
+
+            if (typeof joints === "object") {
+                for (const [name, val] of Object.entries(joints)) {
+                    if (val != null && typeof val === "object") {
+                        out.push({ Joint: name, ...extractFields(val) });
+                    } else if (isFinite(val)) {
+                        out.push({ Joint: name, value: Number(val) });
+                    }
+                }
+                return out;
+            }
+
+            return out;
+        }
+
+        connect();
+    </script>
+</body>
+</html>