a better working example

app.py

@@ -1,12 +1,50 @@
 import gradio as gr
 import numpy as np
 from robots import LiveRobot
+import example_robot_data as erd
 
-ROBOTS = ["panda", "ur5",  "ur10",  "talos"]
+#ROBOTS = ["erd", "panda", "ur10" , "double_pendulum", "anymal", "talos"]
+ROBOTS = [r for r in erd.ROBOTS]
 
-# single global instance to keep the MeshCat connection alive
+
+# keep one MeshCat session alive
 robot = LiveRobot("panda")
 
+# how many sliders we allow at most (raise if you have bigger robots)
+MAX_SLIDERS = 32
+
+def _visible_dofs():
+    """Number of actuated DoFs for current robot."""
+    return len(robot.idxs)
+
+def _slider_updates_for_current_robot():
+    """Return a list of gr.update() objects of length MAX_SLIDERS
+    to (re)configure all sliders for the current robot."""
+    updates = []
+    k = _visible_dofs()
+    for i in range(MAX_SLIDERS):
+        if i < k:
+            label = robot.labels[i]
+            lo, hi = robot.bounds[i]
+            if lo==hi:
+                lo = -np.pi/2
+                hi = np.pi/2
+            qi = robot.idxs[i]
+            val = float((lo+hi)/2)
+            updates.append(
+                gr.update(
+                    minimum=float(lo),
+                    maximum=float(hi),
+                    value=val,
+                    label=label,
+                    step=0.01,
+                    visible=True,
+                )
+            )
+        else:
+            updates.append(gr.update(visible=False))
+    return updates
+
 with gr.Blocks(title="Pinocchio + MeshCat — Live") as demo:
     gr.Markdown("### 🤖 Pinocchio + MeshCat — Live Viewer\n"
                 "Sliders update the robot in real time (no reload).")
@@ -17,41 +55,74 @@ with gr.Blocks(title="Pinocchio + MeshCat — Live") as demo:
 
     viewer = gr.HTML(robot.iframe())
 
-    # sliders are created based on current robot model
-    slider_group = gr.Group()
+    # Pre-create a fixed pool of sliders (initially hidden)
     sliders = []
-    for label, (lo, hi), qi in zip(robot.labels, robot.bounds, robot.idxs):
-        sliders.append(gr.Slider(minimum=lo, maximum=hi, step=0.01,
-                                 value=float(robot.q[qi]), label=label))
+    with gr.Group():
+        for _ in range(MAX_SLIDERS):
+            sliders.append(
+                gr.Slider(
+                    minimum=-3.14, maximum=3.14, value=0.0,
+                    step=0.01, label="joint", visible=False
+                )
+            )
+
+    # ---------- Callbacks ----------
 
     def on_sliders(*vals):
-        robot.set_joints(vals)
-        # return nothing for viewer; iframe stays connected
+        """Apply first k slider values to robot joints."""
+        k = _visible_dofs()
+        # only use the first k values (ignore hidden/unused sliders)
+        robot.set_joints(vals[:k])
+        # viewer iframe persists; nothing to update there
         return gr.update()
 
+    # Wire all sliders to the same handler (fixed signature via *vals)
     for s in sliders:
-        s.change(on_sliders, inputs=sliders, outputs=viewer, queue=False)
+        s.change(on_sliders, inputs=sliders, outputs=viewer, queue=True)
 
     def on_neutral():
-        # reset joints and reflect slider values
-        values = robot.neutral()
-        updates = [gr.update(value=v) for v in values]
-        return [gr.update()] + updates
+        """Reset robot to neutral and reflect in visible sliders."""
+        values = robot.neutral()  # returns values for actuated DoFs, length k
+        bounds = robot.bounds
+        
+        for i, v in enumerate(values):
+            lo, hi = bounds[i]
+            if not np.isfinite(lo): lo = -3.14
+            if not np.isfinite(hi): hi =  3.14
+            
+            # clamp neutral value to slider range
+            if v < lo: v = lo
+            if v > hi: v = hi
+            
+            values[i] = v
+        k = len(values)
+        # viewer stays the same + slider value updates for first k; hide the rest
+        updates = [gr.update()]  # for viewer
+        for i in range(MAX_SLIDERS):
+            if i < k:
+                updates.append(gr.update(value=float(values[i]), visible=True))
+            else:
+                updates.append(gr.update(visible=False))
+        return updates
 
     neutral_btn.click(on_neutral, outputs=[viewer] + sliders, queue=False)
 
     def on_change_robot(name):
+        """Rebuild slider labels/ranges/values/visibility to match selected robot."""
         global robot
         robot = LiveRobot(name)
-        # rebuild slider values to the new robot's neutral
         viewer_html = robot.iframe()
-        updates = [gr.update(value=(lo+hi)/2, label=label, minimum=lo, maximum=hi)
-                   for (label,(lo,hi)) in zip(robot.labels, robot.bounds)]
-        # Return viewer and new sliders
-        return [viewer_html] + updates
+        # 1) update viewer HTML
+        # 2) update ALL sliders to reflect new robot
+        return [viewer_html] + _slider_updates_for_current_robot()
+
+    robot_dd.change(on_change_robot, inputs=robot_dd, outputs=[viewer] + sliders, queue=True)
+
+    # On app load, configure sliders for the initial robot
+    def _initial():
+        return [robot.iframe()] + _slider_updates_for_current_robot()
 
-    robot_dd.change(on_change_robot, inputs=robot_dd,
-                    outputs=[viewer] + sliders, queue=False)
+    demo.load(_initial, outputs=[viewer] + sliders, queue=False)
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=8501)

robots.py

@@ -28,30 +28,35 @@ class LiveRobot:
     Starts a local MeshCat ZMQ+Web server and keeps a persistent connection.
     The web UI is proxied at /meshcat/ by nginx (see nginx.conf).
     """
-    def __init__(self, robot_name="ur5"):
+    def __init__(self, robot_name="panda"):
         self.vis = meshcat.Visualizer(zmq_url="tcp://127.0.0.1:6001")
         print(f"Zmq URL: {self.vis.window.zmq_url}, web URL: {self.vis.window.web_url}")
 
-        self.vis.delete()   
-        time.sleep(1.0)  # wait for the viewer to be ready     
-        
         self.rdata = erd.load(robot_name)
         self.model = self.rdata.model
         self.data = self.model.createData()
-
+        
+        self.vis.delete()
+        time.sleep(0.5)  # wait for the robot to appear
+        
         self.viz = MeshcatVisualizer(
             self.model, self.rdata.collision_model, self.rdata.visual_model
         )
-        self.viz.initViewer(self.vis)
-        self.viz.reset()
-        time.sleep(1.0)  # wait for the viewer to be ready
+        
+        self.viz.initViewer(self.vis)        
+        
+        self.viz.clean()
+        time.sleep(0.5)  # wait for the robot to appear
         
         self.viz.loadViewerModel(rootNodeName="robot")
-        time.sleep(1.0)  # wait for the viewer to be ready
-
+        
         self.q = pin.neutral(self.model)
-        self.viz.display(self.q)
+        try:
+            self.viz.display(self.q)  
+        except Exception as e:
+            print(f"Error setting robot joints: {e}")
 
+        
         self.idxs, self.labels, self.bounds = _actuated_dof_indices(self.model)
 
 
@@ -59,8 +64,13 @@ class LiveRobot:
         q = self.q.copy()
         for v, qi in zip(vals, self.idxs):
             q[qi] = float(v)
-        self.q = q
-        self.viz.display(self.q)
+            
+        try:
+            self.viz.display(q)
+            self.q = q
+        except Exception as e:
+            print(f"Error setting robot joints: {e}")
+            
 
     def neutral(self):
         self.q = pin.neutral(self.model)