add script

* add visualize_dataset call from `lerobot_dataset_viz` in web record server

* add delete button

* fixes

* remove viz

* unused import

examples/openarms/evaluate.py

@@ -0,0 +1,360 @@
+#!/usr/bin/env python
+
+# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+OpenArms Policy Evaluation
+
+Evaluates a trained policy on the OpenArms robot by running inference and recording
+the evaluation episodes to a dataset. Supports optional leader arm for manual resets.
+
+Example usage:
+    python examples/openarms/evaluate.py
+"""
+
+import time
+from pathlib import Path
+
+from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
+from lerobot.configs.policies import PreTrainedConfig
+from lerobot.datasets.lerobot_dataset import LeRobotDataset
+from lerobot.datasets.pipeline_features import aggregate_pipeline_dataset_features, create_initial_features
+from lerobot.datasets.utils import combine_feature_dicts
+from lerobot.policies.factory import make_policy, make_pre_post_processors
+from lerobot.processor import make_default_processors
+from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
+from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
+from lerobot.scripts.lerobot_record import record_loop
+from lerobot.teleoperators.openarms.config_openarms_leader import OpenArmsLeaderConfig
+from lerobot.teleoperators.openarms.openarms_leader import OpenArmsLeader
+from lerobot.utils.control_utils import init_keyboard_listener
+from lerobot.utils.utils import log_say
+from lerobot.utils.visualization_utils import init_rerun
+
+
+HF_MODEL_ID = "lerobot-data-collection/three-folds-pi0"  # TODO: Replace with your trained model
+HF_EVAL_DATASET_ID = "lerobot-data-collection/three-folds-pi0_eval7"  # TODO: Replace with your eval dataset name
+TASK_DESCRIPTION = "three-folds-dataset"  # TODO: Replace with your task, this should match!!
+
+NUM_EPISODES = 1
+FPS = 30
+EPISODE_TIME_SEC = 300
+RESET_TIME_SEC = 60
+
+# Robot CAN interfaces
+FOLLOWER_LEFT_PORT = "can0"
+FOLLOWER_RIGHT_PORT = "can1"
+
+# If enabled, you can manually reset the environment between evaluation episodes
+USE_LEADER_FOR_RESETS = True  # Set to False if you don't want to use leader
+LEADER_LEFT_PORT = "can2"
+LEADER_RIGHT_PORT = "can3"
+
+# Camera configuration
+CAMERA_CONFIG = {
+    "left_wrist": OpenCVCameraConfig(index_or_path="/dev/video5", width=640, height=480, fps=FPS),
+    "right_wrist": OpenCVCameraConfig(index_or_path="/dev/video1", width=640, height=480, fps=FPS),
+    "base": OpenCVCameraConfig(index_or_path="/dev/video3", width=640, height=480, fps=FPS),
+}
+
+def main():
+    """Main evaluation function."""
+    print("OpenArms Policy Evaluation")
+    print(f"\nModel: {HF_MODEL_ID}")
+    print(f"Evaluation Dataset: {HF_EVAL_DATASET_ID}")
+    print(f"Task: {TASK_DESCRIPTION}")
+    print(f"Episodes: {NUM_EPISODES}")
+    print(f"Episode Duration: {EPISODE_TIME_SEC}s")
+    print(f"Reset Duration: {RESET_TIME_SEC}s")
+    print(f"Use Leader for Resets: {USE_LEADER_FOR_RESETS}")
+    
+    follower_config = OpenArmsFollowerConfig(
+        port_left=FOLLOWER_LEFT_PORT,
+        port_right=FOLLOWER_RIGHT_PORT,
+        can_interface="socketcan",
+        id="openarms_follower",
+        disable_torque_on_disconnect=True,
+        max_relative_target=10.0,
+        cameras=CAMERA_CONFIG,
+    )
+    
+    follower = OpenArmsFollower(follower_config)
+    follower.connect(calibrate=False)
+    
+    if not follower.is_connected:
+        raise RuntimeError("Follower robot failed to connect!")
+
+    
+    leader = None
+    if USE_LEADER_FOR_RESETS:
+        leader_config = OpenArmsLeaderConfig(
+            port_left=LEADER_LEFT_PORT,
+            port_right=LEADER_RIGHT_PORT,
+            can_interface="socketcan",
+            id="openarms_leader",
+            manual_control=False,  # Enable torque control for gravity compensation
+        )
+        
+        leader = OpenArmsLeader(leader_config)
+        leader.connect(calibrate=False)
+        
+        if not leader.is_connected:
+            raise RuntimeError("Leader robot failed to connect!")
+        
+        # Enable gravity compensation
+        if leader.pin_robot is not None:
+            leader.bus_right.enable_torque()
+            leader.bus_left.enable_torque()
+            time.sleep(0.1)
+            print(f"Leader connected with gravity compensation ({LEADER_LEFT_PORT}, {LEADER_RIGHT_PORT})")
+        else:
+            print(f"Leader connected but gravity compensation unavailable (no URDF)")
+
+    # Build default processors for action and observation
+    teleop_action_processor, robot_action_processor, robot_observation_processor = make_default_processors()
+    
+    # Build dataset features from robot features and processors
+    # For actions, only include positions (no velocity or torque)
+    action_features_hw = {}
+    for key, value in follower.action_features.items():
+        if key.endswith(".pos"):
+            action_features_hw[key] = value
+    
+    dataset_features = combine_feature_dicts(
+        aggregate_pipeline_dataset_features(
+            pipeline=teleop_action_processor,
+            initial_features=create_initial_features(action=action_features_hw),
+            use_videos=True,
+        ),
+        aggregate_pipeline_dataset_features(
+            pipeline=robot_observation_processor,
+            initial_features=create_initial_features(observation=follower.observation_features),
+            use_videos=True,
+        ),
+    )
+    
+    # Check if dataset already exists
+    dataset_path = Path.home() / ".cache" / "huggingface" / "lerobot" / HF_EVAL_DATASET_ID
+    if dataset_path.exists():
+        print(f"Evaluation dataset already exists at: {dataset_path}")
+        print("This will append new episodes to the existing dataset.")
+        choice = input("  Continue? (y/n): ").strip().lower()
+        if choice != 'y':
+            print("  Aborting evaluation.")
+            follower.disconnect()
+            if leader:
+                leader.disconnect()
+            return
+    
+    # Create dataset
+    dataset = LeRobotDataset.create(
+        repo_id=HF_EVAL_DATASET_ID,
+        fps=FPS,
+        features=dataset_features,
+        robot_type=follower.name,
+        use_videos=True,
+        image_writer_processes=0,
+        image_writer_threads=12, 
+    )
+    
+    # Load policy config from pretrained model and create policy using factory
+    policy_config = PreTrainedConfig.from_pretrained(HF_MODEL_ID)
+    policy_config.pretrained_path = HF_MODEL_ID
+    policy = make_policy(policy_config, ds_meta=dataset.meta)
+    
+    preprocessor, postprocessor = make_pre_post_processors(
+        policy_cfg=policy.config,
+        pretrained_path=HF_MODEL_ID,
+        dataset_stats=dataset.meta.stats,
+        preprocessor_overrides={
+            "device_processor": {"device": str(policy.config.device)}
+        },
+    )
+
+    print(f"\nRunning evaluation...")
+    # Initialize keyboard listener and visualization
+    listener, events = init_keyboard_listener()
+    init_rerun(session_name="openarms_evaluation")
+    episode_idx = 0
+    
+    try:
+        while episode_idx < NUM_EPISODES and not events["stop_recording"]:
+            log_say(f"Evaluating episode {episode_idx + 1} of {NUM_EPISODES}")
+            print(f"\nRunning inference for episode {episode_idx + 1}...")
+            
+            # Run inference with policy
+            record_loop(
+                robot=follower,
+                events=events,
+                fps=FPS,
+                teleop_action_processor=teleop_action_processor,
+                robot_action_processor=robot_action_processor,
+                robot_observation_processor=robot_observation_processor,
+                policy=policy,
+                preprocessor=preprocessor,
+                postprocessor=postprocessor,
+                dataset=dataset,
+                control_time_s=EPISODE_TIME_SEC,
+                single_task=TASK_DESCRIPTION,
+                display_data=True,
+            )
+            
+            # Handle re-recording
+            if events["rerecord_episode"]:
+                log_say("Re-recording episode")
+                events["rerecord_episode"] = False
+                events["exit_early"] = False
+                dataset.clear_episode_buffer()
+                continue
+            
+            # Save episode
+            if dataset.episode_buffer is not None and dataset.episode_buffer.get("size", 0) > 0:
+                print(f"Saving episode {episode_idx + 1} ({dataset.episode_buffer['size']} frames)...")
+                dataset.save_episode()
+                episode_idx += 1
+            
+            # Reset environment between episodes (if not last episode)
+            if not events["stop_recording"] and episode_idx < NUM_EPISODES:
+                if USE_LEADER_FOR_RESETS and leader:
+                    log_say("Reset the environment using leader arms")
+                    print(f"\nManual reset period ({RESET_TIME_SEC}s)...")
+                    
+                    # Use leader for manual reset with gravity compensation
+                    import numpy as np
+                    
+                    dt = 1 / FPS
+                    reset_start_time = time.perf_counter()
+                    
+                    while time.perf_counter() - reset_start_time < RESET_TIME_SEC:
+                        if events["exit_early"] or events["stop_recording"]:
+                            break
+                        
+                        loop_start = time.perf_counter()
+                        
+                        # Get leader state
+                        leader_action = leader.get_action()
+                        
+                        # Extract positions and velocities
+                        leader_positions_deg = {}
+                        leader_velocities_deg_per_sec = {}
+                        
+                        for motor in leader.bus_right.motors:
+                            pos_key = f"right_{motor}.pos"
+                            vel_key = f"right_{motor}.vel"
+                            if pos_key in leader_action:
+                                leader_positions_deg[f"right_{motor}"] = leader_action[pos_key]
+                            if vel_key in leader_action:
+                                leader_velocities_deg_per_sec[f"right_{motor}"] = leader_action[vel_key]
+                        
+                        for motor in leader.bus_left.motors:
+                            pos_key = f"left_{motor}.pos"
+                            vel_key = f"left_{motor}.vel"
+                            if pos_key in leader_action:
+                                leader_positions_deg[f"left_{motor}"] = leader_action[pos_key]
+                            if vel_key in leader_action:
+                                leader_velocities_deg_per_sec[f"left_{motor}"] = leader_action[vel_key]
+                        
+                        # Calculate gravity and friction torques
+                        leader_positions_rad = {k: np.deg2rad(v) for k, v in leader_positions_deg.items()}
+                        leader_gravity_torques_nm = leader._gravity_from_q(leader_positions_rad)
+                        
+                        leader_velocities_rad_per_sec = {k: np.deg2rad(v) for k, v in leader_velocities_deg_per_sec.items()}
+                        leader_friction_torques_nm = leader._friction_from_velocity(
+                            leader_velocities_rad_per_sec,
+                            friction_scale=1.0
+                        )
+                        
+                        # Combine torques
+                        leader_total_torques_nm = {}
+                        for motor_name in leader_gravity_torques_nm:
+                            gravity = leader_gravity_torques_nm.get(motor_name, 0.0)
+                            friction = leader_friction_torques_nm.get(motor_name, 0.0)
+                            leader_total_torques_nm[motor_name] = gravity + friction
+                        
+                        # Apply compensation
+                        for motor in leader.bus_right.motors:
+                            full_name = f"right_{motor}"
+                            position = leader_positions_deg.get(full_name, 0.0)
+                            torque = leader_total_torques_nm.get(full_name, 0.0)
+                            kd = leader.get_damping_kd(motor)
+                            
+                            leader.bus_right._mit_control(
+                                motor=motor, kp=0.0, kd=kd,
+                                position_degrees=position,
+                                velocity_deg_per_sec=0.0,
+                                torque=torque,
+                            )
+                        
+                        for motor in leader.bus_left.motors:
+                            full_name = f"left_{motor}"
+                            position = leader_positions_deg.get(full_name, 0.0)
+                            torque = leader_total_torques_nm.get(full_name, 0.0)
+                            kd = leader.get_damping_kd(motor)
+                            
+                            leader.bus_left._mit_control(
+                                motor=motor, kp=0.0, kd=kd,
+                                position_degrees=position,
+                                velocity_deg_per_sec=0.0,
+                                torque=torque,
+                            )
+                        
+                        # Send leader positions to follower
+                        follower_action = {}
+                        for joint in leader_positions_deg.keys():
+                            pos_key = f"{joint}.pos"
+                            if pos_key in leader_action:
+                                follower_action[pos_key] = leader_action[pos_key]
+                        
+                        if follower_action:
+                            follower.send_action(follower_action)
+                        
+                        # Maintain loop rate
+                        loop_duration = time.perf_counter() - loop_start
+                        sleep_time = dt - loop_duration
+                        if sleep_time > 0:
+                            time.sleep(sleep_time)
+                    
+                    print("Reset complete")
+                else:
+                    log_say("Waiting for manual reset")
+                    print(f"Manually reset the environment and press ENTER to continue")
+                    input("Press ENTER when ready...")
+        
+        print(f"Evaluation complete! {episode_idx} episodes recorded")
+        log_say("Evaluation complete", blocking=True)
+    
+    except KeyboardInterrupt:
+        print("\n\nEvaluation interrupted by user")
+    
+    finally:
+        if leader:
+            leader.bus_right.disable_torque()
+            leader.bus_left.disable_torque()
+            time.sleep(0.1)
+            leader.disconnect()
+
+        follower.disconnect()
+        
+        if listener is not None:
+            listener.stop()
+        
+        dataset.finalize()
+        print("\nUploading to Hugging Face Hub...")
+        dataset.push_to_hub(private=True)
+
+
+if __name__ == "__main__":
+    main()
+

examples/openarms/friction_compensation.py

@@ -0,0 +1,216 @@
+import time
+import numpy as np
+
+from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
+from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
+
+
+# Friction model parameters from OpenArms config/follower.yaml
+# τ_fric(ω) = Fo + Fv·ω + Fc·tanh(k·ω)
+# For 8 motors: [joint_1, joint_2, joint_3, joint_4, joint_5, joint_6, joint_7, gripper]
+FRICTION_PARAMS = {
+    "Fc": [0.306, 0.306, 0.40, 0.166, 0.050, 0.093, 0.172, 0.0512],  # Coulomb friction [Nm]
+    "k": [28.417, 28.417, 29.065, 130.038, 151.771, 242.287, 7.888, 4.000],  # tanh steepness
+    "Fv": [0.063, 0.0630, 0.604, 0.813, 0.029, 0.072, 0.084, 0.084],  # Viscous friction [Nm·s/rad]
+    "Fo": [0.088, 0.088, 0.008, -0.058, 0.005, 0.009, -0.059, -0.050],  # Offset torque [Nm]
+}
+
+# Constants from OpenArms C++ implementation
+AMP_TMP = 1.0
+COEF_TMP = 0.1
+
+FRICTION_SCALE = 1.0  # OpenArms C++ uses 0.3 factor in unilateral mode
+DAMPING_KD = [0.5, 0.5, 0.5, 0.5, 0.1, 0.1, 0.1, 0.1]  # Damping gains for stability
+
+def compute_friction_torque(velocity_rad_per_sec: float, motor_index: int) -> float:
+    """
+    Compute friction torque for a single motor using the tanh friction model.
+    
+    Args:
+        velocity_rad_per_sec: Angular velocity in rad/s
+        motor_index: Index of the motor (0-7)
+        
+    Returns:
+        Friction torque in N·m (scaled for stability)
+    """
+    
+    Fc = FRICTION_PARAMS["Fc"][motor_index]
+    k = FRICTION_PARAMS["k"][motor_index]
+    Fv = FRICTION_PARAMS["Fv"][motor_index]
+    Fo = FRICTION_PARAMS["Fo"][motor_index]
+    
+    # Friction model: τ_fric = amp * Fc * tanh(coef * k * ω) + Fv * ω + Fo
+    friction_torque = (
+        AMP_TMP * Fc * np.tanh(COEF_TMP * k * velocity_rad_per_sec) +
+        Fv * velocity_rad_per_sec +
+        Fo
+    )
+    
+    # Scale down friction compensation for stability at lower control rates
+    # (OpenArms C++ uses 0.3 factor in unilateral mode)!!
+    friction_torque *= FRICTION_SCALE
+    
+    return friction_torque
+
+
+def main() -> None:
+    config = OpenArmsFollowerConfig(
+        port_left="can0",
+        port_right="can1",
+        can_interface="socketcan",
+        id="openarms_follower",
+        disable_torque_on_disconnect=True,
+        max_relative_target=5.0,
+    )
+    
+    print("Initializing robot...")
+    follower = OpenArmsFollower(config)
+    follower.connect(calibrate=True)
+    
+    print(f"Applying friction compensation")
+    print("  1. Support the arm before starting")
+    print("  2. The arm will be held in place by friction compensation")
+    print("  3. You should be able to move it with gentle force")
+    print("\nPress ENTER when ready to start...")
+    input()
+    
+    print(f"✓ Motors enabled")
+    print("\nStarting friction compensation loop...")
+    print("Press Ctrl+C to stop\n")
+    
+    loop_times = []
+    last_print_time = time.perf_counter()
+    
+    # Motor name to index mapping
+    motor_name_to_index = {
+        "joint_1": 0,
+        "joint_2": 1,
+        "joint_3": 2,
+        "joint_4": 3,
+        "joint_5": 4,
+        "joint_6": 5,
+        "joint_7": 6,
+        "gripper": 7,
+    }
+    
+    try:
+        while True:
+            loop_start = time.perf_counter()
+            
+            # Get current joint positions and velocities from robot
+            obs = follower.get_observation()
+            
+            # Extract velocities in degrees per second
+            velocities_deg_per_sec = {}
+            positions_deg = {}
+            
+            for motor in follower.bus_right.motors:
+                vel_key = f"right_{motor}.vel"
+                pos_key = f"right_{motor}.pos"
+                if vel_key in obs:
+                    velocities_deg_per_sec[f"right_{motor}"] = obs[vel_key]
+                if pos_key in obs:
+                    positions_deg[f"right_{motor}"] = obs[pos_key]
+            
+            for motor in follower.bus_left.motors:
+                vel_key = f"left_{motor}.vel"
+                pos_key = f"left_{motor}.pos"
+                if vel_key in obs:
+                    velocities_deg_per_sec[f"left_{motor}"] = obs[vel_key]
+                if pos_key in obs:
+                    positions_deg[f"left_{motor}"] = obs[pos_key]
+            
+            # Convert velocities to rad/s and compute friction torques
+            friction_torques_nm = {}
+            for motor_full_name, velocity_deg_per_sec in velocities_deg_per_sec.items():
+                # Extract motor name without arm prefix
+                if motor_full_name.startswith("right_"):
+                    motor_name = motor_full_name.removeprefix("right_")
+                elif motor_full_name.startswith("left_"):
+                    motor_name = motor_full_name.removeprefix("left_")
+                else:
+                    continue
+                
+                # Get motor index for friction parameters
+                motor_index = motor_name_to_index.get(motor_name, 0)
+                
+                # Convert velocity to rad/s
+                velocity_rad_per_sec = np.deg2rad(velocity_deg_per_sec)
+                
+                # Compute friction torque
+                friction_torque = compute_friction_torque(velocity_rad_per_sec, motor_index)
+                friction_torques_nm[motor_full_name] = friction_torque
+            
+            # Apply friction compensation to right arm (all joints INCLUDING gripper)
+            for motor in follower.bus_right.motors:
+                full_name = f"right_{motor}"
+                position = positions_deg.get(full_name, 0.0)
+                torque = friction_torques_nm.get(full_name, 0.0)
+                
+                # Get motor index for damping gain
+                motor_index = motor_name_to_index.get(motor, 0)
+                kd = DAMPING_KD[motor_index]
+                
+                # Send MIT control command with friction compensation + damping
+                follower.bus_right._mit_control(
+                    motor=motor,
+                    kp=0.0,  # No position control
+                    kd=kd,   # Add damping for stability
+                    position_degrees=position,
+                    velocity_deg_per_sec=0.0,
+                    torque=torque
+                )
+
+            # Apply friction compensation to left arm (all joints INCLUDING gripper)
+            for motor in follower.bus_left.motors:
+                full_name = f"left_{motor}"
+                position = positions_deg.get(full_name, 0.0)
+                torque = friction_torques_nm.get(full_name, 0.0)
+                
+                # Get motor index for damping gain
+                motor_index = motor_name_to_index.get(motor, 0)
+                kd = DAMPING_KD[motor_index]
+                
+                # Send MIT control command with friction compensation + damping
+                follower.bus_left._mit_control(
+                    motor=motor,
+                    kp=0.0,  # No position control
+                    kd=kd,   # Add damping for stability
+                    position_degrees=position,
+                    velocity_deg_per_sec=0.0,
+                    torque=torque
+                )
+            
+            # Measure loop time
+            loop_end = time.perf_counter()
+            loop_time = loop_end - loop_start
+            loop_times.append(loop_time)
+            
+            # Print status every 2 seconds
+            if loop_end - last_print_time >= 2.0:
+                if loop_times:
+                    avg_time = sum(loop_times) / len(loop_times)
+                    current_hz = 1.0 / avg_time if avg_time > 0 else 0
+                    
+                    print(f"{current_hz:.1f} Hz")
+
+                    loop_times = []
+                    last_print_time = loop_end
+            
+            time.sleep(0.001)
+            
+    except KeyboardInterrupt:
+        print("\n\nStopping friction compensation...")
+    
+    finally:
+        print("\nDisabling all motors and disconnecting...")
+        follower.bus_right.disable_torque()
+        follower.bus_left.disable_torque()
+        time.sleep(0.1)
+        follower.disconnect()
+        print("✓ Safe shutdown complete")
+
+
+if __name__ == "__main__":
+    main()
+

examples/openarms/gravity_compensation.py

@@ -0,0 +1,142 @@
+import time
+import numpy as np
+import pinocchio as pin
+from os.path import join, dirname, exists, expanduser
+
+from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
+from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
+
+
+def main() -> None:
+    config = OpenArmsFollowerConfig(
+        port_left="can0",
+        port_right="can1",
+        can_interface="socketcan",
+        id="openarms_follower",
+        disable_torque_on_disconnect=True,
+        max_relative_target=5.0,
+    )
+    
+    
+    print("Initializing robot...")
+    follower = OpenArmsFollower(config)
+    follower.connect(calibrate=True)
+    
+    # Load URDF for Pinocchio dynamics
+    urdf_path = "/home/croissant/Documents/openarm_description/openarm_bimanual_pybullet.urdf"
+    
+    pin_robot = pin.RobotWrapper.BuildFromURDF(urdf_path, dirname(urdf_path))
+    pin_robot.data = pin_robot.model.createData()
+    print(f"✓ Loaded Pinocchio model with {pin_robot.nq} DoFs")
+    
+    follower.pin_robot = pin_robot
+    
+    print(f"Applying gravity compensation")
+    print("  1. Support the arm before starting")
+    print("  2. The arm will be held in place by gravity compensation")
+    print("  3. You should be able to move it with gentle force")
+    print("\nPress ENTER when ready to start...")
+    input()
+    
+    print(f"✓ Motors enabled")
+    print("\nStarting gravity compensation loop...")
+    print("Press Ctrl+C to stop\n")
+    
+    loop_times = []
+    last_print_time = time.perf_counter()
+    
+    try:
+        while True:
+            loop_start = time.perf_counter()
+            
+            # Get current joint positions from robot
+            obs = follower.get_observation()
+            
+            # Extract positions in degrees
+            positions_deg = {}
+            for motor in follower.bus_right.motors:
+                key = f"right_{motor}.pos"
+                if key in obs:
+                    positions_deg[f"right_{motor}"] = obs[key]
+            
+            for motor in follower.bus_left.motors:
+                key = f"left_{motor}.pos"
+                if key in obs:
+                    positions_deg[f"left_{motor}"] = obs[key]
+            
+            # Convert to radians and calculate gravity torques
+            # Use the built-in method from OpenArmsFollower
+            positions_rad = {k: np.deg2rad(v) for k, v in positions_deg.items()}
+            torques_nm = follower._gravity_from_q(positions_rad)
+            
+            # Apply gravity compensation to right arm (all joints except gripper)
+            for motor in follower.bus_right.motors:
+                if motor == "gripper":
+                    continue  # Skip gripper
+                    
+                full_name = f"right_{motor}"
+                position = positions_deg.get(full_name, 0.0)
+                torque = torques_nm.get(full_name, 0.0)
+                
+                # Send MIT control command with gravity compensation torque
+                follower.bus_right._mit_control(
+                    motor=motor,
+                    kp=0.0,  # No position control
+                    kd=0.0,  # No velocity damping
+                    position_degrees=position,
+                    velocity_deg_per_sec=0.0,
+                    torque=torque
+                )
+
+            # Apply gravity compensation to left arm (all joints except gripper)
+            for motor in follower.bus_left.motors:
+                if motor == "gripper":
+                    continue  # Skip gripper
+                    
+                full_name = f"left_{motor}"
+                position = positions_deg.get(full_name, 0.0)
+                torque = torques_nm.get(full_name, 0.0)
+                
+                # Send MIT control command with gravity compensation torque
+                follower.bus_left._mit_control(
+                    motor=motor,
+                    kp=0.0,  # No position control
+                    kd=0.0,  # No velocity damping
+                    position_degrees=position,
+                    velocity_deg_per_sec=0.0,
+                    torque=torque
+                )
+            
+            # Measure loop time
+            loop_end = time.perf_counter()
+            loop_time = loop_end - loop_start
+            loop_times.append(loop_time)
+            
+            # Print status every 2 seconds
+            if loop_end - last_print_time >= 2.0:
+                if loop_times:
+                    avg_time = sum(loop_times) / len(loop_times)
+                    current_hz = 1.0 / avg_time if avg_time > 0 else 0
+                    
+                    print(f"{current_hz:.1f} Hz ({avg_time*1000:.1f} ms)")
+
+                    loop_times = []
+                    last_print_time = loop_end
+            
+            time.sleep(0.005)
+            
+    except KeyboardInterrupt:
+        print("\n\nStopping gravity compensation...")
+    
+    finally:
+        print("\nDisabling all motors and disconnecting...")
+        follower.bus_right.disable_torque()
+        follower.bus_left.disable_torque()
+        time.sleep(0.1)
+        follower.disconnect()
+        print("✓ Safe shutdown complete")
+
+
+if __name__ == "__main__":
+    main()
+

examples/openarms/record_with_compensation.py

@@ -0,0 +1,395 @@
+"""
+OpenArms Dataset Recording with Gravity + Friction Compensation
+
+Records a dataset using OpenArms follower robot with leader teleoperator.
+Leader arms have gravity and friction compensation for weightless, easy movement.
+Includes 3 cameras: left wrist, right wrist, and base camera.
+
+Uses the same compensation approach as teleop_with_compensation.py
+"""
+
+import shutil
+import time
+from pathlib import Path
+
+import numpy as np
+
+from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
+from lerobot.datasets.lerobot_dataset import LeRobotDataset
+from lerobot.datasets.utils import build_dataset_frame, hw_to_dataset_features
+from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
+from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
+from lerobot.teleoperators.openarms.config_openarms_leader import OpenArmsLeaderConfig
+from lerobot.teleoperators.openarms.openarms_leader import OpenArmsLeader
+from lerobot.utils.control_utils import init_keyboard_listener
+from lerobot.utils.utils import log_say
+from lerobot.utils.visualization_utils import init_rerun, log_rerun_data
+
+# Recording parameters
+NUM_EPISODES = 1
+FPS = 30
+EPISODE_TIME_SEC = 600
+RESET_TIME_SEC = 120
+TASK_DESCRIPTION = "OpenArms task description"
+
+# Friction compensation scale factor (1.0 = full, 0.3 = 30% for stability)
+FRICTION_SCALE = 1.0
+
+def record_loop_with_compensation(
+    robot,
+    leader,
+    events,
+    fps,
+    dataset,
+    dataset_features,
+    control_time_s,
+    single_task,
+    display_data=True,
+):
+    """
+    Custom record loop that applies gravity + friction compensation to leader.
+    Based on record_loop but with integrated compensation.
+    """
+    dt = 1 / fps
+    episode_start_time = time.perf_counter()
+    
+    # All joints (both arms)
+    all_joints = []
+    for motor in leader.bus_right.motors:
+        all_joints.append(f"right_{motor}")
+    for motor in leader.bus_left.motors:
+        all_joints.append(f"left_{motor}")
+    
+    while True:
+        loop_start = time.perf_counter()
+        elapsed = loop_start - episode_start_time
+        
+        # Check if we should exit
+        if elapsed >= control_time_s or events["exit_early"] or events["stop_recording"]:
+            break
+        
+        # Get leader state
+        leader_action = leader.get_action()
+        
+        # Extract positions and velocities in degrees
+        leader_positions_deg = {}
+        leader_velocities_deg_per_sec = {}
+        
+        for motor in leader.bus_right.motors:
+            pos_key = f"right_{motor}.pos"
+            vel_key = f"right_{motor}.vel"
+            if pos_key in leader_action:
+                leader_positions_deg[f"right_{motor}"] = leader_action[pos_key]
+            if vel_key in leader_action:
+                leader_velocities_deg_per_sec[f"right_{motor}"] = leader_action[vel_key]
+        
+        for motor in leader.bus_left.motors:
+            pos_key = f"left_{motor}.pos"
+            vel_key = f"left_{motor}.vel"
+            if pos_key in leader_action:
+                leader_positions_deg[f"left_{motor}"] = leader_action[pos_key]
+            if vel_key in leader_action:
+                leader_velocities_deg_per_sec[f"left_{motor}"] = leader_action[vel_key]
+        
+        # Calculate gravity torques for leader using built-in method
+        leader_positions_rad = {k: np.deg2rad(v) for k, v in leader_positions_deg.items()}
+        leader_gravity_torques_nm = leader._gravity_from_q(leader_positions_rad)
+        
+        # Calculate friction torques for leader using built-in method
+        leader_velocities_rad_per_sec = {k: np.deg2rad(v) for k, v in leader_velocities_deg_per_sec.items()}
+        leader_friction_torques_nm = leader._friction_from_velocity(
+            leader_velocities_rad_per_sec,
+            friction_scale=FRICTION_SCALE
+        )
+        
+        # Combine gravity + friction torques
+        leader_total_torques_nm = {}
+        for motor_name in leader_gravity_torques_nm:
+            gravity = leader_gravity_torques_nm.get(motor_name, 0.0)
+            friction = leader_friction_torques_nm.get(motor_name, 0.0)
+            leader_total_torques_nm[motor_name] = gravity + friction
+        
+        # Apply gravity + friction compensation to leader RIGHT arm (all joints including gripper)
+        for motor in leader.bus_right.motors:
+            full_name = f"right_{motor}"
+            position = leader_positions_deg.get(full_name, 0.0)
+            torque = leader_total_torques_nm.get(full_name, 0.0)
+            
+            # Get damping gain for stability
+            kd = leader.get_damping_kd(motor)
+            
+            leader.bus_right._mit_control(
+                motor=motor,
+                kp=0.0,
+                kd=kd,  # Add damping for stability
+                position_degrees=position,
+                velocity_deg_per_sec=0.0,
+                torque=torque,
+            )
+        
+        # Apply gravity + friction compensation to leader LEFT arm (all joints including gripper)
+        for motor in leader.bus_left.motors:
+            full_name = f"left_{motor}"
+            position = leader_positions_deg.get(full_name, 0.0)
+            torque = leader_total_torques_nm.get(full_name, 0.0)
+            
+            # Get damping gain for stability
+            kd = leader.get_damping_kd(motor)
+            
+            leader.bus_left._mit_control(
+                motor=motor,
+                kp=0.0,
+                kd=kd,  # Add damping for stability
+                position_degrees=position,
+                velocity_deg_per_sec=0.0,
+                torque=torque,
+            )
+        
+        # Send leader positions to follower (both arms)
+        follower_action = {}
+        for joint in all_joints:
+            pos_key = f"{joint}.pos"
+            if pos_key in leader_action:
+                follower_action[pos_key] = leader_action[pos_key]
+        
+        # Send action to robot
+        if follower_action:
+            robot.send_action(follower_action)
+        
+        # Get observation from robot (includes camera images)
+        observation = robot.get_observation()
+        
+        # Add to dataset if we have a dataset
+        if dataset is not None:
+            # Build properly formatted observation frame
+            obs_frame = build_dataset_frame(dataset_features, observation, prefix="observation")
+            
+            # Build properly formatted action frame (keep .pos suffix - it matches the feature names)
+            action_frame = build_dataset_frame(dataset_features, follower_action, prefix="action")
+            
+            # Combine into single frame
+            frame = {**obs_frame, **action_frame}
+            
+            # Add metadata (task is required, timestamp will be auto-calculated by add_frame)
+            frame["task"] = single_task
+            
+            dataset.add_frame(frame)
+        
+        # Display data if requested
+        if display_data:
+            log_rerun_data(observation=observation, action=follower_action)
+        
+        # Maintain loop rate
+        loop_duration = time.perf_counter() - loop_start
+        sleep_time = dt - loop_duration
+        if sleep_time > 0:
+            time.sleep(sleep_time)
+
+
+def main():
+    """Main recording loop with gravity compensation."""
+    
+    print("=" * 70)
+    print("OpenArms Dataset Recording with Compensation")
+    print("=" * 70)
+    
+    # Create camera configurations (3 cameras: left wrist, right wrist, base)
+    # Using actual device paths found by lerobot-find-cameras opencv
+    camera_config = {
+        "left_wrist": OpenCVCameraConfig(index_or_path="/dev/video0", width=640, height=480, fps=FPS),
+        "right_wrist": OpenCVCameraConfig(index_or_path="/dev/video1", width=640, height=480, fps=FPS),
+        "base": OpenCVCameraConfig(index_or_path="/dev/video7", width=640, height=480, fps=FPS),
+    }
+    
+    # Configure follower robot with cameras
+    follower_config = OpenArmsFollowerConfig(
+        port_left="can2",
+        port_right="can3",
+        can_interface="socketcan",
+        id="openarms_follower",
+        disable_torque_on_disconnect=True,
+        max_relative_target=10.0,
+        cameras=camera_config,
+    )
+    
+    # Configure leader teleoperator (no cameras needed)
+    leader_config = OpenArmsLeaderConfig(
+        port_left="can0",
+        port_right="can1",
+        can_interface="socketcan",
+        id="openarms_leader",
+        manual_control=False,  # Enable torque control for gravity compensation
+    )
+    
+    # Initialize robot and teleoperator
+    print("\nInitializing devices...")
+    follower = OpenArmsFollower(follower_config)
+    leader = OpenArmsLeader(leader_config)
+    
+    # Connect devices
+    print("Connecting and calibrating...")
+    follower.connect(calibrate=True)
+    leader.connect(calibrate=True)
+    
+    # Verify URDF is loaded for gravity compensation
+    if leader.pin_robot is None:
+        raise RuntimeError("URDF model not loaded on leader. Gravity compensation not available.")
+    
+    # Configure the dataset features
+    # For actions, we only want to record positions (not velocity or torque)
+    action_features_hw = {}
+    for key, value in follower.action_features.items():
+        if key.endswith(".pos"):
+            action_features_hw[key] = value
+    
+    action_features = hw_to_dataset_features(action_features_hw, "action")
+    obs_features = hw_to_dataset_features(follower.observation_features, "observation")
+    dataset_features = {**action_features, **obs_features}
+    
+    # Create the dataset
+    print("\nCreating dataset...")
+    repo_id = "<hf_username>/<dataset_repo_id>"  # TODO: Replace with your Hugging Face repo
+    
+    # Check if dataset already exists and prompt user
+    dataset_path = Path.home() / ".cache" / "huggingface" / "lerobot" / repo_id
+    while dataset_path.exists():
+        print(f"\nDataset already exists at: {dataset_path}")
+        print("\nOptions:")
+        print("  1. Overwrite existing dataset")
+        print("  2. Use a different name")
+        print("  3. Abort")
+        
+        choice = input("\nEnter your choice (1/2/3): ").strip()
+        
+        if choice == '1':
+            print(f"Removing existing dataset...")
+            shutil.rmtree(dataset_path)
+            print("✓ Existing dataset removed")
+            break
+        elif choice == '2':
+            print("\nCurrent repo_id:", repo_id)
+            new_repo_id = input("Enter new repo_id (format: <username>/<dataset_name>): ").strip()
+            if new_repo_id and '/' in new_repo_id:
+                repo_id = new_repo_id
+                dataset_path = Path.home() / ".cache" / "huggingface" / "lerobot" / repo_id
+                print(f"✓ Using new repo_id: {repo_id}")
+                # Loop will continue if this new path also exists
+            else:
+                print("Invalid repo_id format. Please use format: <username>/<dataset_name>")
+        elif choice == '3':
+            print("Aborting. Please remove the existing dataset manually or restart with a different repo_id.")
+            follower.disconnect()
+            leader.disconnect()
+            return
+        else:
+            print("Invalid choice. Please enter 1, 2, or 3.")
+    
+    dataset = LeRobotDataset.create(
+        repo_id=repo_id,
+        fps=FPS,
+        features=dataset_features,
+        robot_type=follower.name,
+        use_videos=True,
+        image_writer_threads=4,
+    )
+    
+    # Initialize keyboard listener and visualization
+    _, events = init_keyboard_listener()
+    init_rerun(session_name="openarms_recording")
+    
+    # Enable motors on both leader arms for gravity compensation
+    leader.bus_right.enable_torque()
+    leader.bus_left.enable_torque()
+    time.sleep(0.1)
+    
+    print("\n" + "=" * 70)
+    print(f"Recording {NUM_EPISODES} episodes")
+    print(f"Task: {TASK_DESCRIPTION}")
+    print("=" * 70)
+    print("\nLeader BOTH arms: Gravity + Friction comp | Follower BOTH arms: Teleop")
+    print("\nKeyboard controls:")
+    print("  - Press 'q' to stop recording")
+    print("  - Press 'r' to re-record current episode")
+    print("=" * 70)
+    
+    episode_idx = 0
+    
+    try:
+        while episode_idx < NUM_EPISODES and not events["stop_recording"]:
+            log_say(f"Recording episode {episode_idx + 1} of {NUM_EPISODES}")
+            
+            # Record episode with compensation active
+            record_loop_with_compensation(
+                robot=follower,
+                leader=leader,
+                events=events,
+                fps=FPS,
+                dataset=dataset,
+                dataset_features=dataset_features,
+                control_time_s=EPISODE_TIME_SEC,
+                single_task=TASK_DESCRIPTION,
+                display_data=True,
+            )
+            
+            # Reset the environment if not stopping or re-recording
+            if not events["stop_recording"] and (episode_idx < NUM_EPISODES - 1 or events["rerecord_episode"]):
+                log_say("Reset the environment")
+                record_loop_with_compensation(
+                    robot=follower,
+                    leader=leader,
+                    events=events,
+                    fps=FPS,
+                    dataset=None,  # Don't save reset period
+                    dataset_features=dataset_features,
+                    control_time_s=RESET_TIME_SEC,
+                    single_task=TASK_DESCRIPTION,
+                    display_data=True,
+                )
+            
+            # Handle re-recording
+            if events["rerecord_episode"]:
+                log_say("Re-recording episode")
+                events["rerecord_episode"] = False
+                events["exit_early"] = False
+                dataset.clear_episode_buffer()
+                continue
+            
+            # Only save episode if frames were recorded
+            if dataset.episode_buffer is not None and dataset.episode_buffer["size"] > 0:
+                dataset.save_episode()
+                episode_idx += 1
+            else:
+                log_say("No frames recorded, skipping episode save")
+                # Clear the empty buffer
+                dataset.episode_buffer = None
+    
+    except KeyboardInterrupt:
+        print("\n\nStopping recording...")
+    
+    finally:
+        # Clean up
+        log_say("Stop recording")
+        try:
+            leader.bus_right.disable_torque()
+            leader.bus_left.disable_torque()
+            time.sleep(0.1)
+            leader.disconnect()
+            follower.disconnect()
+            print("✓ Shutdown complete")
+        except Exception as e:
+            print(f"Shutdown error: {e}")
+        
+        # Upload dataset
+        print("\nUploading dataset to Hugging Face Hub...")
+        try:
+            dataset.push_to_hub()
+            print("✓ Dataset uploaded successfully")
+        except Exception as e:
+            print(f"Warning: Failed to upload dataset: {e}")
+            print("You can manually upload later using: dataset.push_to_hub()")
+        
+        print("✓ Recording complete!")
+
+
+if __name__ == "__main__":
+    main()

examples/openarms/replay.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python
+
+# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+OpenArms Dataset Replay Example
+
+Replays position actions from a recorded dataset on an OpenArms follower robot.
+Only position commands (ending with .pos) are replayed, not velocity or torque.
+
+Example usage:
+    python examples/openarms/replay.py
+"""
+
+import time
+
+from lerobot.datasets.lerobot_dataset import LeRobotDataset
+from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
+from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
+from lerobot.utils.constants import ACTION
+from lerobot.utils.robot_utils import busy_wait
+from lerobot.utils.utils import log_say
+
+# Configuration
+EPISODE_IDX = 0
+DATASET_REPO_ID = "lerobot-data-collection/replay-this-2025-11-02-17-58"  # TODO: Replace with your dataset
+DATASET_ROOT = None  # Use default cache location, or specify custom path
+
+# Robot configuration - adjust these to match your setup
+ROBOT_CONFIG = OpenArmsFollowerConfig(
+    port_left="can2",      # CAN interface for left arm
+    port_right="can3",     # CAN interface for right arm
+    can_interface="socketcan", 
+    id="openarms_follower",
+    disable_torque_on_disconnect=True,
+    max_relative_target=10.0,  # Safety limit: max degrees to move per step
+)
+
+
+def main():
+    """Main replay function."""
+    print("=" * 70)
+    print("OpenArms Dataset Replay")
+    print("=" * 70)
+    print(f"\nDataset: {DATASET_REPO_ID}")
+    print(f"Episode: {EPISODE_IDX}")
+    print(f"Robot: {ROBOT_CONFIG.id}")
+    print(f"  Left arm: {ROBOT_CONFIG.port_left}")
+    print(f"  Right arm: {ROBOT_CONFIG.port_right}")
+    print("\n" + "=" * 70)
+    
+    # Initialize the robot
+    print("\n[1/3] Initializing robot...")
+    robot = OpenArmsFollower(ROBOT_CONFIG)
+    
+    # Load the dataset
+    print(f"\n[2/3] Loading dataset '{DATASET_REPO_ID}'...")
+    dataset = LeRobotDataset(
+        DATASET_REPO_ID,
+        root=DATASET_ROOT,
+        episodes=[EPISODE_IDX]
+    )
+    
+    # Filter dataset to only include frames from the specified episode
+    # (required for dataset V3.0 where episodes are chunked)
+    episode_frames = dataset.hf_dataset.filter(
+        lambda x: x["episode_index"] == EPISODE_IDX
+    )
+    
+    if len(episode_frames) == 0:
+        raise ValueError(
+            f"No frames found for episode {EPISODE_IDX} in dataset {DATASET_REPO_ID}"
+        )
+    
+    print(f"  Found {len(episode_frames)} frames in episode {EPISODE_IDX}")
+    
+    # Extract action features from dataset
+    action_features = dataset.features.get(ACTION, {})
+    action_names = action_features.get("names", [])
+    
+    # Filter to only position actions (ending with .pos)
+    position_action_names = [name for name in action_names if name.endswith(".pos")]
+    
+    if not position_action_names:
+        raise ValueError(
+            f"No position actions found in dataset. Action names: {action_names}"
+        )
+    
+    print(f"  Found {len(position_action_names)} position actions to replay")
+    print(f"  Actions: {', '.join(position_action_names[:5])}{'...' if len(position_action_names) > 5 else ''}")
+    
+    # Select only action columns from dataset
+    actions = episode_frames.select_columns(ACTION)
+    
+    # Connect to the robot
+    print(f"\n[3/3] Connecting to robot...")
+    robot.connect(calibrate=False)  # Skip calibration for replay
+    
+    if not robot.is_connected:
+        raise RuntimeError("Robot failed to connect!")
+    
+    print("\n" + "=" * 70)
+    print("Ready to replay!")
+    print("=" * 70)
+    print("\nThe robot will replay the recorded positions.")
+    print("Press Ctrl+C to stop at any time.\n")
+    
+    input("Press ENTER to start replaying...")
+    
+    # Replay loop
+    log_say(f"Replaying episode {EPISODE_IDX}", blocking=True)
+    
+    try:
+        for idx in range(len(episode_frames)):
+            loop_start = time.perf_counter()
+            
+            # Extract action array from dataset
+            action_array = actions[idx][ACTION]
+            
+            # Build action dictionary, but only include position actions
+            action = {}
+            for i, name in enumerate(action_names):
+                # Only include position actions (ending with .pos)
+                if name.endswith(".pos"):
+                    action[name] = float(action_array[i])
+            
+            # Send action to robot
+            robot.send_action(action)
+            
+            # Maintain replay rate (use dataset fps)
+            loop_duration = time.perf_counter() - loop_start
+            dt_s = 1.0 / dataset.fps - loop_duration
+            busy_wait(dt_s)
+            
+            # Progress indicator every 100 frames
+            if (idx + 1) % 100 == 0:
+                progress = (idx + 1) / len(episode_frames) * 100
+                print(f"Progress: {idx + 1}/{len(episode_frames)} frames ({progress:.1f}%)")
+        
+        print(f"\n✓ Successfully replayed {len(episode_frames)} frames")
+        log_say("Replay complete", blocking=True)
+        
+    except KeyboardInterrupt:
+        print("\n\nReplay interrupted by user")
+    finally:
+        # Disconnect robot
+        print("\nDisconnecting robot...")
+        robot.disconnect()
+        print("✓ Replay complete!")
+
+
+if __name__ == "__main__":
+    main()
+

examples/openarms/teleop.py

@@ -14,8 +14,8 @@ from lerobot.teleoperators.openarms.config_openarms_leader import OpenArmsLeader
 
 
 follower_config = OpenArmsFollowerConfig(
-    port_left="can0",   # CAN interface for follower left arm
-    port_right="can1",  # CAN interface for follower right arm
+    port_left="can2",   # CAN interface for follower left arm
+    port_right="can3",  # CAN interface for follower right arm
     can_interface="socketcan",  # Linux SocketCAN
     id="openarms_follower",
     disable_torque_on_disconnect=True,
@@ -24,8 +24,8 @@ follower_config = OpenArmsFollowerConfig(
 
 
 leader_config = OpenArmsLeaderConfig(
-    port_left="can2",   # CAN interface for leader left arm
-    port_right="can3",  # CAN interface for leader right arm
+    port_left="can0",   # CAN interface for leader left arm
+    port_right="can1",  # CAN interface for leader right arm
     can_interface="socketcan",  # Linux SocketCAN
     id="openarms_leader",
     manual_control=True,  # Enable manual control (torque disabled)

examples/openarms/teleop_openarms_mini.py

@@ -0,0 +1,197 @@
+"""
+OpenArms Mini Teleoperation Example
+
+This script demonstrates teleoperation of an OpenArms follower robot using 
+an OpenArms Mini leader (Feetech-based) with dual arms (16 motors total).
+
+The OpenArms Mini has:
+- Right arm: 8 motors (joint_1 to joint_7 + gripper)
+- Left arm: 8 motors (joint_1 to joint_7 + gripper)
+
+Note on gripper normalization:
+- OpenArms Mini gripper: 0-100 scale (0=closed, 100=open)
+- OpenArms follower gripper: degrees (0=closed, -65=open)
+- This script automatically converts between the two ranges
+"""
+
+import time
+import os
+import sys
+
+from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
+from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
+from lerobot.teleoperators.openarms_mini.openarms_mini import OpenArmsMini
+from lerobot.teleoperators.openarms_mini.config_openarms_mini import OpenArmsMiniConfig
+from lerobot.utils.robot_utils import busy_wait
+
+# Target control frequency
+TARGET_FPS = 30
+
+# Configure the OpenArms follower (Damiao motors on CAN bus)
+follower_config = OpenArmsFollowerConfig(
+    port_left="can0",   # CAN interface for follower left arm
+    port_right="can1",  # CAN interface for follower right arm
+    can_interface="socketcan",  # Linux SocketCAN
+    id="openarms_follower",
+    disable_torque_on_disconnect=True,
+    max_relative_target=10.0,  # Safety limit (degrees per step)
+)
+
+# Configure the OpenArms Mini leader (Feetech motors on serial)
+leader_config = OpenArmsMiniConfig(
+    port_right="/dev/ttyACM0",  # Serial port for right arm
+    port_left="/dev/ttyACM1",   # Serial port for left arm
+    id="openarms_mini",
+    use_degrees=True,
+)
+
+print("OpenArms Mini → OpenArms Follower Teleoperation")
+
+# Initialize devices
+follower = OpenArmsFollower(follower_config)
+leader = OpenArmsMini(leader_config)
+
+# Connect and calibrate follower
+print("Note: If you have existing calibration, just press ENTER to use it.")
+follower.connect(calibrate=True)
+
+# Connect and calibrate leader
+print("Note: The leader arms will have torque disabled for manual control.")
+leader.connect(calibrate=True)
+
+print("\nPress ENTER to start teleoperation...")
+input()
+
+print("Press Ctrl+C to stop.\n")
+
+# All joints for both arms (16 motors total)
+all_joints = [
+    # Right arm
+    "right_joint_1",
+    "right_joint_2",
+    "right_joint_3",
+    "right_joint_4",
+    "right_joint_5",
+    "right_joint_6",
+    "right_joint_7",
+    "right_gripper",
+    # Left arm
+    "left_joint_1",
+    "left_joint_2",
+    "left_joint_3",
+    "left_joint_4",
+    "left_joint_5",
+    "left_joint_6",
+    "left_joint_7",
+    "left_gripper",
+]
+
+# Performance monitoring
+loop_times = []
+avg_loop_time = 0.0
+min_loop_time = float('inf')
+max_loop_time = 0.0
+stats_update_interval = 1.0  # Update stats every 1 second
+last_stats_update = time.perf_counter()
+
+
+SWAPPED_JOINTS = {
+    "right_joint_6": "right_joint_7",
+    "right_joint_7": "right_joint_6",
+    "left_joint_6": "left_joint_7",
+    "left_joint_7": "left_joint_6",
+}
+
+try:
+    while True:
+        loop_start = time.perf_counter()
+
+        # Get actions and observations
+        leader_action = leader.get_action()
+        follower_obs = follower.get_observation()
+
+        joint_action = {}
+        for joint in all_joints:
+            leader_key = f"{joint}.pos"
+
+            # Determine which follower joint this leader joint controls
+            follower_joint = SWAPPED_JOINTS.get(joint, joint)
+            follower_key = f"{follower_joint}.pos"
+
+            # Get leader position (default 0 if missing)
+            pos = leader_action.get(leader_key, 0.0)
+
+            # Convert gripper values: Mini uses 0-100, OpenArms uses 0 to -65 degrees
+            if "gripper" in joint:
+                # Map 0-100 (Mini) to 0 to -65 (OpenArms)
+                # 0 (closed) -> 0°, 100 (open) -> -65°
+                pos = (pos / 100.0) * -65.0
+
+            # Store in action dict for follower
+            joint_action[follower_key] = pos
+
+        follower.send_action(joint_action)
+
+        # Loop timing
+        loop_end = time.perf_counter()
+        loop_time = loop_end - loop_start
+        loop_times.append(loop_time)
+
+        # Update stats periodically
+        current_time = time.perf_counter()
+        if current_time - last_stats_update >= stats_update_interval:
+            if loop_times:
+                avg_loop_time = sum(loop_times) / len(loop_times)
+                min_loop_time = min(loop_times)
+                max_loop_time = max(loop_times)
+                loop_times = []
+                last_stats_update = current_time
+
+        # Display everything
+        sys.stdout.write("\033[H\033[J")  # Clear screen
+        
+        # Show timing stats at the top
+        if avg_loop_time > 0:
+            avg_hz = 1.0 / avg_loop_time
+            min_hz = 1.0 / max_loop_time if max_loop_time > 0 else 0
+            max_hz = 1.0 / min_loop_time if min_loop_time > 0 and min_loop_time < float('inf') else 0
+            print(f"[Performance] Target: {TARGET_FPS} Hz | Avg: {avg_hz:.1f} Hz | Range: {min_hz:.1f}-{max_hz:.1f} Hz | Loop: {avg_loop_time*1000:.1f} ms\n")
+        else:
+            print(f"[Performance] Target: {TARGET_FPS} Hz | Measuring...\n")
+
+        # Show joint positions
+        print(f"{'Joint':<20} {'Leader':>15} {'Follower':>15}")
+        print(f"{'':20} {'(0-100/deg)':>15} {'(deg)':>15}")
+        print("-" * 52)
+
+        for joint in all_joints:
+            leader_key = f"{joint}.pos"
+            follower_joint = SWAPPED_JOINTS.get(joint, joint)
+            follower_key = f"{follower_joint}.pos"
+
+            leader_pos = leader_action.get(leader_key, 0.0)
+            follower_pos = follower_obs.get(follower_key, 0.0)
+
+            print(f"{joint:<20} {leader_pos:>15.2f} {follower_pos:>15.2f}")
+
+        # Smart sleep to maintain target FPS
+        dt_s = time.perf_counter() - loop_start
+        busy_wait(max(0, 1.0 / TARGET_FPS - dt_s))
+            
+except KeyboardInterrupt:
+    print("\n\nStopping teleoperation...")
+finally:
+    # Disconnect devices
+    print("Disconnecting devices...")
+    try:
+        follower.disconnect()
+    except Exception as e:
+        print(f"Error disconnecting follower: {e}")
+    
+    try:
+        leader.disconnect()
+    except Exception as e:
+        print(f"Error disconnecting leader: {e}")
+    
+    print("Done!")
+

examples/openarms/teleop_with_compensation.py

@@ -0,0 +1,202 @@
+"""
+OpenArms Teleoperation with Gravity + Friction Compensation
+
+Leader arms (both LEFT and RIGHT): Gravity + Friction compensation (weightless, easy to move)
+Follower arms (both LEFT and RIGHT): Mirror leader movements
+
+Uses the URDF file from the lerobot repository.
+"""
+
+import time
+
+import numpy as np
+
+from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
+from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
+from lerobot.teleoperators.openarms.config_openarms_leader import OpenArmsLeaderConfig
+from lerobot.teleoperators.openarms.openarms_leader import OpenArmsLeader
+
+# Friction compensation scale factor (1.0 = full, 0.3 = 30% for stability)
+FRICTION_SCALE = 1.0
+
+def main():
+    """Main teleoperation loop with gravity compensation"""
+
+    print("=" * 70)
+    print("OpenArms Teleoperation with Gravity Compensation")
+    print("=" * 70)
+
+    # Configuration
+    follower_config = OpenArmsFollowerConfig(
+        port_left="can2",
+        port_right="can3",
+        can_interface="socketcan",
+        id="openarms_follower",
+        disable_torque_on_disconnect=True,
+        max_relative_target=10.0,
+    )
+
+    leader_config = OpenArmsLeaderConfig(
+        port_left="can0",
+        port_right="can1",
+        can_interface="socketcan",
+        id="openarms_leader",
+        manual_control=False,  # Enable torque control for gravity compensation
+    )
+
+    # Initialize and connect
+    print("\nInitializing devices...")
+    follower = OpenArmsFollower(follower_config)
+    leader = OpenArmsLeader(leader_config)
+
+    follower.connect()
+    leader.connect()
+
+    # URDF is automatically loaded in the leader constructor
+    if leader.pin_robot is None:
+        raise RuntimeError("URDF model not loaded on leader. Gravity compensation not available.")
+
+    print("\nLeader BOTH arms: Gravity + Friction comp | Follower BOTH arms: Teleop")
+    print("Press ENTER to start...")
+    input()
+
+    # Enable motors on both leader arms for gravity compensation
+    leader.bus_right.enable_torque()
+    leader.bus_left.enable_torque()
+    time.sleep(0.1)
+
+    print("Press Ctrl+C to stop\n")
+
+    # Main control loop
+    loop_times = []
+    last_print_time = time.perf_counter()
+
+    # All joints (both arms)
+    all_joints = []
+    for motor in leader.bus_right.motors:
+        all_joints.append(f"right_{motor}")
+    for motor in leader.bus_left.motors:
+        all_joints.append(f"left_{motor}")
+
+    try:
+        while True:
+            loop_start = time.perf_counter()
+
+            # Get leader state
+            leader_action = leader.get_action()
+
+            # Extract positions and velocities in degrees
+            leader_positions_deg = {}
+            leader_velocities_deg_per_sec = {}
+            
+            for motor in leader.bus_right.motors:
+                pos_key = f"right_{motor}.pos"
+                vel_key = f"right_{motor}.vel"
+                if pos_key in leader_action:
+                    leader_positions_deg[f"right_{motor}"] = leader_action[pos_key]
+                if vel_key in leader_action:
+                    leader_velocities_deg_per_sec[f"right_{motor}"] = leader_action[vel_key]
+
+            for motor in leader.bus_left.motors:
+                pos_key = f"left_{motor}.pos"
+                vel_key = f"left_{motor}.vel"
+                if pos_key in leader_action:
+                    leader_positions_deg[f"left_{motor}"] = leader_action[pos_key]
+                if vel_key in leader_action:
+                    leader_velocities_deg_per_sec[f"left_{motor}"] = leader_action[vel_key]
+
+            # Calculate gravity torques for leader using built-in method
+            leader_positions_rad = {k: np.deg2rad(v) for k, v in leader_positions_deg.items()}
+            leader_gravity_torques_nm = leader._gravity_from_q(leader_positions_rad)
+            
+            # Calculate friction torques for leader using built-in method
+            leader_velocities_rad_per_sec = {k: np.deg2rad(v) for k, v in leader_velocities_deg_per_sec.items()}
+            leader_friction_torques_nm = leader._friction_from_velocity(
+                leader_velocities_rad_per_sec,
+                friction_scale=FRICTION_SCALE
+            )
+            
+            # Combine gravity + friction torques 
+            leader_total_torques_nm = {}
+            for motor_name in leader_gravity_torques_nm:
+                gravity = leader_gravity_torques_nm.get(motor_name, 0.0)
+                friction = leader_friction_torques_nm.get(motor_name, 0.0)
+                leader_total_torques_nm[motor_name] = gravity + friction
+
+            # Apply gravity + friction compensation to leader RIGHT arm (all joints including gripper)
+            for motor in leader.bus_right.motors:
+                full_name = f"right_{motor}"
+                position = leader_positions_deg.get(full_name, 0.0)
+                torque = leader_total_torques_nm.get(full_name, 0.0)
+                
+                # Get damping gain for stability
+                kd = leader.get_damping_kd(motor)
+
+                leader.bus_right._mit_control(
+                    motor=motor,
+                    kp=0.0,
+                    kd=kd,  # Add damping for stability
+                    position_degrees=position,
+                    velocity_deg_per_sec=0.0,
+                    torque=torque,
+                )
+
+            # Apply gravity + friction compensation to leader LEFT arm (all joints including gripper)
+            for motor in leader.bus_left.motors:
+                full_name = f"left_{motor}"
+                position = leader_positions_deg.get(full_name, 0.0)
+                torque = leader_total_torques_nm.get(full_name, 0.0)
+                
+                # Get damping gain for stability
+                kd = leader.get_damping_kd(motor)
+
+                leader.bus_left._mit_control(                    
+                    motor=motor,
+                    kp=0.0,
+                    kd=kd,  # Add damping for stability
+                    position_degrees=position,
+                    velocity_deg_per_sec=0.0,
+                    torque=torque,
+                )
+
+            # Send leader positions to follower (both arms)
+            follower_action = {}
+            for joint in all_joints:
+                pos_key = f"{joint}.pos"
+                if pos_key in leader_action:
+                    follower_action[pos_key] = leader_action[pos_key]
+
+            if follower_action:
+                follower.send_action(follower_action)
+
+            # Performance monitoring
+            loop_end = time.perf_counter()
+            loop_time = loop_end - loop_start
+            loop_times.append(loop_time)
+
+            if loop_end - last_print_time >= 2.0:
+                if loop_times:
+                    avg_time = sum(loop_times) / len(loop_times)
+                    current_hz = 1.0 / avg_time if avg_time > 0 else 0
+
+                    print(f"{current_hz:.1f} Hz ({avg_time*1000:.1f} ms)")
+
+                    loop_times = []
+                    last_print_time = loop_end
+
+    except KeyboardInterrupt:
+        print("\n\nStopping...")
+    finally:
+        try:
+            leader.bus_right.disable_torque()
+            leader.bus_left.disable_torque()
+            time.sleep(0.1)
+            leader.disconnect()
+            follower.disconnect()
+            print("✓ Shutdown complete")
+        except Exception as e:
+            print(f"Shutdown error: {e}")
+
+
+if __name__ == "__main__":
+    main()

examples/openarms_web_interface/App.css

@@ -0,0 +1,745 @@
+body {
+  margin: 0;
+  padding: 0;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+  background: #f5f5f5;
+}
+
+main {
+  min-height: 100vh;
+  padding: 2rem;
+}
+
+header {
+  text-align: center;
+  margin-bottom: 2rem;
+}
+
+h1 {
+  font-size: 2rem;
+  font-weight: 600;
+  color: #333;
+  margin: 0;
+}
+
+h2 {
+  font-size: 1.25rem;
+  font-weight: 600;
+  color: #333;
+  margin: 0 0 1rem 0;
+}
+
+h3 {
+  font-size: 0.875rem;
+  font-weight: 600;
+  color: #666;
+  margin: 0 0 0.5rem 0;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+}
+
+.container {
+  max-width: 1920px;
+  margin: 0 auto;
+  display: grid;
+  grid-template-columns: minmax(500px, 600px) 1fr;
+  gap: 2rem;
+  align-items: start;
+}
+
+/* Left column container */
+.left-column {
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+}
+
+/* Right column container */
+.right-column {
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+}
+
+/* Responsive: Stack on smaller screens */
+@media (max-width: 1200px) {
+  .container {
+    grid-template-columns: 1fr;
+  }
+}
+
+.panel {
+  background: white;
+  border-radius: 8px;
+  padding: 1.5rem;
+  box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+}
+
+.config-panel {
+  border: 2px solid #e5e7eb;
+}
+
+.config-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  cursor: pointer;
+  user-select: none;
+  padding: 0.5rem 0;
+}
+
+.config-header:hover {
+  opacity: 0.7;
+}
+
+.toggle-icon {
+  font-size: 1rem;
+  color: #6b7280;
+  transition: transform 0.2s;
+}
+
+.config-content {
+  margin-top: 1rem;
+  padding-top: 1rem;
+  border-top: 1px solid #e5e7eb;
+}
+
+.robot-setup {
+  margin-bottom: 0.5rem;
+}
+
+.robot-status {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 1rem;
+  border-radius: 6px;
+  font-weight: 500;
+  gap: 1rem;
+}
+
+.robot-status.ready {
+  background: linear-gradient(135deg, #d1fae5 0%, #a7f3d0 100%);
+  color: #065f46;
+  border: 1px solid #10b981;
+}
+
+.robot-status.not-ready {
+  background: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%);
+  color: #92400e;
+  border: 1px solid #f59e0b;
+}
+
+.btn-setup {
+  background: #10b981;
+  color: white;
+  border: none;
+  padding: 0.5rem 1rem;
+  border-radius: 4px;
+  font-size: 0.875rem;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background 0.2s;
+}
+
+.btn-setup:hover:not(:disabled) {
+  background: #059669;
+}
+
+.btn-setup:disabled {
+  background: #d1d5db;
+  cursor: not-allowed;
+}
+
+.btn-zero {
+  background: #8b5cf6;
+  color: white;
+  border: none;
+  padding: 0.5rem 1rem;
+  border-radius: 4px;
+  font-size: 0.875rem;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background 0.2s;
+}
+
+.btn-zero:hover:not(:disabled) {
+  background: #7c3aed;
+}
+
+.btn-zero:disabled {
+  background: #d1d5db;
+  cursor: not-allowed;
+}
+
+.zero-position-section {
+  margin-top: 1rem;
+  padding-top: 1rem;
+  border-top: 1px solid #e5e7eb;
+}
+
+.btn-zero-large {
+  width: 100%;
+  background: #8b5cf6;
+  color: white;
+  border: none;
+  padding: 0.875rem 1.5rem;
+  border-radius: 8px;
+  font-size: 1rem;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.2s;
+  box-shadow: 0 2px 4px rgba(139, 92, 246, 0.2);
+}
+
+.btn-zero-large:hover:not(:disabled) {
+  background: #7c3aed;
+  box-shadow: 0 4px 8px rgba(139, 92, 246, 0.3);
+  transform: translateY(-1px);
+}
+
+.btn-zero-large:disabled {
+  background: #d1d5db;
+  cursor: not-allowed;
+  box-shadow: none;
+  transform: none;
+}
+
+.delete-episode-section {
+  margin-top: 1rem;
+  padding-top: 1rem;
+  border-top: 1px solid #e5e7eb;
+}
+
+.btn-delete {
+  width: 100%;
+  background: #ef4444;
+  color: white;
+  border: none;
+  padding: 0.875rem 1.5rem;
+  border-radius: 8px;
+  font-size: 1rem;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.2s;
+  box-shadow: 0 2px 4px rgba(239, 68, 68, 0.2);
+}
+
+.btn-delete:hover:not(:disabled) {
+  background: #dc2626;
+  box-shadow: 0 4px 8px rgba(239, 68, 68, 0.3);
+  transform: translateY(-1px);
+}
+
+.btn-delete:disabled {
+  background: #d1d5db;
+  cursor: not-allowed;
+  box-shadow: none;
+  transform: none;
+}
+
+.delete-info {
+  margin-top: 0.5rem;
+  font-size: 0.875rem;
+  color: #666;
+  text-align: center;
+  font-style: italic;
+}
+
+.btn-disconnect {
+  background: #ef4444;
+  color: white;
+  border: none;
+  padding: 0.5rem 1rem;
+  border-radius: 4px;
+  font-size: 0.875rem;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background 0.2s;
+}
+
+.btn-disconnect:hover {
+  background: #dc2626;
+}
+
+.btn-refresh {
+  background: #3b82f6;
+  color: white;
+  border: none;
+  padding: 0.4rem 0.8rem;
+  border-radius: 4px;
+  font-size: 0.75rem;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background 0.2s;
+}
+
+.btn-refresh:hover:not(:disabled) {
+  background: #2563eb;
+}
+
+.btn-refresh:disabled {
+  background: #d1d5db;
+  cursor: not-allowed;
+}
+
+.control-panel {
+  border: 2px solid #10b981;
+}
+
+.status-banner {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  padding: 1rem 1.5rem;
+  border-radius: 6px;
+  margin-bottom: 1.5rem;
+  font-weight: 500;
+  font-size: 0.95rem;
+}
+
+.status-banner.initializing {
+  background: linear-gradient(135deg, #dbeafe 0%, #bfdbfe 100%);
+  color: #1e40af;
+  border-left: 4px solid #3b82f6;
+}
+
+.status-banner.encoding {
+  background: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%);
+  color: #92400e;
+  border-left: 4px solid #f59e0b;
+}
+
+.status-banner.uploading {
+  background: linear-gradient(135deg, #e0e7ff 0%, #c7d2fe 100%);
+  color: #3730a3;
+  border-left: 4px solid #6366f1;
+}
+
+.status-banner.success {
+  background: linear-gradient(135deg, #d1fae5 0%, #a7f3d0 100%);
+  color: #065f46;
+  border-left: 4px solid #10b981;
+}
+
+.status-banner.warning {
+  background: linear-gradient(135deg, #fee2e2 0%, #fecaca 100%);
+  color: #991b1b;
+  border-left: 4px solid #ef4444;
+}
+
+.spinner {
+  width: 20px;
+  height: 20px;
+  border: 3px solid rgba(0, 0, 0, 0.1);
+  border-top-color: currentColor;
+  border-radius: 50%;
+  animation: spin 0.8s linear infinite;
+}
+
+@keyframes spin {
+  to { transform: rotate(360deg); }
+}
+
+.control-horizontal {
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+}
+
+.control-left {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+}
+
+.control-right {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.input-group {
+  display: flex;
+  gap: 0.5rem;
+  margin-bottom: 0;
+}
+
+input[type="text"] {
+  flex: 1;
+  padding: 0.75rem;
+  border: 1px solid #ddd;
+  border-radius: 4px;
+  font-size: 1rem;
+}
+
+input[type="text"]:disabled {
+  background: #f5f5f5;
+  cursor: not-allowed;
+}
+
+input[type="text"]:focus {
+  outline: none;
+  border-color: #10b981;
+}
+
+button {
+  padding: 0.75rem 1.5rem;
+  border: none;
+  border-radius: 4px;
+  font-size: 1rem;
+  font-weight: 500;
+  cursor: pointer;
+  transition: all 0.2s;
+}
+
+.btn-set-task {
+  background: #3b82f6;
+  color: white;
+  min-width: 120px;
+}
+
+.btn-set-task:hover:not(:disabled) {
+  background: #2563eb;
+}
+
+.btn-set-task:disabled {
+  background: #d1d5db;
+  cursor: not-allowed;
+}
+
+.btn-start {
+  background: #10b981;
+  color: white;
+}
+
+.btn-start:hover:not(:disabled) {
+  background: #059669;
+}
+
+.btn-start:disabled {
+  background: #d1d5db;
+  cursor: not-allowed;
+}
+
+.btn-stop {
+  background: #ef4444;
+  color: white;
+}
+
+.btn-stop:hover {
+  background: #dc2626;
+}
+
+.btn-reset {
+  padding: 0.5rem 1rem;
+  background: #6b7280;
+  color: white;
+  font-size: 0.875rem;
+}
+
+.btn-reset:hover {
+  background: #4b5563;
+}
+
+.status {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  padding: 1rem;
+  border-radius: 4px;
+  margin-bottom: 1rem;
+}
+
+.status.recording {
+  background: #fee2e2;
+  color: #991b1b;
+}
+
+.status.recording.recording-active {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+  background: #dc2626;
+  color: white;
+  padding: 1.5rem;
+  border: 4px solid #991b1b;
+  box-shadow: 0 4px 12px rgba(220, 38, 38, 0.4);
+  font-weight: 700;
+  font-size: 1rem;
+}
+
+.status.recording.recording-active .indicator {
+  width: 20px;
+  height: 20px;
+  background: #fef2f2;
+  animation: pulse-strong 1s ease-in-out infinite;
+}
+
+@keyframes pulse-strong {
+  0%, 100% { 
+    opacity: 1;
+    transform: scale(1);
+  }
+  50% { 
+    opacity: 0.7;
+    transform: scale(1.1);
+  }
+}
+
+.status.recording.recording-active .time-display {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  font-size: 1.5rem;
+  font-weight: 700;
+  color: white;
+}
+
+.fps-display {
+  font-size: 1rem;
+  font-weight: 500;
+  opacity: 0.95;
+}
+
+.fps-warning {
+  color: #fef2f2;
+  animation: pulse-warning 1s ease-in-out infinite;
+}
+
+@keyframes pulse-warning {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.5; }
+}
+
+.status.recording.recording-active .btn-stop {
+  align-self: stretch;
+}
+
+.ramp-up-countdown {
+  display: flex;
+  justify-content: center;
+  margin-bottom: 1rem;
+}
+
+.countdown-box {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 2rem 3rem;
+  background: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%);
+  border: 4px solid #f59e0b;
+  border-radius: 16px;
+  box-shadow: 0 6px 20px rgba(245, 158, 11, 0.4);
+  min-width: 280px;
+  animation: pulse-warm 1.5s ease-in-out infinite;
+}
+
+@keyframes pulse-warm {
+  0%, 100% {
+    box-shadow: 0 6px 20px rgba(245, 158, 11, 0.4);
+  }
+  50% {
+    box-shadow: 0 6px 25px rgba(245, 158, 11, 0.6);
+  }
+}
+
+.countdown-label {
+  font-size: 1rem;
+  color: #92400e;
+  text-transform: uppercase;
+  letter-spacing: 1.5px;
+  font-weight: 800;
+  margin-bottom: 1rem;
+  text-align: center;
+}
+
+.countdown-value {
+  font-size: 4.5rem;
+  font-weight: 900;
+  color: #d97706;
+  font-family: 'Courier New', monospace;
+  line-height: 1;
+  text-shadow: 2px 2px 6px rgba(0, 0, 0, 0.15);
+  margin-bottom: 0.5rem;
+}
+
+.countdown-subtitle {
+  font-size: 0.875rem;
+  color: #78350f;
+  font-weight: 600;
+  font-style: italic;
+  text-align: center;
+  margin-top: 0.5rem;
+}
+
+.status.idle {
+  background: #f3f4f6;
+  color: #374151;
+}
+
+.indicator {
+  width: 12px;
+  height: 12px;
+  border-radius: 50%;
+  background: #ef4444;
+  animation: pulse 1.5s ease-in-out infinite;
+}
+
+@keyframes pulse {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.5; }
+}
+
+.counter {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 0.75rem;
+  padding: 1.5rem;
+  background: linear-gradient(135deg, #f9fafb 0%, #f3f4f6 100%);
+  border-radius: 8px;
+  border: 2px solid #e5e7eb;
+  min-width: 200px;
+}
+
+.counter-label {
+  font-size: 0.75rem;
+  color: #6b7280;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+  font-weight: 600;
+}
+
+.counter-value {
+  font-size: 3rem;
+  font-weight: 700;
+  color: #10b981;
+  line-height: 1;
+}
+
+.time-display {
+  font-size: 1.5rem;
+  font-weight: 600;
+  font-family: 'Courier New', monospace;
+}
+
+.error-box {
+  padding: 1rem;
+  background: #fee2e2;
+  color: #991b1b;
+  border-radius: 4px;
+  border-left: 4px solid #ef4444;
+  font-size: 0.875rem;
+}
+
+.config-section {
+  margin-bottom: 1.5rem;
+}
+
+.config-section:last-child {
+  margin-bottom: 0;
+}
+
+.config-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+  gap: 1rem;
+}
+
+label {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  font-size: 0.875rem;
+  color: #374151;
+  font-weight: 500;
+}
+
+select {
+  padding: 0.5rem;
+  border: 1px solid #ddd;
+  border-radius: 4px;
+  font-size: 0.875rem;
+  background: white;
+}
+
+select:disabled {
+  background: #f5f5f5;
+  cursor: not-allowed;
+}
+
+/* Camera Layout */
+.camera-layout {
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+}
+
+.camera-base {
+  width: 100%;
+}
+
+.camera-wrist-container {
+  display: grid;
+  grid-template-columns: repeat(2, 1fr);
+  gap: 1.5rem;
+}
+
+.camera-wrist {
+  width: 100%;
+}
+
+.camera {
+  border: 1px solid #e5e7eb;
+  border-radius: 4px;
+  overflow: hidden;
+}
+
+.camera h3 {
+  padding: 0.75rem;
+  background: #f9fafb;
+  border-bottom: 1px solid #e5e7eb;
+  margin: 0;
+}
+
+.camera img {
+  width: 100%;
+  height: auto;
+  display: block;
+  background: #000;
+  min-height: 300px;
+  object-fit: cover;
+}
+
+.camera-placeholder {
+  text-align: center;
+  padding: 4rem 2rem;
+  background: #f9fafb;
+  border-radius: 4px;
+  border: 2px dashed #d1d5db;
+}
+
+.camera-placeholder p {
+  margin: 0.5rem 0;
+  font-size: 1rem;
+  color: #6b7280;
+}
+
+.camera-placeholder p:first-child {
+  font-size: 1.25rem;
+  font-weight: 500;
+  color: #374151;
+}
+
+.hint {
+  margin-top: 0.5rem;
+  font-size: 0.75rem;
+  color: #6b7280;
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  flex-wrap: wrap;
+}
+

examples/openarms_web_interface/App.jsx

@@ -0,0 +1,857 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+import './App.css';
+
+const API_BASE = 'http://localhost:8000/api';
+
+function App() {
+  // State
+  const [task, setTask] = useState('');
+  const [isRecording, setIsRecording] = useState(false);
+  const [isInitializing, setIsInitializing] = useState(false);
+  const [isEncoding, setIsEncoding] = useState(false);
+  const [isUploading, setIsUploading] = useState(false);
+  const [robotsReady, setRobotsReady] = useState(false);
+  const [elapsedTime, setElapsedTime] = useState(0);
+  const [currentFps, setCurrentFps] = useState(0);
+  const [loopFps, setLoopFps] = useState(0);
+  const [episodeCount, setEpisodeCount] = useState(0);
+  const [error, setError] = useState(null);
+  const [statusMessage, setStatusMessage] = useState('Ready');
+  const [uploadStatus, setUploadStatus] = useState(null);
+  const [rampUpRemaining, setRampUpRemaining] = useState(0);
+  const [movingToZero, setMovingToZero] = useState(false);
+  const [configExpanded, setConfigExpanded] = useState(false);
+  const [latestRepoId, setLatestRepoId] = useState(null);
+
+  // Configuration
+  const [config, setConfig] = useState({
+    leader_type: 'openarms',  // 'openarms' or 'openarms_mini'
+    leader_left: 'can0',
+    leader_right: 'can1',
+    follower_left: 'can2',
+    follower_right: 'can3',
+    left_wrist: '/dev/video0',
+    right_wrist: '/dev/video1',
+    base: '/dev/video4'
+  });
+
+  // Available options
+  const [availableCameras, setAvailableCameras] = useState([]);
+  const [availableUsbPorts, setAvailableUsbPorts] = useState([]);
+  const canInterfaces = ['can0', 'can1', 'can2', 'can3'];
+
+  const statusIntervalRef = useRef(null);
+  const hasInitializedRef = useRef(false);
+
+  const loadConfig = () => {
+    try {
+      const saved = localStorage.getItem('openarms_config');
+      if (saved) {
+        const loadedConfig = JSON.parse(saved);
+        setConfig(prev => ({ ...prev, ...loadedConfig }));
+      }
+    } catch (e) {
+      console.error('Load config error:', e);
+    }
+  };
+
+  const saveConfig = (newConfig) => {
+    try {
+      localStorage.setItem('openarms_config', JSON.stringify(newConfig || config));
+    } catch (e) {
+      console.error('Save config error:', e);
+    }
+  };
+
+  // Fetch status periodically
+  const fetchStatus = async () => {
+    try {
+      const response = await fetch(`${API_BASE}/status`);
+      const data = await response.json();
+
+      setIsRecording(data.is_recording);
+      setIsInitializing(data.is_initializing);
+      setIsEncoding(data.is_encoding);
+      setIsUploading(data.is_uploading);
+      setRobotsReady(data.robots_ready);
+      setElapsedTime(data.elapsed_time);
+      setCurrentFps(data.current_fps || 0);
+      setLoopFps(data.loop_fps || 0);
+      setEpisodeCount(data.episode_count);
+      setError(data.error);
+      setStatusMessage(data.status_message || 'Ready');
+      setUploadStatus(data.upload_status);
+      setRampUpRemaining(data.ramp_up_remaining || 0);
+      setMovingToZero(data.moving_to_zero || false);
+      
+      // Track the latest repo_id from the backend
+      if (data.latest_repo_id) {
+        setLatestRepoId(data.latest_repo_id);
+      }
+
+      if (data.config) {
+        // Only merge server config if we don't have a saved config (first load)
+        if (!localStorage.getItem('openarms_config')) {
+          setConfig(prev => {
+            const merged = { ...data.config, ...prev };
+            localStorage.setItem('openarms_config', JSON.stringify(merged));
+            return merged;
+          });
+        }
+      }
+    } catch (e) {
+      console.error('Failed to fetch status:', e);
+    }
+  };
+
+  const setupRobots = async () => {
+    // Show warning to verify camera positions
+    const confirmed = window.confirm(
+      '⚠️ IMPORTANT: Before connecting robots, please verify:\n\n' +
+      '📹 Check that cameras are correctly positioned:\n' +
+      '   • LEFT wrist camera is actually on the LEFT arm\n' +
+      '   • RIGHT wrist camera is actually on the RIGHT arm\n' +
+      '   • BASE camera is actually the BASE/overhead camera\n\n' +
+      'Incorrect camera positioning will result in invalid training data!\n\n' +
+      'Click OK to continue with robot setup, or Cancel to review configuration.'
+    );
+    
+    if (!confirmed) {
+      return; // User cancelled, don't proceed
+    }
+    
+    setError(null);
+    try {
+      const response = await fetch(`${API_BASE}/robots/setup`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(config)
+      });
+
+      if (!response.ok) {
+        const data = await response.json();
+        throw new Error(data.detail || 'Failed to setup robots');
+      }
+
+      await response.json();
+      saveConfig(config);
+    } catch (e) {
+      setError(`Robot setup failed: ${e.message}`);
+    }
+  };
+
+  // Disconnect robots
+  const disconnectRobots = async () => {
+    try {
+      await fetch(`${API_BASE}/robots/disconnect`, { method: 'POST' });
+      setRobotsReady(false);
+    } catch (e) {
+      console.error('Failed to disconnect robots:', e);
+    }
+  };
+
+  // Discover cameras
+  const discoverCameras = async () => {
+    try {
+      const response = await fetch(`${API_BASE}/cameras/discover`);
+      const data = await response.json();
+      const cameras = data.cameras || [];
+      setAvailableCameras(cameras);
+
+      // Get list of valid camera IDs
+      const validCameraIds = cameras.map(cam => String(cam.id));
+
+      // Auto-fix config if current values are invalid or not set
+      const updated = { ...config };
+      let changed = false;
+
+      // Auto-fix invalid camera config
+      if (!config.left_wrist || !validCameraIds.includes(config.left_wrist)) {
+        if (cameras.length >= 1) {
+          updated.left_wrist = String(cameras[0].id);
+          changed = true;
+        }
+      }
+
+      if (!config.right_wrist || !validCameraIds.includes(config.right_wrist)) {
+        if (cameras.length >= 2) {
+          updated.right_wrist = String(cameras[1].id);
+          changed = true;
+        }
+      }
+
+      if (!config.base || !validCameraIds.includes(config.base)) {
+        if (cameras.length >= 3) {
+          updated.base = String(cameras[2].id);
+          changed = true;
+        }
+      }
+
+      if (changed) {
+        setConfig(updated);
+        saveConfig(updated);
+      }
+
+      if (cameras.length === 0) {
+        setError('No cameras detected! Please connect cameras and refresh.');
+      }
+    } catch (e) {
+      console.error('Failed to discover cameras:', e);
+      setError(`Camera discovery failed: ${e.message}`);
+    }
+  };
+
+  // Discover USB ports
+  const discoverUsbPorts = async () => {
+    try {
+      const response = await fetch(`${API_BASE}/usb/discover`);
+      const data = await response.json();
+      const ports = data.ports || [];
+      setAvailableUsbPorts(ports);
+
+      // Auto-fix config if OpenArms Mini is selected and ports are invalid
+      if (config.leader_type === 'openarms_mini') {
+        const updated = { ...config };
+        let changed = false;
+
+        if (ports.length >= 1 && !ports.includes(config.leader_left)) {
+          updated.leader_left = ports[0];
+          changed = true;
+        }
+
+        if (ports.length >= 2 && !ports.includes(config.leader_right)) {
+          updated.leader_right = ports[1];
+          changed = true;
+        }
+
+        if (changed) {
+          setConfig(updated);
+          saveConfig(updated);
+        }
+      }
+
+      if (ports.length === 0) {
+        console.warn('No USB ports detected for OpenArms Mini');
+      }
+    } catch (e) {
+      console.error('Failed to discover USB ports:', e);
+    }
+  };
+
+  // Set task only (for pedal use)
+  const setTaskOnly = async () => {
+    if (!task.trim()) {
+      setError('Please enter a task description');
+      return;
+    }
+
+    setError(null);
+
+    try {
+      const response = await fetch(`${API_BASE}/recording/set-task`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ task, ...config })
+      });
+
+      if (!response.ok) {
+        const data = await response.json();
+        throw new Error(data.detail || 'Failed to set task');
+      }
+
+      const result = await response.json();
+      setStatusMessage(result.message || `Task set: ${task}`);
+      saveConfig(config);
+      
+      // Clear success message after 3 seconds
+      setTimeout(() => {
+        if (!isRecording && !isInitializing) {
+          setStatusMessage('Ready');
+        }
+      }, 3000);
+    } catch (e) {
+      setError(e.message);
+    }
+  };
+
+  // Start recording
+  const startRecording = async () => {
+    if (!task.trim()) {
+      setError('Please enter a task description');
+      return;
+    }
+
+    setError(null);
+
+    try {
+      const response = await fetch(`${API_BASE}/recording/start`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ task, ...config })
+      });
+
+      if (!response.ok) {
+        const data = await response.json();
+        throw new Error(data.detail || 'Failed to start recording');
+      }
+
+      await response.json();
+      saveConfig(config);
+    } catch (e) {
+      setError(e.message);
+    }
+  };
+
+  // Stop recording
+  const stopRecording = async () => {
+    try {
+      const response = await fetch(`${API_BASE}/recording/stop`, {
+        method: 'POST'
+      });
+
+      if (!response.ok) {
+        const data = await response.json();
+        throw new Error(data.detail || 'Failed to stop recording');
+      }
+
+      const data = await response.json();
+      setError(null);
+      // Update latest repo_id after recording
+      if (data.dataset_name) {
+        setLatestRepoId(`lerobot-data-collection/${data.dataset_name}`);
+      }
+    } catch (e) {
+      setError(e.message);
+    }
+  };
+
+  const deleteLatestEpisode = async () => {
+    if (!latestRepoId) {
+      setError('No episode to delete');
+      return;
+    }
+    
+    const confirmed = window.confirm(
+      `WARNING: This will permanently delete the repository:\n\n${latestRepoId}\n\nThis action cannot be undone. Continue?`
+    );
+    
+    if (!confirmed) {
+      return;
+    }
+    
+    try {
+      const response = await fetch(`${API_BASE}/recording/delete-latest`, { method: 'POST' });
+      
+      if (!response.ok) {
+        const data = await response.json();
+        throw new Error(data.detail || 'Failed to delete episode');
+      }
+
+      const data = await response.json();
+      setLatestRepoId(null);
+      setEpisodeCount(Math.max(0, episodeCount - 1));
+      setStatusMessage(`Deleted: ${data.deleted_repo}`);
+      
+      setTimeout(() => {
+        if (!isRecording && !isInitializing) {
+          setStatusMessage('Ready');
+        }
+      }, 3000);
+    } catch (e) {
+      setError(`Delete failed: ${e.message}`);
+    }
+  };
+
+  // Reset counter
+  const resetCounter = async () => {
+    try {
+      await fetch(`${API_BASE}/counter/reset`, { method: 'POST' });
+      setEpisodeCount(0);
+    } catch (e) {
+      console.error('Failed to reset counter:', e);
+    }
+  };
+
+  // Move robot to zero position
+  const moveToZero = async () => {
+    setError(null);
+    try {
+      const response = await fetch(`${API_BASE}/robots/move-to-zero`, { method: 'POST' });
+      if (!response.ok) {
+        const data = await response.json();
+        throw new Error(data.detail || 'Failed to move to zero position');
+      }
+      await response.json();
+    } catch (e) {
+      setError(`Move to zero failed: ${e.message}`);
+    }
+  };
+
+  // Format time as MM:SS
+  const formatTime = (seconds) => {
+    const mins = Math.floor(seconds / 60);
+    const secs = Math.floor(seconds % 60);
+    return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
+  };
+
+  // Update config and save
+  const updateConfig = (key, value) => {
+    const updated = { ...config, [key]: value };
+    setConfig(updated);
+    saveConfig(updated);
+  };
+
+  // Initialize on mount only
+  useEffect(() => {
+    // Prevent double-initialization in development
+    if (hasInitializedRef.current) {
+      return;
+    }
+    hasInitializedRef.current = true;
+
+    loadConfig();
+    discoverCameras();
+    discoverUsbPorts();
+    fetchStatus();
+    statusIntervalRef.current = setInterval(fetchStatus, 1000);
+
+    return () => {
+      if (statusIntervalRef.current) {
+        clearInterval(statusIntervalRef.current);
+      }
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []); // Run only once on mount
+
+  // Discover USB ports when leader type changes to Mini
+  useEffect(() => {
+    if (config.leader_type === 'openarms_mini') {
+      discoverUsbPorts();
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [config.leader_type]);
+
+  return (
+    <main>
+      <header>
+        <h1>OpenArms Recording</h1>
+      </header>
+
+      <div className="container">
+        {/* Left Column: Configuration and Recording Control */}
+        <div className="left-column">
+          {/* Configuration Panel */}
+          <section className="panel config-panel">
+          <div
+            className="config-header"
+            onClick={() => setConfigExpanded(!configExpanded)}
+            role="button"
+            tabIndex={0}
+            onKeyDown={(e) => e.key === 'Enter' && setConfigExpanded(!configExpanded)}
+          >
+            <h2>⚙️ Configuration</h2>
+            <span className="toggle-icon">{configExpanded ? '▼' : '▶'}</span>
+          </div>
+
+          {configExpanded && (
+            <div className="config-content">
+              {/* Robot Setup */}
+              <div className="config-section">
+                <h3>🤖 Robot Setup</h3>
+                <div className="robot-setup">
+                  {robotsReady ? (
+                    <div className="robot-status ready">
+                      <span>✅ Robots Ready - Recording will start instantly</span>
+                      <button onClick={disconnectRobots} className="btn-disconnect">
+                        Disconnect Robots
+                      </button>
+                    </div>
+                  ) : (
+                    <div className="robot-status not-ready">
+                      <span>⚠️ Robots not initialized - Recording will take ~10 seconds</span>
+                      <button
+                        onClick={setupRobots}
+                        disabled={isRecording || isInitializing}
+                        className="btn-setup"
+                      >
+                        🚀 Setup Robots
+                      </button>
+                    </div>
+                  )}
+                </div>
+              </div>
+
+              {/* Leader Type Selection */}
+              <div className="config-section">
+                <h3>🎮 Leader Type</h3>
+                <div className="config-grid">
+                  <label style={{gridColumn: '1 / -1'}}>
+                    Leader Arm Type
+                    <select
+                      value={config.leader_type}
+                      onChange={(e) => updateConfig('leader_type', e.target.value)}
+                      disabled={isRecording || robotsReady}
+                    >
+                      <option value="openarms">OpenArms (CAN Bus - Damiao Motors)</option>
+                      <option value="openarms_mini">OpenArms Mini (USB - Feetech Motors)</option>
+                    </select>
+                  </label>
+                </div>
+              </div>
+
+              {/* Leader Interfaces (CAN or USB based on type) */}
+              <div className="config-section">
+                <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '0.5rem' }}>
+                  <h3>
+                    {config.leader_type === 'openarms_mini' 
+                      ? `Leader Ports (USB/Serial) ${availableUsbPorts.length > 0 ? `(${availableUsbPorts.length} detected)` : ''}` 
+                      : 'Leader Interfaces (CAN)'}
+                  </h3>
+                  {config.leader_type === 'openarms_mini' && (
+                    <button
+                      onClick={discoverUsbPorts}
+                      className="btn-refresh"
+                      disabled={isRecording || robotsReady}
+                    >
+                      🔄 Refresh
+                    </button>
+                  )}
+                </div>
+                
+                <div className="config-grid">
+                  <label>
+                    Leader Left
+                    <select
+                      value={config.leader_left}
+                      onChange={(e) => updateConfig('leader_left', e.target.value)}
+                      disabled={isRecording || robotsReady}
+                    >
+                      {config.leader_type === 'openarms_mini' ? (
+                        availableUsbPorts.length > 0 ? (
+                          availableUsbPorts.map((port) => (
+                            <option key={port} value={port}>{port}</option>
+                          ))
+                        ) : (
+                          <option value="">No USB ports detected</option>
+                        )
+                      ) : (
+                        canInterfaces.map((iface) => (
+                          <option key={iface} value={iface}>{iface}</option>
+                        ))
+                      )}
+                    </select>
+                  </label>
+
+                  <label>
+                    Leader Right
+                    <select
+                      value={config.leader_right}
+                      onChange={(e) => updateConfig('leader_right', e.target.value)}
+                      disabled={isRecording || robotsReady}
+                    >
+                      {config.leader_type === 'openarms_mini' ? (
+                        availableUsbPorts.length > 0 ? (
+                          availableUsbPorts.map((port) => (
+                            <option key={port} value={port}>{port}</option>
+                          ))
+                        ) : (
+                          <option value="">No USB ports detected</option>
+                        )
+                      ) : (
+                        canInterfaces.map((iface) => (
+                          <option key={iface} value={iface}>{iface}</option>
+                        ))
+                      )}
+                    </select>
+                  </label>
+                </div>
+              </div>
+
+              {/* Follower CAN Interfaces */}
+              <div className="config-section">
+                <h3>Follower Interfaces (CAN)</h3>
+                
+                <div className="config-grid">
+                  <label>
+                    Follower Left
+                    <select
+                      value={config.follower_left}
+                      onChange={(e) => updateConfig('follower_left', e.target.value)}
+                      disabled={isRecording || robotsReady}
+                    >
+                      {canInterfaces.map((iface) => (
+                        <option key={iface} value={iface}>{iface}</option>
+                      ))}
+                    </select>
+                  </label>
+
+                  <label>
+                    Follower Right
+                    <select
+                      value={config.follower_right}
+                      onChange={(e) => updateConfig('follower_right', e.target.value)}
+                      disabled={isRecording || robotsReady}
+                    >
+                      {canInterfaces.map((iface) => (
+                        <option key={iface} value={iface}>{iface}</option>
+                      ))}
+                    </select>
+                  </label>
+                </div>
+              </div>
+
+              {/* Camera Configuration */}
+              <div className="config-section">
+                <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '0.5rem' }}>
+                  <h3>Cameras {availableCameras.length > 0 && `(${availableCameras.length} detected)`}</h3>
+                  <button
+                    onClick={discoverCameras}
+                    className="btn-refresh"
+                    disabled={isRecording || robotsReady}
+                  >
+                    🔄 Refresh
+                  </button>
+                </div>
+                <div className="config-grid">
+                  <label>
+                    Left Wrist
+                    <select
+                      value={config.left_wrist}
+                      onChange={(e) => updateConfig('left_wrist', e.target.value)}
+                      disabled={isRecording || robotsReady}
+                    >
+                      {availableCameras.map((cam) => (
+                        <option key={cam.id} value={String(cam.id)}>
+                          {cam.name || `Camera @ ${cam.id}`}
+                        </option>
+                      ))}
+                    </select>
+                  </label>
+
+                  <label>
+                    Right Wrist
+                    <select
+                      value={config.right_wrist}
+                      onChange={(e) => updateConfig('right_wrist', e.target.value)}
+                      disabled={isRecording || robotsReady}
+                    >
+                      {availableCameras.map((cam) => (
+                        <option key={cam.id} value={String(cam.id)}>
+                          {cam.name || `Camera @ ${cam.id}`}
+                        </option>
+                      ))}
+                    </select>
+                  </label>
+
+                  <label>
+                    Base Camera
+                    <select
+                      value={config.base}
+                      onChange={(e) => updateConfig('base', e.target.value)}
+                      disabled={isRecording || robotsReady}
+                    >
+                      {availableCameras.map((cam) => (
+                        <option key={cam.id} value={String(cam.id)}>
+                          {cam.name || `Camera @ ${cam.id}`}
+                        </option>
+                      ))}
+                    </select>
+                  </label>
+                </div>
+              </div>
+            </div>
+          )}
+        </section>
+
+        {/* Control Panel */}
+        <section className="panel control-panel">
+          <h2>🎬 Recording Control</h2>
+
+          {/* Status Banner - Always show important statuses */}
+          {isInitializing && (
+            <div className="status-banner initializing">
+              <div className="spinner"></div>
+              <span>{statusMessage}</span>
+            </div>
+          )}
+
+          {isEncoding && (
+            <div className="status-banner encoding">
+              <div className="spinner"></div>
+              <span>📹 {statusMessage}</span>
+            </div>
+          )}
+
+          {isUploading && (
+            <div className="status-banner uploading">
+              <div className="spinner"></div>
+              <span>☁️ {statusMessage}</span>
+            </div>
+          )}
+
+          {uploadStatus && !isRecording && !isEncoding && !isUploading && (
+            <div className={`status-banner ${uploadStatus.startsWith('✓') ? 'success' : 'warning'}`}>
+              <span>{uploadStatus}</span>
+            </div>
+          )}
+
+          <div className="control-horizontal">
+            {/* Task Input and Status */}
+            <div className="control-left">
+              <div className="input-group">
+                <input
+                  type="text"
+                  value={task}
+                  onChange={(e) => setTask(e.target.value)}
+                  placeholder="Task description (e.g., 'pick and place')"
+                  disabled={isRecording || isInitializing || isEncoding || isUploading}
+                  onKeyPress={(e) => {
+                    if (e.key === 'Enter' && robotsReady) {
+                      setTaskOnly();
+                    }
+                  }}
+                />
+                <button
+                  onClick={setTaskOnly}
+                  disabled={isRecording || isInitializing || isEncoding || isUploading || !robotsReady}
+                  className="btn-set-task"
+                  title={!robotsReady ? 'Please setup robots first' : 'Store task for pedal use (Enter key)'}
+                >
+                  💾 Set Task
+                </button>
+                <button
+                  onClick={startRecording}
+                  disabled={isRecording || isInitializing || isEncoding || isUploading || !robotsReady}
+                  className="btn-start"
+                  title={!robotsReady ? 'Please setup robots first' : ''}
+                >
+                  {isInitializing
+                    ? '⏳ Initializing...'
+                    : isRecording
+                    ? '⏺ Recording...'
+                    : robotsReady
+                    ? '⏺ Start Recording'
+                    : '⏺ Setup Robots First'}
+                </button>
+              </div>
+
+              {/* Ramp-up Countdown */}
+              {isRecording && rampUpRemaining > 0 && (
+                <div className="ramp-up-countdown">
+                  <div className="countdown-box">
+                    <div className="countdown-label">⚡ WARMING UP - PID RAMP-UP</div>
+                    <div className="countdown-value">{rampUpRemaining.toFixed(1)}s</div>
+                    <div className="countdown-subtitle">Recording will start automatically...</div>
+                  </div>
+                </div>
+              )}
+
+              {/* Recording Status - Only show after ramp-up */}
+              {isRecording && rampUpRemaining <= 0 && (
+                <div className="status recording recording-active">
+                  <div className="indicator"></div>
+                  <div className="time-display">
+                    <span>{formatTime(elapsedTime)}</span>
+                    <span className="fps-display">
+                      Loop: {loopFps.toFixed(1)} Hz
+                      {loopFps > 0 && loopFps < 29 && <span className="fps-warning"> ⚠️</span>}
+                    </span>
+                    <span className="fps-display">Recording: {currentFps.toFixed(1)} FPS</span>
+                  </div>
+                  <button onClick={stopRecording} className="btn-stop">
+                    ⏹ Stop
+                  </button>
+                </div>
+              )}
+            </div>
+
+            {/* Episode Counter */}
+            <div className="control-right">
+              <div className="counter">
+                <div className="counter-label">Episodes Recorded</div>
+                <div className="counter-value">{episodeCount}</div>
+                <button onClick={resetCounter} className="btn-reset">
+                  Reset
+                </button>
+              </div>
+            </div>
+          </div>
+
+          {/* Delete Latest Episode Button */}
+          {!isRecording && !isInitializing && latestRepoId && (
+            <div className="delete-episode-section">
+              <button 
+                onClick={deleteLatestEpisode}
+                className="btn-delete"
+                title="Delete the latest recorded episode from HuggingFace Hub"
+              >
+                Delete Latest Episode
+              </button>
+              <div className="delete-info">Will delete: {latestRepoId}</div>
+            </div>
+          )}
+
+          {/* Move to Zero Button */}
+          {robotsReady && !isRecording && !isInitializing && (
+            <div className="zero-position-section">
+              <button 
+                onClick={moveToZero} 
+                disabled={movingToZero}
+                className="btn-zero-large"
+                title="Move both leader and follower robots to zero position (2s)"
+              >
+                {movingToZero ? '⏳ Moving to Zero Position...' : '🎯 Move to Zero Position (Leader + Follower)'}
+              </button>
+            </div>
+          )}
+
+          {/* Error Display */}
+          {error && (
+            <div className="error-box">
+              ⚠️ {error}
+            </div>
+          )}
+        </section>
+        </div>
+
+        {/* Right Column: Camera Feeds */}
+        <div className="right-column">
+          <section className="panel cameras">
+          <h2>📹 Camera Views</h2>
+          {robotsReady || isRecording || isInitializing ? (
+            <div className="camera-layout">
+              {/* Base camera - full width */}
+              <div className="camera camera-base">
+                <h3>Base Camera</h3>
+                <img src={`${API_BASE}/camera/stream/base`} alt="Base Camera" />
+              </div>
+
+              {/* Wrist cameras - side by side */}
+              <div className="camera-wrist-container">
+                <div className="camera camera-wrist">
+                  <h3>Left Wrist</h3>
+                  <img src={`${API_BASE}/camera/stream/left_wrist`} alt="Left Wrist Camera" />
+                </div>
+
+                <div className="camera camera-wrist">
+                  <h3>Right Wrist</h3>
+                  <img src={`${API_BASE}/camera/stream/right_wrist`} alt="Right Wrist Camera" />
+                </div>
+              </div>
+            </div>
+          ) : (
+            <div className="camera-placeholder">
+              <p>📷 Camera feeds will appear when robots are set up</p>
+              <p className="hint">Click "Setup Robots" above to preview camera feeds</p>
+            </div>
+          )}
+        </section>
+        </div>
+
+      </div>
+    </main>
+  );
+}
+
+export default App;
+

examples/openarms_web_interface/README.md

@@ -0,0 +1,41 @@
+# OpenArms Web Recording Interface
+
+A web interface for recording OpenArms datasets.
+
+## Installation
+
+```bash
+cd examples/openarms_web_interface
+npm install
+```
+
+## Usage
+
+**Start everything with one command:**
+
+```bash
+./launch.sh
+```
+
+This will:
+- Start the FastAPI backend on port 8000
+- Start the React frontend on port 5173
+- Show live logs from both services
+
+Then open your browser to: **http://localhost:5173**
+
+**Stop with:** `Ctrl+C`
+
+---
+
+## Workflow
+
+1. **Configure CAN interfaces** and **camera paths** in the dropdowns
+2. Click **"Setup Robots"** to initialize (once at start)
+3. Enter a **task description**
+4. Click **"Start Recording"** to begin an episode
+5. Click **"Stop Recording"** when done
+6. Dataset is automatically encoded and uploaded to HuggingFace Hub as **private**
+7. Repeat steps 3-6 for more episodes (no need to re-setup robots!)
+
+---

examples/openarms_web_interface/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>OpenArms Recording Interface</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/main.jsx"></script>
+  </body>
+</html>

examples/openarms_web_interface/launch.sh

@@ -0,0 +1,142 @@
+#!/bin/bash
+
+# OpenArms Web Interface Launcher
+# Starts Rerun viewer, FastAPI backend, and React frontend
+
+set -e
+
+# Colors for output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+
+# Get script directory
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+cd "$SCRIPT_DIR"
+
+echo -e "${BLUE}╔════════════════════════════════════════╗${NC}"
+echo -e "${BLUE}║   OpenArms Web Recording Interface    ║${NC}"
+echo -e "${BLUE}╚════════════════════════════════════════╝${NC}"
+echo ""
+
+# Function to cleanup on exit
+cleanup() {
+    echo ""
+    echo -e "${YELLOW}Shutting down services...${NC}"
+    
+    # Kill all child processes
+    pkill -P $$ 2>/dev/null || true
+    
+    # Kill specific services by port
+    lsof -ti:8000 | xargs kill -9 2>/dev/null || true  # Backend
+    lsof -ti:5173 | xargs kill -9 2>/dev/null || true  # Frontend
+    lsof -ti:9876 | xargs kill -9 2>/dev/null || true  # Rerun (if spawned)
+    
+    echo -e "${GREEN}✓ Services stopped${NC}"
+    exit 0
+}
+
+# Register cleanup on script exit
+trap cleanup EXIT INT TERM
+
+# Check if required commands exist
+command -v rerun >/dev/null 2>&1 || { 
+    echo -e "${RED}✗ Error: 'rerun' not found. Please install: pip install rerun-sdk${NC}"
+    exit 1
+}
+
+command -v python >/dev/null 2>&1 || { 
+    echo -e "${RED}✗ Error: 'python' not found${NC}"
+    exit 1
+}
+
+command -v npm >/dev/null 2>&1 || { 
+    echo -e "${RED}✗ Error: 'npm' not found${NC}"
+    exit 1
+}
+
+# Check if node_modules exists
+if [ ! -d "node_modules" ]; then
+    echo -e "${YELLOW}⚠ node_modules not found. Running npm install...${NC}"
+    npm install
+    echo -e "${GREEN}✓ Dependencies installed${NC}"
+    echo ""
+fi
+
+echo -e "${GREEN}Starting services...${NC}"
+echo ""
+
+# 1. Start FastAPI backend (Rerun will start when recording begins)
+echo -e "${BLUE}[1/2]${NC} Starting FastAPI backend on port 8000..."
+cd "$SCRIPT_DIR"
+
+# Use Python from current environment (if lerobot env is active, it will use that)
+# Otherwise, check if we need to use conda run
+if [[ "$CONDA_DEFAULT_ENV" == "lerobot" ]]; then
+    # Already in lerobot environment
+    echo -e "${GREEN}✓ Using active lerobot environment${NC}"
+    PYTHON_CMD="python"
+elif command -v conda >/dev/null 2>&1 && conda env list | grep -q "^lerobot "; then
+    # lerobot env exists but not active - use conda run
+    echo -e "${YELLOW}Using conda run with lerobot environment...${NC}"
+    PYTHON_CMD="conda run -n lerobot --no-capture-output python"
+else
+    # Fall back to system python
+    echo -e "${YELLOW}⚠ Warning: lerobot environment not found, using system python${NC}"
+    PYTHON_CMD="python"
+fi
+
+$PYTHON_CMD web_record_server.py > /tmp/openarms_backend.log 2>&1 &
+BACKEND_PID=$!
+sleep 3
+
+if ps -p $BACKEND_PID > /dev/null; then
+    echo -e "${GREEN}✓ Backend started${NC} (PID: $BACKEND_PID)"
+    echo -e "      URL: ${BLUE}http://localhost:8000${NC}"
+else
+    echo -e "${RED}✗ Failed to start backend${NC}"
+    echo -e "${YELLOW}Check logs: tail -f /tmp/openarms_backend.log${NC}"
+    exit 1
+fi
+echo ""
+
+# 2. Start React frontend
+echo -e "${BLUE}[2/2]${NC} Starting React frontend on port 5173..."
+cd "$SCRIPT_DIR"
+npm run dev > /tmp/openarms_frontend.log 2>&1 &
+FRONTEND_PID=$!
+sleep 3
+
+if ps -p $FRONTEND_PID > /dev/null; then
+    echo -e "${GREEN}✓ Frontend started${NC} (PID: $FRONTEND_PID)"
+    echo -e "      URL: ${BLUE}http://localhost:5173${NC}"
+else
+    echo -e "${RED}✗ Failed to start frontend${NC}"
+    echo -e "${YELLOW}Check logs: tail -f /tmp/openarms_frontend.log${NC}"
+    exit 1
+fi
+echo ""
+
+# Display status
+echo -e "${GREEN}╔════════════════════════════════════════╗${NC}"
+echo -e "${GREEN}║     All services running! 🚀           ║${NC}"
+echo -e "${GREEN}╚════════════════════════════════════════╝${NC}"
+echo ""
+echo -e "🔧 ${BLUE}Backend:${NC}  http://localhost:8000"
+echo -e "🌐 ${BLUE}Frontend:${NC} http://localhost:5173"
+echo -e "📊 ${BLUE}Rerun:${NC}    Will spawn automatically when recording starts"
+echo ""
+echo -e "${YELLOW}Open your browser to:${NC} ${BLUE}http://localhost:5173${NC}"
+echo ""
+echo -e "${YELLOW}Logs:${NC}"
+echo -e "  • Backend:  tail -f /tmp/openarms_backend.log"
+echo -e "  • Frontend: tail -f /tmp/openarms_frontend.log"
+echo ""
+echo -e "${RED}Press Ctrl+C to stop all services${NC}"
+echo ""
+
+# Keep script running and wait for any service to exit
+wait
+

examples/openarms_web_interface/main.jsx

@@ -0,0 +1,7 @@
+import { createRoot } from 'react-dom/client'
+import App from './App.jsx'
+
+createRoot(document.getElementById('root')).render(
+  <App />
+)
+

examples/openarms_web_interface/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "openarms-web-interface",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "@vitejs/plugin-react": "^4.3.4",
+    "vite": "^6.0.1"
+  }
+}

examples/openarms_web_interface/vite.config.js

@@ -0,0 +1,17 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 5173,
+    strictPort: false,
+    host: true,
+    open: false
+  },
+  build: {
+    outDir: 'dist',
+    sourcemap: true
+  }
+})

loop_datasets.py

@@ -0,0 +1,10 @@
+from huggingface_hub import HfApi, list_datasets
+
+api = HfApi()
+datasets = list_datasets(author="lerobot-data-collection")
+print('"[', end="")
+i=0
+for dataset in datasets:
+    if "three-folds-dataset" in dataset.id:
+        print("'" + dataset.id + "',", end="")
+print(']"',)

scripts/find_high_mse_episodes.py

@@ -0,0 +1,278 @@
+#!/usr/bin/env python
+"""
+Script to find episodes with highest MSE between observation.state and action pairs.
+
+This script:
+1. Downloads a LeRobot dataset (if needed, skipping videos)
+2. Computes MSE between observation.state and action for each frame
+3. Aggregates MSE per episode
+4. Returns the top 1% episodes with highest total MSE
+"""
+
+import argparse
+import logging
+from pathlib import Path
+
+import numpy as np
+import torch
+from tqdm import tqdm
+
+from lerobot.datasets.lerobot_dataset import LeRobotDataset
+from lerobot.utils.constants import HF_LEROBOT_HOME
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+
+
+def compute_episode_mse(
+    dataset: LeRobotDataset,
+    state_key: str = "observation.state",
+    action_key: str = "action",
+) -> dict[int, float]:
+    """
+    Compute total MSE between state and action for each episode.
+    
+    Args:
+        dataset: LeRobotDataset to analyze
+        state_key: Key for the observation state in the dataset
+        action_key: Key for the action in the dataset
+        
+    Returns:
+        Dictionary mapping episode_index to total MSE for that episode
+    """
+    episode_mse = {}
+    
+    # Get all unique episode indices
+    hf_dataset = dataset.hf_dataset
+    
+    # Group frames by episode for efficient processing
+    logging.info("Computing MSE for each episode...")
+    
+    # Process all frames and accumulate MSE per episode
+    for idx in tqdm(range(len(hf_dataset)), desc="Processing frames"):
+        item = hf_dataset[idx]
+        
+        ep_idx = item["episode_index"]
+        if isinstance(ep_idx, torch.Tensor):
+            ep_idx = ep_idx.item()
+        
+        state = item[state_key]
+        action = item[action_key]
+        
+        if isinstance(state, torch.Tensor):
+            state = state.numpy()
+        if isinstance(action, torch.Tensor):
+            action = action.numpy()
+        
+        # Compute MSE for this frame (sum of squared differences across all dimensions)
+        mse = np.mean((state - action) ** 2)
+        
+        if ep_idx not in episode_mse:
+            episode_mse[ep_idx] = 0.0
+        episode_mse[ep_idx] += mse
+    
+    return episode_mse
+
+
+def get_top_mse_episodes(
+    episode_mse: dict[int, float],
+    top_percent: float = 1.0,
+) -> list[int]:
+    """
+    Get the top X% of episodes with highest total MSE.
+    
+    Args:
+        episode_mse: Dictionary mapping episode_index to total MSE
+        top_percent: Percentage of episodes to return (default: 1%)
+        
+    Returns:
+        List of episode indices sorted by MSE (highest first)
+    """
+    # Sort episodes by MSE in descending order
+    sorted_episodes = sorted(episode_mse.items(), key=lambda x: x[1], reverse=True)
+    
+    # Calculate number of episodes to return
+    num_episodes = len(sorted_episodes)
+    num_top = max(1, int(np.ceil(num_episodes * top_percent / 100)))
+    
+    # Extract top episode indices
+    top_episodes = [ep_idx for ep_idx, _ in sorted_episodes[:num_top]]
+    
+    return top_episodes
+
+
+def find_high_mse_episodes(
+    repo_id: str,
+    root: str | Path | None = None,
+    state_key: str = "observation.state",
+    action_key: str = "action",
+    top_percent: float = 1.0,
+    force_download: bool = False,
+) -> tuple[list[int], dict[int, float]]:
+    """
+    Find episodes with highest MSE between observation.state and action.
+    
+    Args:
+        repo_id: HuggingFace dataset repository ID
+        root: Local directory for dataset storage (default: ~/.cache/huggingface/lerobot)
+        state_key: Key for the observation state in the dataset
+        action_key: Key for the action in the dataset
+        top_percent: Percentage of episodes to return (default: 1%)
+        force_download: Force re-download of the dataset
+        
+    Returns:
+        Tuple of (list of top episode indices, dict of all episode MSEs)
+    """
+    logging.info(f"Loading dataset: {repo_id}")
+    
+    # Load the dataset (skip video download since we only need state/action data)
+    dataset = LeRobotDataset(
+        repo_id=repo_id,
+        root=root,
+        download_videos=False,
+        force_cache_sync=force_download,
+    )
+    
+    # Verify the dataset has the required features
+    if state_key not in dataset.features:
+        raise ValueError(f"Dataset does not contain '{state_key}' feature. "
+                        f"Available features: {list(dataset.features.keys())}")
+    if action_key not in dataset.features:
+        raise ValueError(f"Dataset does not contain '{action_key}' feature. "
+                        f"Available features: {list(dataset.features.keys())}")
+    
+    # Check that state and action have the same shape
+    state_shape = tuple(dataset.features[state_key]["shape"])
+    action_shape = tuple(dataset.features[action_key]["shape"])
+    if state_shape != action_shape:
+        raise ValueError(f"State shape {state_shape} does not match action shape {action_shape}")
+    
+    logging.info(f"Dataset loaded successfully:")
+    logging.info(f"  - Total episodes: {dataset.meta.total_episodes}")
+    logging.info(f"  - Total frames: {dataset.meta.total_frames}")
+    logging.info(f"  - State shape: {state_shape}")
+    logging.info(f"  - Action shape: {action_shape}")
+    logging.info(f"  - Feature names: {dataset.features[state_key].get('names', 'N/A')}")
+    
+    # Compute MSE for each episode
+    episode_mse = compute_episode_mse(dataset, state_key, action_key)
+    
+    # Get top episodes
+    top_episodes = get_top_mse_episodes(episode_mse, top_percent)
+    
+    return top_episodes, episode_mse
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Find episodes with highest MSE between observation.state and action"
+    )
+    parser.add_argument(
+        "repo_id",
+        type=str,
+        help="HuggingFace dataset repository ID (e.g., 'lerobot/aloha_sim_insertion_human')",
+    )
+    parser.add_argument(
+        "--root",
+        type=str,
+        default=None,
+        help="Local directory for dataset storage (default: ~/.cache/huggingface/lerobot)",
+    )
+    parser.add_argument(
+        "--state-key",
+        type=str,
+        default="observation.state",
+        help="Key for observation state feature (default: 'observation.state')",
+    )
+    parser.add_argument(
+        "--action-key",
+        type=str,
+        default="action",
+        help="Key for action feature (default: 'action')",
+    )
+    parser.add_argument(
+        "--top-percent",
+        type=float,
+        default=1.0,
+        help="Percentage of episodes to return (default: 1.0)",
+    )
+    parser.add_argument(
+        "--force-download",
+        action="store_true",
+        help="Force re-download of the dataset",
+    )
+    parser.add_argument(
+        "--show-all-mse",
+        action="store_true",
+        help="Show MSE values for all episodes",
+    )
+    parser.add_argument(
+        "--output",
+        type=str,
+        default=None,
+        help="Output file to save results (optional)",
+    )
+    
+    args = parser.parse_args()
+    
+    # Find high MSE episodes
+    top_episodes, all_mse = find_high_mse_episodes(
+        repo_id=args.repo_id,
+        root=args.root,
+        state_key=args.state_key,
+        action_key=args.action_key,
+        top_percent=args.top_percent,
+        force_download=args.force_download,
+    )
+    
+    # Print results
+    print("\n" + "=" * 60)
+    print(f"TOP {args.top_percent}% EPISODES WITH HIGHEST MSE")
+    print("=" * 60)
+    
+    print(f"\nTotal episodes analyzed: {len(all_mse)}")
+    print(f"Number of top episodes (top {args.top_percent}%): {len(top_episodes)}")
+    
+    print(f"\nTop {len(top_episodes)} episode(s) with highest MSE:")
+    print("-" * 40)
+    for i, ep_idx in enumerate(top_episodes, 1):
+        print(f"  {i:3d}. Episode {ep_idx:5d} - Total MSE: {all_mse[ep_idx]:.6f}")
+    
+    # Statistics
+    all_mse_values = list(all_mse.values())
+    print(f"\nMSE Statistics:")
+    print(f"  - Mean MSE: {np.mean(all_mse_values):.6f}")
+    print(f"  - Std MSE: {np.std(all_mse_values):.6f}")
+    print(f"  - Min MSE: {np.min(all_mse_values):.6f}")
+    print(f"  - Max MSE: {np.max(all_mse_values):.6f}")
+    print(f"  - Median MSE: {np.median(all_mse_values):.6f}")
+    
+    if args.show_all_mse:
+        print(f"\nAll episodes sorted by MSE (descending):")
+        print("-" * 40)
+        sorted_episodes = sorted(all_mse.items(), key=lambda x: x[1], reverse=True)
+        for ep_idx, mse in sorted_episodes:
+            print(f"  Episode {ep_idx:5d} - Total MSE: {mse:.6f}")
+    
+    # Save results if output file specified
+    if args.output:
+        output_path = Path(args.output)
+        with open(output_path, "w") as f:
+            f.write(f"# High MSE Episodes Analysis\n")
+            f.write(f"# Dataset: {args.repo_id}\n")
+            f.write(f"# State key: {args.state_key}\n")
+            f.write(f"# Action key: {args.action_key}\n")
+            f.write(f"# Top percent: {args.top_percent}%\n\n")
+            
+            f.write(f"Top {args.top_percent}% episodes:\n")
+            for ep_idx in top_episodes:
+                f.write(f"{ep_idx},{all_mse[ep_idx]:.6f}\n")
+        
+        logging.info(f"Results saved to: {output_path}")
+    
+    # Return the list for programmatic use
+    return top_episodes
+
+
+if __name__ == "__main__":
+    main()
+

src/lerobot/datasets/lerobot_dataset.py

@@ -22,11 +22,13 @@ from pathlib import Path
 
 import datasets
 import numpy as np
+import os
 import packaging.version
 import pandas as pd
 import PIL.Image
 import pyarrow as pa
 import pyarrow.parquet as pq
+from concurrent.futures import ProcessPoolExecutor
 import torch
 import torch.utils
 from huggingface_hub import HfApi, snapshot_download
@@ -1149,8 +1151,9 @@ class LeRobotDataset(torch.utils.data.Dataset):
         use_batched_encoding = self.batch_encoding_size > 1
 
         if has_video_keys and not use_batched_encoding:
-            for video_key in self.meta.video_keys:
-                ep_metadata.update(self._save_episode_video(video_key, episode_index))
+            video_paths = self._encode_multiple_temporary_episode_videos(self.meta.video_keys, episode_index)
+            for (video_key, video_path) in zip(self.meta.video_keys, video_paths):
+                ep_metadata.update(self._save_episode_video(video_key, episode_index, video_path))
 
         # `meta.save_episode` need to be executed after encoding the videos
         self.meta.save_episode(episode_index, episode_length, episode_tasks, ep_stats, ep_metadata)
@@ -1315,9 +1318,12 @@ class LeRobotDataset(torch.utils.data.Dataset):
 
         return metadata
 
-    def _save_episode_video(self, video_key: str, episode_index: int) -> dict:
+    def _save_episode_video(self, video_key: str, episode_index: int, video_path: str | Path | None = None) -> dict:
         # Encode episode frames into a temporary video
-        ep_path = self._encode_temporary_episode_video(video_key, episode_index)
+        if video_path is None:
+            ep_path = self._encode_temporary_episode_video(video_key, episode_index)
+        else:
+            ep_path = video_path
         ep_size_in_mb = get_file_size_in_mb(ep_path)
         ep_duration_in_s = get_video_duration_in_s(ep_path)
 
@@ -1441,6 +1447,22 @@ class LeRobotDataset(torch.utils.data.Dataset):
         shutil.rmtree(img_dir)
         return temp_path
 
+    def _encode_multiple_temporary_episode_videos(self, video_keys, episode_index):
+        temp_paths = []
+        img_dirs = []
+        for video_key in video_keys:
+            temp_paths.append(Path(tempfile.mkdtemp(dir=self.root)) / f"{video_key}_{episode_index:03d}.mp4")
+            img_dirs.append(self._get_image_file_dir(episode_index, video_key))
+        fps = [self.fps]*len(video_keys)
+
+        with ProcessPoolExecutor(max_workers=len(video_keys)) as executor:
+            executor.map(encode_video_frames,img_dirs,temp_paths,fps)
+
+        for img_dir in img_dirs:
+            shutil.rmtree(img_dir)
+
+        return temp_paths
+
     @classmethod
     def create(
         cls,

src/lerobot/datasets/video_utils.py

@@ -310,7 +310,7 @@ def encode_video_frames(
     crf: int | None = 30,
     fast_decode: int = 0,
     log_level: int | None = av.logging.ERROR,
-    overwrite: bool = False,
+    overwrite: bool = True,
 ) -> None:
     """More info on ffmpeg arguments tuning on `benchmark/video/README.md`"""
     # Check encoder availability
@@ -354,6 +354,9 @@ def encode_video_frames(
     if crf is not None:
         video_options["crf"] = str(crf)
 
+    #TEMPORARY FIX
+    video_options["preset"] = "12"
+
     if fast_decode:
         key = "svtav1-params" if vcodec == "libsvtav1" else "tune"
         value = f"fast-decode={fast_decode}" if vcodec == "libsvtav1" else "fastdecode"

src/lerobot/motors/damiao/damiao.py

@@ -377,7 +377,7 @@ class DamiaoMotorsBus(MotorsBusBase):
         
         try:
             while len(responses) < len(expected_recv_ids) and (time.time() - start_time) < timeout:
-                msg = self.canbus.recv(timeout=0.0001)  # 100us poll timeout
+                msg = self.canbus.recv(timeout=0.0002)  # 200us poll timeout (increased from 100us for better reliability)
                 if msg and msg.arbitration_id in expected_set:
                     responses[msg.arbitration_id] = msg
                     if len(responses) == len(expected_recv_ids):
@@ -440,6 +440,65 @@ class DamiaoMotorsBus(MotorsBusBase):
         self.canbus.send(msg)
         recv_id = self._get_motor_recv_id(motor)
         self._recv_motor_response(expected_recv_id=recv_id)
+    
+    def _mit_control_batch(
+        self,
+        commands: Dict[NameOrID, Tuple[float, float, float, float, float]],
+    ) -> None:
+        """
+        Send MIT control commands to multiple motors in batch (optimized).
+        Sends all commands first, then collects responses. Much faster than sequential.
+        
+        Args:
+            commands: Dict mapping motor name/ID to (kp, kd, position_deg, velocity_deg/s, torque)
+                     Example: {'joint_1': (10.0, 0.5, 45.0, 0.0, 0.0), ...}
+        """
+        if not commands:
+            return
+        
+        expected_recv_ids = []
+        
+        # Step 1: Send all MIT control commands (no waiting)
+        for motor, (kp, kd, position_degrees, velocity_deg_per_sec, torque) in commands.items():
+            motor_id = self._get_motor_id(motor)
+            motor_name = self._get_motor_name(motor)
+            motor_type = self._motor_types.get(motor_name, MotorType.DM4310)
+            
+            # Convert degrees to radians
+            position_rad = np.radians(position_degrees)
+            velocity_rad_per_sec = np.radians(velocity_deg_per_sec)
+            
+            # Get motor limits
+            pmax, vmax, tmax = MOTOR_LIMIT_PARAMS[motor_type]
+            
+            # Encode parameters
+            kp_uint = self._float_to_uint(kp, 0, 500, 12)
+            kd_uint = self._float_to_uint(kd, 0, 5, 12)
+            q_uint = self._float_to_uint(position_rad, -pmax, pmax, 16)
+            dq_uint = self._float_to_uint(velocity_rad_per_sec, -vmax, vmax, 12)
+            tau_uint = self._float_to_uint(torque, -tmax, tmax, 12)
+            
+            # Pack data
+            data = [0] * 8
+            data[0] = (q_uint >> 8) & 0xFF
+            data[1] = q_uint & 0xFF
+            data[2] = dq_uint >> 4
+            data[3] = ((dq_uint & 0xF) << 4) | ((kp_uint >> 8) & 0xF)
+            data[4] = kp_uint & 0xFF
+            data[5] = kd_uint >> 4
+            data[6] = ((kd_uint & 0xF) << 4) | ((tau_uint >> 8) & 0xF)
+            data[7] = tau_uint & 0xFF
+            
+            # Send command
+            msg = can.Message(arbitration_id=motor_id, data=data, is_extended_id=False)
+            self.canbus.send(msg)
+            
+            # Track expected response
+            recv_id = self._get_motor_recv_id(motor)
+            expected_recv_ids.append(recv_id)
+        
+        # Step 2: Collect all responses at once
+        self._recv_all_responses(expected_recv_ids, timeout=0.002)
 
     def _float_to_uint(self, x: float, x_min: float, x_max: float, bits: int) -> int:
         """Convert float to unsigned integer for CAN transmission."""
@@ -574,7 +633,7 @@ class DamiaoMotorsBus(MotorsBusBase):
         
         # Step 2: Collect all responses at once (batch receive)
         expected_recv_ids = [self._get_motor_recv_id(motor) for motor in motors]
-        responses = self._recv_all_responses(expected_recv_ids, timeout=0.003)  # 3ms total timeout
+        responses = self._recv_all_responses(expected_recv_ids, timeout=0.01)  # 10ms total timeout
         
         # Step 3: Parse responses
         for motor in motors:
@@ -611,6 +670,64 @@ class DamiaoMotorsBus(MotorsBusBase):
                 result[motor] = 0.0
         
         return result
+    
+    def sync_read_all_states(
+        self,
+        motors: str | list[str] | None = None,
+        *,
+        num_retry: int = 0,
+    ) -> Dict[str, Dict[str, Value]]:
+        """
+        Read ALL motor states (position, velocity, torque) from multiple motors in ONE refresh cycle.
+        This is 3x faster than calling sync_read() three times separately.
+        
+        Returns:
+            Dictionary mapping motor names to state dicts with keys: 'position', 'velocity', 'torque'
+            Example: {'joint_1': {'position': 45.2, 'velocity': 1.3, 'torque': 0.5}, ...}
+        """
+        motors = self._get_motors_list(motors)
+        result = {}
+
+        # Step 1: Send refresh commands to ALL motors first (with small delays to reduce bus congestion)
+        for motor in motors:
+            motor_id = self._get_motor_id(motor)
+            data = [motor_id & 0xFF, (motor_id >> 8) & 0xFF, CAN_CMD_REFRESH, 0, 0, 0, 0, 0]
+            msg = can.Message(arbitration_id=CAN_PARAM_ID, data=data, is_extended_id=False)
+            self.canbus.send(msg)
+            time.sleep(0.0001)  # 100us delay between commands to reduce bus congestion
+        
+        # Step 2: Collect all responses at once (batch receive)
+        expected_recv_ids = [self._get_motor_recv_id(motor) for motor in motors]
+        responses = self._recv_all_responses(expected_recv_ids, timeout=0.015)  # 15ms timeout (increased for reliability)
+        
+        # Step 3: Parse responses and extract ALL state values
+        for motor in motors:
+            try:
+                recv_id = self._get_motor_recv_id(motor)
+                msg = responses.get(recv_id)
+                
+                if msg is None:
+                    logger.warning(f"No response from motor '{motor}' (recv ID: 0x{recv_id:02X})")
+                    result[motor] = {"position": 0.0, "velocity": 0.0, "torque": 0.0}
+                    continue
+                
+                motor_type = self._motor_types.get(motor, MotorType.DM4310)
+                position_degrees, velocity_deg_per_sec, torque, t_mos, t_rotor = self._decode_motor_state(msg.data, motor_type)
+                
+                # Return all state values in one dict
+                result[motor] = {
+                    "position": position_degrees,
+                    "velocity": velocity_deg_per_sec,
+                    "torque": torque,
+                    "temp_mos": t_mos,
+                    "temp_rotor": t_rotor,
+                }
+                
+            except Exception as e:
+                logger.warning(f"Failed to read state from {motor}: {e}")
+                result[motor] = {"position": 0.0, "velocity": 0.0, "torque": 0.0}
+        
+        return result
 
     def sync_write(
         self,
@@ -658,10 +775,11 @@ class DamiaoMotorsBus(MotorsBusBase):
                 
                 msg = can.Message(arbitration_id=motor_id, data=data, is_extended_id=False)
                 self.canbus.send(msg)
+                time.sleep(0.0001)  # 100us delay between commands to reduce bus congestion
             
             # Step 2: Collect all responses at once
             expected_recv_ids = [self._get_motor_recv_id(motor) for motor in values.keys()]
-            self._recv_all_responses(expected_recv_ids, timeout=0.002)  # 2ms timeout
+            self._recv_all_responses(expected_recv_ids, timeout=0.015)  # 15ms timeout (increased for reliability)
         else:
             # Fall back to individual writes for other data types
             for motor, value in values.items():

src/lerobot/motors/damiao/seed_damiao.py

@@ -1,833 +0,0 @@
-## This is a derivative of the following software.
-## https://github.com/cmjang/DM_Control_Python/blob/main/DM_CAN.py
-
-import can
-from time import sleep, time
-import numpy as np
-from enum import IntEnum
-from struct import unpack
-from struct import pack
-
-class Motor:
-    def __init__(self, MotorType, SlaveID, MasterID):
-        """
-        define Motor object 定义电机对象
-        :param MotorType: Motor type 电机类型
-        :param SlaveID: CANID 电机ID
-        :param MasterID: MasterID 主机ID 建议不要设为0
-        """
-        self.Pd = float(0)
-        self.Vd = float(0)
-        self.goal_position = float(0)
-        self.goal_tau = float(0)
-        self.state_q = float(0)
-        self.state_dq = float(0)
-        self.state_tau = float(0)
-        self.state_tmos = int(0)
-        self.state_trotor = int(0)
-        self.SlaveID = SlaveID
-        self.MasterID = MasterID
-        self.MotorType = MotorType
-        self.isEnable = False
-        self.NowControlMode = Control_Type.MIT
-        self.temp_param_dict = {}
-
-    def recv_data(self, q: float, dq: float, tau: float, tmos: int, trotor: int):
-        self.state_q = q
-        self.state_dq = dq
-        self.state_tau = tau
-        self.state_tmos = tmos
-        self.state_trotor = trotor
-
-    def getPosition(self):
-        """
-        get the position of the motor 获取电机位置
-        :return: the position of the motor 电机位置
-        """
-        return self.state_q
-
-    def getVelocity(self):
-        """
-        get the velocity of the motor 获取电机速度
-        :return: the velocity of the motor 电机速度
-        """
-        return self.state_dq
-
-    def getTorque(self):
-        """
-        get the torque of the motor 获取电机力矩
-        :return: the torque of the motor 电机力矩
-        """
-        return self.state_tau
-
-    def getParam(self, RID):
-        """
-        get the parameter of the motor 获取电机内部的参数，需要提前读取
-        :param RID: DM_variable 电机参数
-        :return: the parameter of the motor 电机参数
-        """
-        if RID in self.temp_param_dict:
-            return self.temp_param_dict[RID]
-        else:
-            return None
-
-
-class MotorControl:
-    #send_data_frame = np.array(
-    #    [0x55, 0xAA, 0x1e, 0x03, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0, 0, 0, 0, 0x00, 0x08, 0x00,
-    #     0x00, 0, 0, 0, 0, 0, 0, 0, 0, 0x00], np.uint8)
-    #                4310           4310_48        4340           4340_48
-    Limit_Param = [[12.5, 30, 10], [12.5, 50, 10], [12.5, 8, 28], [12.5, 10, 28],
-                   # 6006           8006           8009            10010L         10010
-                   [12.5, 45, 20], [12.5, 45, 40], [12.5, 45, 54], [12.5, 25, 200], [12.5, 20, 200],
-                   # H3510            DMG62150      DMH6220
-                   [12.5 , 280 , 1],[12.5 , 45 , 10],[12.5 , 45 , 10]]
-
-    def __init__(self, channel: str, bitrate: int = 1000000):
-        """
-        define MotorControl object 定义电机控制对象
-        :param serial_device: serial object 串口对象
-        """
-        #self.serial_ = serial_device
-        self.motors_map = dict()
-        self.data_save = bytes()  # save data
-        #if self.serial_.is_open:  # open the serial port
-        #    print("Serial port is open")
-        #    serial_device.close()
-        #self.serial_.open()
-        self.canbus = can.interface.Bus(channel=channel, interface='socketcan', bitrate=bitrate)
-
-        #print("can is open")
-        
-
-    def controlMIT(self, DM_Motor, kp: float, kd: float, q: float, dq: float, tau: float):
-        """
-        MIT Control Mode Function 达妙电机MIT控制模式函数
-        :param DM_Motor: Motor object 电机对象
-        :param kp: kp
-        :param kd:  kd
-        :param q:  position  期望位置
-        :param dq:  velocity  期望速度
-        :param tau: torque  期望力矩
-        :return: None
-        """
-        if DM_Motor.SlaveID not in self.motors_map:
-            print("controlMIT ERROR : Motor ID not found")
-            return
-        kp_uint = float_to_uint(kp, 0, 500, 12)
-        kd_uint = float_to_uint(kd, 0, 5, 12)
-        MotorType = DM_Motor.MotorType
-        Q_MAX = self.Limit_Param[MotorType][0]
-        DQ_MAX = self.Limit_Param[MotorType][1]
-        TAU_MAX = self.Limit_Param[MotorType][2]
-        q_uint = float_to_uint(q, -Q_MAX, Q_MAX, 16)
-        dq_uint = float_to_uint(dq, -DQ_MAX, DQ_MAX, 12)
-        tau_uint = float_to_uint(tau, -TAU_MAX, TAU_MAX, 12)
-        data_buf = np.array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], np.uint8)
-        data_buf[0] = (q_uint >> 8) & 0xff
-        data_buf[1] = q_uint & 0xff
-        data_buf[2] = dq_uint >> 4
-        data_buf[3] = ((dq_uint & 0xf) << 4) | ((kp_uint >> 8) & 0xf)
-        data_buf[4] = kp_uint & 0xff
-        data_buf[5] = kd_uint >> 4
-        data_buf[6] = ((kd_uint & 0xf) << 4) | ((tau_uint >> 8) & 0xf)
-        data_buf[7] = tau_uint & 0xff
-        self.__send_data(DM_Motor.SlaveID, data_buf)
-        self.recv()  # receive the data from serial port
-
-    def control_delay(self, DM_Motor, kp: float, kd: float, q: float, dq: float, tau: float, delay: float):
-        """
-        MIT Control Mode Function with delay 达妙电机MIT控制模式函数带延迟
-        :param DM_Motor: Motor object 电机对象
-        :param kp: kp
-        :param kd: kd
-        :param q:  position  期望位置
-        :param dq:  velocity  期望速度
-        :param tau: torque  期望力矩
-        :param delay: delay time 延迟时间 单位秒
-        """
-        self.controlMIT(DM_Motor, kp, kd, q, dq, tau)
-        sleep(delay)
-
-    def control_Pos_Vel(self, Motor, P_desired: float, V_desired: float):
-        """
-        control the motor in position and velocity control mode 电机位置速度控制模式
-        :param Motor: Motor object 电机对象
-        :param P_desired: desired position 期望位置
-        :param V_desired: desired velocity 期望速度
-        :return: None
-        """
-        if Motor.SlaveID not in self.motors_map:
-            print("Control Pos_Vel Error : Motor ID not found")
-            return
-        motorid = 0x100 + Motor.SlaveID
-        data_buf = np.array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], np.uint8)
-        P_desired_uint8s = float_to_uint8s(P_desired)
-        V_desired_uint8s = float_to_uint8s(V_desired)
-        data_buf[0:4] = P_desired_uint8s
-        data_buf[4:8] = V_desired_uint8s
-        self.__send_data(motorid, data_buf)
-        self.recv()  # receive the data from serial port
-
-    def control_Vel(self, Motor, Vel_desired):
-        """
-        control the motor in velocity control mode 电机速度控制模式
-        :param Motor: Motor object 电机对象
-        :param Vel_desired: desired velocity 期望速度
-        """
-        if Motor.SlaveID not in self.motors_map:
-            print("control_VEL ERROR : Motor ID not found")
-            return
-        motorid = 0x200 + Motor.SlaveID
-        data_buf = np.array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], np.uint8)
-        Vel_desired_uint8s = float_to_uint8s(Vel_desired)
-        data_buf[0:4] = Vel_desired_uint8s
-        self.__send_data(motorid, data_buf)
-        self.recv()  # receive the data from serial port
-
-    def control_pos_force(self, Motor, Pos_des: float, Vel_des, i_des):
-        """
-        control the motor in EMIT control mode 电机力位混合模式
-        :param Pos_des: desired position rad  期望位置 单位为rad
-        :param Vel_des: desired velocity rad/s  期望速度 为放大100倍
-        :param i_des: desired current rang 0-10000 期望电流标幺值放大10000倍
-        电流标幺值：实际电流值除以最大电流值，最大电流见上电打印
-        """
-        if Motor.SlaveID not in self.motors_map:
-            print("control_pos_vel ERROR : Motor ID not found")
-            return
-        motorid = 0x300 + Motor.SlaveID
-        data_buf = np.array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], np.uint8)
-        Pos_desired_uint8s = float_to_uint8s(Pos_des)
-        data_buf[0:4] = Pos_desired_uint8s
-        Vel_uint = np.uint16(Vel_des)
-        ides_uint = np.uint16(i_des)
-        data_buf[4] = Vel_uint & 0xff
-        data_buf[5] = Vel_uint >> 8
-        data_buf[6] = ides_uint & 0xff
-        data_buf[7] = ides_uint >> 8
-        self.__send_data(motorid, data_buf)
-        self.recv()  # receive the data from serial port
-
-    def enable(self, Motor):
-        """
-        enable motor 使能电机
-        最好在上电后几秒后再使能电机
-        :param Motor: Motor object 电机对象
-        """
-        self.__control_cmd(Motor, np.uint8(0xFC))
-        sleep(0.1)
-        self.recv()  # receive the data from serial port
-
-    def enable_old(self, Motor ,ControlMode):
-        """
-        enable motor old firmware 使能电机旧版本固件，这个是为了旧版本电机固件的兼容性
-        可恶的旧版本固件使能需要加上偏移量
-        最好在上电后几秒后再使能电机
-        :param Motor: Motor object 电机对象
-        """
-        data_buf = np.array([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc], np.uint8)
-        enable_id = ((int(ControlMode)-1) << 2) + Motor.SlaveID
-        self.__send_data(enable_id, data_buf)
-        sleep(0.1)
-        self.recv()  # receive the data from serial port
-
-    def disable(self, Motor):
-        """
-        disable motor 失能电机
-        :param Motor: Motor object 电机对象
-        """
-        self.__control_cmd(Motor, np.uint8(0xFD))
-        sleep(0.1)
-        self.recv()  # receive the data from serial port
-
-    def set_zero_position(self, Motor):
-        """
-        set the zero position of the motor 设置电机0位
-        :param Motor: Motor object 电机对象
-        """
-        self.__control_cmd(Motor, np.uint8(0xFE))
-        sleep(0.1)
-        self.recv()  # receive the data from serial port
-
-    def recv(self):
-        # 把上次没有解析完的剩下的也放进来
-        # data_recv = b''.join([self.data_save, self.serial_.read_all()])
-        #data_recv = b''.join([self.data_save, self.canbus.recv()])
-
-
-        # packets = self.__extract_packets(data_recv)
-        # for packet in packets:
-        #     data = packet[7:15]
-        #     CANID = (packet[6] << 24) | (packet[5] << 16) | (packet[4] << 8) | packet[3]
-        #     CMD = packet[1]
-        #     self.__process_packet(data, CANID, CMD)
-        
-        data_recv = self.canbus.recv(0.1)
-
-        if data_recv is not None:
-            # data = data_recv.data
-            # err = data[0] >> 12
-            # id = data[0] & 0x7f
-            # pos = (data[1] << 8) + data[2]
-            # vel = (data[3] << 4) + (data[4] >> 4)
-            # tau = ((data[4] & 0x0f) << 8) + data[5]
-            # t_mos = data[6]
-            # t_rotor = data[7]
-            # print(hex(id), err, id, pos, vel, tau, goal_tau, t_mos, t_rotor)
-            # CANID = data_recv.arbitration_id
-            CANID = data_recv.data[0]
-            # CMD = data_recv.data[3]
-            CMD = 0x11                  # 飯田：修正の必要あり
-            self.__process_packet(data_recv.data, CANID, CMD)
-
-            # 飯田：Debug print
-            # print(hex(CANID),hex(CMD))
-            # print(hex(data_recv.data[0]),hex(data_recv.data[1]),hex(data_recv.data[2]),hex(data_recv.data[3]),hex(data_recv.data[4]),hex(data_recv.data[5]),hex(data_recv.data[6]),hex(data_recv.data[7]))
-            #return data
-
-    def recv_set_param_data(self):
-        #data_recv = self.serial_.read_all()
-
-        # packets = self.__extract_packets(data_recv)
-        # for packet in packets:
-        #     data = packet[7:15]
-        #     CANID = (packet[6] << 24) | (packet[5] << 16) | (packet[4] << 8) | packet[3]
-        #     CMD = packet[1]
-        #     self.__process_set_param_packet(data, CANID, CMD)
-        
-        data_recv = self.canbus.recv(0.1)
-
-
-        if data_recv is not None:
-            data = data_recv.data
-            CANID = data_recv.arbitration_id
-            # CANID = data_recv.data[0]
-            # CMD = data_recv.data[3]  
-            CMD = 0x11                  # 飯田：修正の必要あり
-            self.__process_packet(data, CANID, CMD)
-
-
-            # 飯田：Debug print
-            print(hex(CANID),hex(CMD))
-            print(hex(data_recv.data[0]),hex(data_recv.data[1]),hex(data_recv.data[2]),hex(data_recv.data[3]),hex(data_recv.data[4]),hex(data_recv.data[5]),hex(data_recv.data[6]),hex(data_recv.data[7]))
-
-    def __process_packet(self, data, CANID, CMD):
-        if CMD == 0x11:
-            if CANID != 0x00:
-                if CANID in self.motors_map:
-                    q_uint = np.uint16((np.uint16(data[1]) << 8) | data[2])
-                    dq_uint = np.uint16((np.uint16(data[3]) << 4) | (data[4] >> 4))
-                    tau_uint = np.uint16(((data[4] & 0xf) << 8) | data[5])
-                    t_mos = data[6]
-                    t_rotor = data[7]
-                    MotorType_recv = self.motors_map[CANID].MotorType
-                    Q_MAX = self.Limit_Param[MotorType_recv][0]
-                    DQ_MAX = self.Limit_Param[MotorType_recv][1]
-                    TAU_MAX = self.Limit_Param[MotorType_recv][2]
-                    recv_q = uint_to_float(q_uint, -Q_MAX, Q_MAX, 16)
-                    recv_dq = uint_to_float(dq_uint, -DQ_MAX, DQ_MAX, 12)
-                    recv_tau = uint_to_float(tau_uint, -TAU_MAX, TAU_MAX, 12)
-                    self.motors_map[CANID].recv_data(recv_q, recv_dq, recv_tau, t_mos, t_rotor)
-            else:
-                MasterID=data[0] & 0x0f
-                if MasterID in self.motors_map:
-                    q_uint = np.uint16((np.uint16(data[1]) << 8) | data[2])
-                    dq_uint = np.uint16((np.uint16(data[3]) << 4) | (data[4] >> 4))
-                    tau_uint = np.uint16(((data[4] & 0xf) << 8) | data[5])
-                    t_mos = data[6]
-                    t_rotor = data[7]
-                    MotorType_recv = self.motors_map[MasterID].MotorType
-                    Q_MAX = self.Limit_Param[MotorType_recv][0]
-                    DQ_MAX = self.Limit_Param[MotorType_recv][1]
-                    TAU_MAX = self.Limit_Param[MotorType_recv][2]
-                    recv_q = uint_to_float(q_uint, -Q_MAX, Q_MAX, 16)
-                    recv_dq = uint_to_float(dq_uint, -DQ_MAX, DQ_MAX, 12)
-                    recv_tau = uint_to_float(tau_uint, -TAU_MAX, TAU_MAX, 12)
-                    self.motors_map[MasterID].recv_data(recv_q, recv_dq, recv_tau, t_mos, t_rotor)
-
-
-    def __process_set_param_packet(self, data, CANID, CMD):
-        if CMD == 0x11 and (data[2] == 0x33 or data[2] == 0x55):
-            masterid=CANID
-            slaveId = ((data[1] << 8) | data[0])
-            if CANID==0x00:  #防止有人把MasterID设为0稳一手
-                masterid=slaveId
-
-            if masterid not in self.motors_map:
-                if slaveId not in self.motors_map:
-                    return
-                else:
-                    masterid=slaveId
-
-            RID = data[3]
-            # 读取参数得到的数据
-            if is_in_ranges(RID):
-                #uint32类型
-                num = uint8s_to_uint32(data[4], data[5], data[6], data[7])
-                self.motors_map[masterid].temp_param_dict[RID] = num
-
-            else:
-                #float类型
-                num = uint8s_to_float(data[4], data[5], data[6], data[7])
-                self.motors_map[masterid].temp_param_dict[RID] = num
-
-
-    def addMotor(self, Motor):
-        """
-        add motor to the motor control object 添加电机到电机控制对象
-        :param Motor: Motor object 电机对象
-        """
-        self.motors_map[Motor.SlaveID] = Motor
-        if Motor.MasterID != 0:
-            self.motors_map[Motor.MasterID] = Motor
-        return True
-
-    def __control_cmd(self, Motor, cmd: np.uint8):     # 飯田：コマンドは通ります
-        data_buf = np.array([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, cmd], np.uint8)
-        self.__send_data(Motor.SlaveID, data_buf)
-
-    def __send_data(self, motor_id, data):
-        """
-        send data to the motor 发送数据到电机
-        :param motor_id:
-        :param data:
-        :return:
-        """
-        #self.send_data_frame[13] = motor_id & 0xff
-        #self.send_data_frame[14] = (motor_id >> 8)& 0xff  #id high 8 bits
-        #self.send_data_frame[21:29] = data
-        #self.serial_.write(bytes(self.send_data_frame.T))
-
-        msg =can.Message(is_extended_id=False,arbitration_id=motor_id,data=data,is_remote_frame = False)
-        self.canbus.send(msg)
-
-    def __read_RID_param(self, Motor, RID):             # 飯田：修正の必要あり?
-        can_id_l = Motor.SlaveID & 0xff #id low 8 bits
-        can_id_h = (Motor.SlaveID >> 8)& 0xff  #id high 8 bits
-        data_buf = np.array([np.uint8(can_id_l), np.uint8(can_id_h), 0x33, np.uint8(RID), 0x00, 0x00, 0x00, 0x00], np.uint8)
-        self.__send_data(0x7FF, data_buf)
-        
-
-
-    def __write_motor_param(self, Motor, RID, data):             # 飯田：修正の必要あり?
-        can_id_l = Motor.SlaveID & 0xff #id low 8 bits
-        can_id_h = (Motor.SlaveID >> 8)& 0xff  #id high 8 bits
-        data_buf = np.array([np.uint8(can_id_l), np.uint8(can_id_h), 0x55, np.uint8(RID), 0x00, 0x00, 0x00, 0x00], np.uint8)
-        if not is_in_ranges(RID):
-            # data is float
-            data_buf[4:8] = float_to_uint8s(data)
-        else:
-            # data is int
-            data_buf[4:8] = data_to_uint8s(int(data))
-        self.__send_data(0x7FF, data_buf)
-
-    def switchControlMode(self, Motor, ControlMode):
-        """
-        switch the control mode of the motor 切换电机控制模式
-        :param Motor: Motor object 电机对象
-        :param ControlMode: Control_Type 电机控制模式 example:MIT:Control_Type.MIT MIT模式
-        """
-        max_retries = 20
-        retry_interval = 0.1  #retry times
-        RID = 10
-        self.__write_motor_param(Motor, RID, np.uint8(ControlMode))
-        for _ in range(max_retries):
-            sleep(retry_interval)
-            self.recv_set_param_data()
-            if Motor.SlaveID in self.motors_map:
-                if RID in self.motors_map[Motor.SlaveID].temp_param_dict:
-                    if abs(self.motors_map[Motor.SlaveID].temp_param_dict[RID] - ControlMode) < 0.1:
-                        return True
-                    else:
-                        return False
-        return False
-
-    def save_motor_param(self, Motor):
-        """
-        save the all parameter  to flash 保存所有电机参数
-        :param Motor: Motor object 电机对象
-        :return:
-        """
-        can_id_l = Motor.SlaveID & 0xff #id low 8 bits
-        can_id_h = (Motor.SlaveID >> 8)& 0xff  #id high 8 bits
-        data_buf = np.array([np.uint8(can_id_l), np.uint8(can_id_h), 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00], np.uint8)
-        self.disable(Motor)  # before save disable the motor
-        self.__send_data(0x7FF, data_buf)
-        sleep(0.001)
-
-    def change_limit_param(self, Motor_Type, PMAX, VMAX, TMAX):
-        """
-        change the PMAX VMAX TMAX of the motor 改变电机的PMAX VMAX TMAX
-        :param Motor_Type:
-        :param PMAX: 电机的PMAX
-        :param VMAX: 电机的VMAX
-        :param TMAX: 电机的TMAX
-        :return:
-        """
-        self.Limit_Param[Motor_Type][0] = PMAX
-        self.Limit_Param[Motor_Type][1] = VMAX
-        self.Limit_Param[Motor_Type][2] = TMAX
-
-    def refresh_motor_status(self,Motor):
-        """
-        get the motor status 获得电机状态
-        """
-        can_id_l = Motor.SlaveID & 0xff #id low 8 bits
-        can_id_h = (Motor.SlaveID >> 8) & 0xff  #id high 8 bits
-        data_buf = np.array([np.uint8(can_id_l), np.uint8(can_id_h), 0xCC, 0x00, 0x00, 0x00, 0x00, 0x00], np.uint8)
-        self.__send_data(0x7FF, data_buf)
-        self.recv()  # receive the data from serial port
-
-    def change_motor_param(self, Motor, RID, data):
-        """
-        change the RID of the motor 改变电机的参数
-        :param Motor: Motor object 电机对象
-        :param RID: DM_variable 电机参数
-        :param data: 电机参数的值
-        :return: True or False ,True means success, False means fail
-        """
-        max_retries = 20
-        retry_interval = 0.05  #retry times
-
-        self.__write_motor_param(Motor, RID, data)
-        for _ in range(max_retries):
-            self.recv_set_param_data()
-            if Motor.SlaveID in self.motors_map and RID in self.motors_map[Motor.SlaveID].temp_param_dict:
-                if abs(self.motors_map[Motor.SlaveID].temp_param_dict[RID] - data) < 0.1:
-                    return True
-                else:
-                    return False
-            sleep(retry_interval)
-        return False
-
-    def read_motor_param(self, Motor, RID):
-        """
-        read only the RID of the motor 读取电机的内部信息例如 版本号等
-        :param Motor: Motor object 电机对象
-        :param RID: DM_variable 电机参数
-        :return: 电机参数的值
-        """
-        max_retries = 5
-        retry_interval = 0.05  #retry times
-        self.__read_RID_param(Motor, RID)
-        for _ in range(max_retries):
-            sleep(retry_interval)
-            self.recv_set_param_data()
-            if Motor.SlaveID in self.motors_map:
-                if RID in self.motors_map[Motor.SlaveID].temp_param_dict:
-                    return self.motors_map[Motor.SlaveID].temp_param_dict[RID]
-        return None
-
-    # -------------------------------------------------
-    # Extract packets from the serial data
-    def __extract_packets(self, data):          
-        frames = []
-        header = 0xAA
-        tail = 0x55
-        frame_length = 16
-        i = 0
-        remainder_pos = 0
-
-        while i <= len(data) - frame_length:
-            if data[i] == header and data[i + frame_length - 1] == tail:
-                frame = data[i:i + frame_length]
-                frames.append(frame)
-                i += frame_length
-                remainder_pos = i
-            else:
-                i += 1
-        self.data_save = data[remainder_pos:]
-        return frames
-
-
-def LIMIT_MIN_MAX(x, min, max):
-    if x <= min:
-        x = min
-    elif x > max:
-        x = max
-
-
-def float_to_uint(x: float, x_min: float, x_max: float, bits):
-    LIMIT_MIN_MAX(x, x_min, x_max)
-    span = x_max - x_min
-    data_norm = (x - x_min) / span
-    return np.uint16(data_norm * ((1 << bits) - 1))
-
-
-def uint_to_float(x: np.uint16, min: float, max: float, bits):
-    span = max - min
-    data_norm = float(x) / ((1 << bits) - 1)
-    temp = data_norm * span + min
-    return np.float32(temp)
-
-
-def float_to_uint8s(value):
-    # Pack the float into 4 bytes
-    packed = pack('f', value)
-    # Unpack the bytes into four uint8 values
-    return unpack('4B', packed)
-
-
-def data_to_uint8s(value):
-    # Check if the value is within the range of uint32
-    if isinstance(value, int) and (0 <= value <= 0xFFFFFFFF):
-        # Pack the uint32 into 4 bytes
-        packed = pack('I', value)
-    else:
-        raise ValueError("Value must be an integer within the range of uint32")
-
-    # Unpack the bytes into four uint8 values
-    return unpack('4B', packed)
-
-
-def is_in_ranges(number):
-    """
-    check if the number is in the range of uint32
-    :param number:
-    :return:
-    """
-    if (7 <= number <= 10) or (13 <= number <= 16) or (35 <= number <= 36):
-        return True
-    return False
-
-
-def uint8s_to_uint32(byte1, byte2, byte3, byte4):
-    # Pack the four uint8 values into a single uint32 value in little-endian order
-    packed = pack('<4B', byte1, byte2, byte3, byte4)
-    # Unpack the packed bytes into a uint32 value
-    return unpack('<I', packed)[0]
-
-
-def uint8s_to_float(byte1, byte2, byte3, byte4):
-    # Pack the four uint8 values into a single float value in little-endian order
-    packed = pack('<4B', byte1, byte2, byte3, byte4)
-    # Unpack the packed bytes into a float value
-    return unpack('<f', packed)[0]
-
-
-def print_hex(data):
-    hex_values = [f'{byte:02X}' for byte in data]
-    print(' '.join(hex_values))
-
-
-def get_enum_by_index(index, enum_class):
-    try:
-        return enum_class(index)
-    except ValueError:
-        return None
-
-
-class DM_Motor_Type(IntEnum):
-    DM4310 = 0
-    DM4310_48V = 1
-    DM4340 = 2
-    DM4340_48V = 3
-    DM6006 = 4
-    DM8006 = 5
-    DM8009 = 6
-    DM10010L = 7
-    DM10010 = 8
-    DMH3510 = 9
-    DMH6215 = 10
-    DMG6220 = 11
-
-
-class DM_variable(IntEnum):
-    UV_Value = 0
-    KT_Value = 1
-    OT_Value = 2
-    OC_Value = 3
-    ACC = 4
-    DEC = 5
-    MAX_SPD = 6
-    MST_ID = 7
-    ESC_ID = 8
-    TIMEOUT = 9
-    CTRL_MODE = 10
-    Damp = 11
-    Inertia = 12
-    hw_ver = 13
-    sw_ver = 14
-    SN = 15
-    NPP = 16
-    Rs = 17
-    LS = 18
-    Flux = 19
-    Gr = 20
-    PMAX = 21
-    VMAX = 22
-    TMAX = 23
-    I_BW = 24
-    KP_ASR = 25
-    KI_ASR = 26
-    KP_APR = 27
-    KI_APR = 28
-    OV_Value = 29
-    GREF = 30
-    Deta = 31
-    V_BW = 32
-    IQ_c1 = 33
-    VL_c1 = 34
-    can_br = 35
-    sub_ver = 36
-    u_off = 50
-    v_off = 51
-    k1 = 52
-    k2 = 53
-    m_off = 54
-    dir = 55
-    p_m = 80
-    xout = 81
-
-
-class Control_Type(IntEnum):
-    MIT = 1
-    POS_VEL = 2
-    VEL = 3
-    Torque_Pos = 4
-
-class DamiaoPort:
-    def __init__(self, device, types, can_ids, master_ids, motor_with_torque, control_mode=Control_Type.MIT):
-        self.device = device
-        self.types = types
-        self.can_ids = can_ids
-        self.master_ids = master_ids
-        self.control = MotorControl(self.device, bitrate=4000000)
-        self.motors = [Motor(type, can_id, master_id) for type, can_id, master_id in zip(types, can_ids, master_ids)]
-        self.stat_data = []
-        self.stat_time = []
-        for motor in self.motors:
-            self.control.addMotor(motor)
-            self.control.enable(motor)
-
-    def get_present_status(self):
-        self.stat_time.append(time())
-        stat = [[
-            motor.goal_position,
-            motor.goal_tau,
-            motor.getPosition(),
-            motor.getVelocity(),
-            motor.getTorque(),
-            motor.state_tmos,
-            motor.state_trotor,
-        ] for motor in self.motors]
-        self.stat_data.append(stat)
-
-        return stat
-
-    def save_status(self, filename):
-        np.savez(filename, np.array(self.stat_time), np.array(self.stat_data))
-
-    def disable(self):
-        for motor in self.motors:
-            self.control.disable(motor)
-
-    def shutdown(self):
-        for motor in self.motors:
-            self.control.controlMIT(motor, 0, 0, 0, 0, 0)
-        self.control.canbus.shutdown()
-
-    def set_zero_position(self):
-        for motor in self.motors:
-            self.control.disable(motor)
-        sleep(1)
-        for motor in self.motors:
-            self.control.set_zero_position(motor)
-        sleep(1)
-        for motor in self.motors:
-            self.control.enable(motor)
-        return 0
-
-    async def move_towards(self, goal_positions, kps, kds):
-        for motor, goal_position, kp, kd in zip(self.motors, goal_positions, kps, kds):
-            delta = goal_position - motor.getPosition()
-            v = motor.getVelocity()
-            tau = kp * delta - kd * v
-            motor.goal_position = goal_position
-            motor.goal_tau = tau
-            self.control.controlMIT(motor, 0, 0, 0, 0, tau)
-            await asyncio.sleep(0.00003)
-
-    def move_regressor_sync(self, regs, search_range, search_step, goal_positions, kps, kds):
-        TORQUE_SCALER=30
-        if len(self.stat_data) == 0:
-            return self.move_towards_sync(goal_positions, kps, kds)
-        for motor, reg, goal_position, kp, kd, stat in zip(
-                self.motors, regs, goal_positions, kps, kds, self.stat_data[-1]):
-            pos = motor.getPosition()
-            vel = motor.getVelocity()
-            delta = goal_position - pos
-            goal_tau = kp * delta - kd * vel
-            _goal_pos, _goal_tau, _pos, _vel, _tau = stat
-            x = np.array([[_pos, _vel, _tau, _goal_pos, _goal_tau],
-                          [pos, vel, motor.getTorque(), goal_position, goal_tau]])
-            x /= np.array([[np.pi, 10, TORQUE_SCALER, np.pi, TORQUE_SCALER]])
-            xs = []
-            for tau in np.linspace(goal_tau/TORQUE_SCALER - search_range,
-                                   goal_tau/TORQUE_SCALER + search_range,
-                                   num=search_step):
-                x_ = x.copy()
-                x_[0,4] = tau
-                xs.append(x_.flatten())
-            h = reg.predict(xs)
-            diff = h - goal_position
-            tau = TORQUE_SCALER * xs[np.argmin(diff ** 2)][4]
-            goal_tau = tau
-            motor.goal_position = goal_position
-            motor.goal_tau = goal_tau
-            self.control.controlMIT(motor, 0, 0, 0, 0, goal_tau)
-            sleep(0.00003)
-
-    def move_towards_sync(self, goal_positions, kps, kds):
-        for motor, goal_position, kp, kd in zip(self.motors, goal_positions, kps, kds):
-            delta = goal_position - motor.getPosition()
-            v = motor.getVelocity()
-            tau = kp * delta - kd * v
-            motor.goal_position = goal_position
-            motor.goal_tau = tau
-            self.control.controlMIT(motor, 0, 0, 0, 0, tau)
-            # sleep(0.00003)
-
-    def set_goal_torque_sync(self, goal_taus):
-        for motor, goal_tau in zip(self.motors, goal_taus):
-            motor.goal_position = 0
-            motor.goal_tau = goal_tau
-            self.control.controlMIT(motor, 0, 0, 0, 0, motor.goal_tau)
-            sleep(0.00003)
-
-    def move_torque_sync(self, taus):
-        for motor,tau in zip(self.motors, taus):
-            motor.goal_position = 0
-            motor.goal_tau = tau
-            self.control.controlMIT(motor, 0, 0, 0, 0, motor.goal_tau)
-            sleep(0.00003)
-
-    def keep_torque_sync(self):
-        for motor in self.motors:
-            self.control.controlMIT(motor, 0, 0, 0, 0, motor.goal_tau)
-            sleep(0.00003)
-
-    async def set_goal_positions(self, goal_positions, kps):
-        for motor, goal_position, kp in zip(self.motors, goal_positions, kps):
-            motor.goal_position = goal_position
-            motor.goal_tau = 0
-            self.control.controlMIT(motor, kp, 1.2, goal_position, 0, 0)
-            await asyncio.sleep(0.00003)
-
-    def set_goal_positions_sync(self, goal_positions, kps, kds):
-        for motor, goal_position, kp, kd in zip(self.motors, goal_positions, kps, kds):
-            motor.goal_position = goal_position
-            motor.goal_tau = 0
-            self.control.controlMIT(motor, kp, kd, goal_position, 0, 0)
-            sleep(0.00003)
-
-    def set_goal_posvel(self, goal_positions):
-        for motor, goal_position in zip(self.motors, goal_positions):
-            motor.goal_position = goal_position
-            motor.goal_tau = 0
-            self.control.control_pos_force(motor, goal_position, 1, 1)
-
-    def controlMIT(self, motor, kp, kd, q, dq, tau):
-        self.control.controlMIT(self.motors[motor], kp, kd, q, dq, tau)
-

src/lerobot/motors/feetech/feetech.py

@@ -165,7 +165,7 @@ class FeetechMotorsBus(SerialMotorsBus):
 
     def _handshake(self) -> None:
         self._assert_motors_exist()
-        self._assert_same_firmware()
+        #self._assert_same_firmware()
 
     def _find_single_motor(self, motor: str, initial_baudrate: int | None = None) -> tuple[int, int]:
         if self.protocol_version == 0:

src/lerobot/robots/openarms/config_openarms_follower.py

@@ -72,11 +72,47 @@ class OpenArmsFollowerConfig(RobotConfig):
         "gripper": (0x08, 0x18, "dm4310"),   # J8 - Gripper (DM4310)
     })
     
-    # MIT control parameters for position control (per motor)
-    # Values: [joint_1, joint_2, joint_3, joint_4, joint_5, joint_6, joint_7, gripper]
-    position_kp: list[float] = field(default_factory=lambda: [240.0, 240.0, 240.0, 240.0, 24.0, 31.0, 25.0, 16.0])
+    # MIT control parameters for position control (used in send_action)
+    # List of 8 values: [joint_1, joint_2, joint_3, joint_4, joint_5, joint_6, joint_7, gripper]
+    position_kp: list[float] = field(default_factory=lambda: [240.0, 240.0, 240.0, 240.0, 24.0, 31.0, 25.0, 25.0])
     position_kd: list[float] = field(default_factory=lambda: [3.0, 3.0, 3.0, 3.0, 0.2, 0.2, 0.2, 0.2])
     
+    # Damping gains for stability when applying torque compensation (gravity/friction)
+    # Used when kp=0 and only torque is applied
+    damping_kd: list[float] = field(default_factory=lambda: [0.5, 0.5, 0.5, 0.5, 0.1, 0.1, 0.1, 0.1])
+    
+    # Friction model parameters: τ_fric(ω) = Fo + Fv·ω + Fc·tanh(k·ω)
+    # From OpenArms config/follower.yaml
+    friction_fc: list[float] = field(default_factory=lambda: [0.306, 0.306, 0.40, 0.166, 0.050, 0.093, 0.172, 0.0512])  # Coulomb friction [Nm]
+    friction_k: list[float] = field(default_factory=lambda: [28.417, 28.417, 29.065, 130.038, 151.771, 242.287, 7.888, 4.000])  # tanh steepness
+    friction_fv: list[float] = field(default_factory=lambda: [0.063, 0.0630, 0.604, 0.813, 0.029, 0.072, 0.084, 0.084])  # Viscous friction [Nm·s/rad]
+    friction_fo: list[float] = field(default_factory=lambda: [0.088, 0.088, 0.008, -0.058, 0.005, 0.009, -0.059, -0.050])  # Offset torque [Nm]
+    
     # Calibration parameters
     calibration_mode: str = "manual"  # "manual" or "auto"
     zero_position_on_connect: bool = False  # Set zero position on connect
+    
+    # Joint limits for position clipping (degrees)
+    # Format: [min, max] for each joint
+    # These limits clip commands in send_action to prevent mechanical damage
+    joint_limits_right: Dict[str, tuple[float, float]] = field(default_factory=lambda: {
+        "joint_1": (-75.0, 75.0),
+        "joint_2": (-9.0, 90.0),
+        "joint_3": (-85.0, 85.0),
+        "joint_4": (0.0, 135.0),
+        "joint_5": (-85.0, 85.0),
+        "joint_6": (-40.0, 40.0),
+        "joint_7": (-80.0, 80.0),
+        "gripper": (-65.0, 0.0),
+    })
+    
+    joint_limits_left: Dict[str, tuple[float, float]] = field(default_factory=lambda: {
+        "joint_1": (-75.0, 75.0),
+        "joint_2": (-90.0, 9.0),
+        "joint_3": (-85.0, 85.0),
+        "joint_4": (0.0, 135.0),
+        "joint_5": (-85.0, 85.0),
+        "joint_6": (-40.0, 40.0),
+        "joint_7": (-80.0, 80.0),
+        "gripper": (-65.0, 0.0),
+    })

src/lerobot/robots/openarms/openarms_follower.py

@@ -17,7 +17,7 @@
 import logging
 import time
 from functools import cached_property
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
 import numpy as np
 import pinocchio as pin
@@ -90,14 +90,25 @@ class OpenArmsFollower(Robot):
         
         # Initialize cameras
         self.cameras = make_cameras_from_configs(config.cameras)
+        # Cache for last valid camera frames (to avoid blocking on slow USB reads)
+        self.camera_frame_cache = {key: None for key in self.cameras.keys()}
         
         # Initialize Pinocchio robot model for dynamics (optional)
         self.pin_robot = None
         try:
-            # Try to load URDF if available
-            # TODO: Add OpenArms URDF file to repository
-            self.pin_robot = pin.RobotWrapper.BuildFromURDF("urdf/openarms.urdf", "urdf")
-            logger.info("Loaded OpenArms URDF for dynamics computation")
+            # Load URDF - try external path first (with meshes), then repository
+            import os
+            from os.path import expanduser, dirname
+            
+            # Try external URDF with meshes first
+            external_urdf_path = expanduser("~/Documents/openarm_description/openarm_bimanual_pybullet.urdf")
+            if os.path.exists(external_urdf_path):
+                urdf_path = external_urdf_path
+                urdf_dir = dirname(urdf_path)
+            
+                self.pin_robot = pin.RobotWrapper.BuildFromURDF(urdf_path, urdf_dir)
+                self.pin_robot.data = self.pin_robot.model.createData()
+                logger.info(f"Loaded OpenArms URDF for dynamics computation from {urdf_path}")
         except Exception as e:
             logger.warning(f"Could not load URDF for dynamics: {e}. Gravity compensation will not be available.")
 
@@ -105,16 +116,12 @@ class OpenArmsFollower(Robot):
     def _motors_ft(self) -> Dict[str, type]:
         """Motor features for observation and action spaces."""
         features = {}
-        # Right arm motors
+        # Right arm motors - only positions stored in dataset
         for motor in self.bus_right.motors:
             features[f"right_{motor}.pos"] = float
-            features[f"right_{motor}.vel"] = float
-            features[f"right_{motor}.torque"] = float
-        # Left arm motors
+        # Left arm motors - only positions stored in dataset
         for motor in self.bus_left.motors:
             features[f"left_{motor}.pos"] = float
-            features[f"left_{motor}.vel"] = float
-            features[f"left_{motor}.torque"] = float
         return features
 
     @property
@@ -159,9 +166,9 @@ class OpenArmsFollower(Robot):
         self.bus_left.connect()
         
         # Run calibration if needed
-        if not self.is_calibrated and calibrate:
+        if calibrate:
             logger.info(
-                "No calibration found or calibration mismatch. Running calibration..."
+                "No calibration found or overwriting calibration. Running calibration..."
             )
             self.calibrate()
         
@@ -287,46 +294,81 @@ class OpenArmsFollower(Robot):
         raise NotImplementedError("Motor ID configuration is typically done via manufacturer tools for CAN motors.")
 
     def get_observation(self) -> Dict[str, Any]:
-        """Get current observation from robot including position, velocity, and torque."""
+        """
+        Get current observation from robot including position, velocity, and torque.
+        
+        OPTIMIZED: Reads all motor states (pos/vel/torque) in one CAN refresh cycle
+        instead of 3 separate reads.
+        
+        Note: Velocity and torque are read but not stored in dataset (only used for
+        internal calculations). Only positions and camera images are stored.
+        """
         if not self.is_connected:
             raise DeviceNotConnectedError(f"{self} is not connected.")
         
         obs_dict = {}
         
-        # Read motor positions, velocities, and torques from right arm
-        start = time.perf_counter()
-        positions_right = self.bus_right.sync_read("Present_Position")
-        velocities_right = self.bus_right.sync_read("Present_Velocity")
-        torques_right = self.bus_right.sync_read("Present_Torque")
+        # Detailed profiling for bottleneck analysis
+        timings = {}
+        
+        # OPTIMIZED: Use sync_read_all_states to get pos/vel/torque in one go
+        t0 = time.perf_counter()
+        right_states = self.bus_right.sync_read_all_states()
+        timings["right_motors"] = (time.perf_counter() - t0) * 1000
         
         for motor in self.bus_right.motors:
-            obs_dict[f"right_{motor}.pos"] = positions_right.get(motor, 0.0)
-            obs_dict[f"right_{motor}.vel"] = velocities_right.get(motor, 0.0)
-            obs_dict[f"right_{motor}.torque"] = torques_right.get(motor, 0.0)
+            state = right_states.get(motor, {})
+            obs_dict[f"right_{motor}.pos"] = state.get("position", 0.0)
+            obs_dict[f"right_{motor}.vel"] = state.get("velocity", 0.0)
+            obs_dict[f"right_{motor}.torque"] = state.get("torque", 0.0)
         
-        # Read motor positions, velocities, and torques from left arm
-        positions_left = self.bus_left.sync_read("Present_Position")
-        velocities_left = self.bus_left.sync_read("Present_Velocity")
-        torques_left = self.bus_left.sync_read("Present_Torque")
+        # OPTIMIZED: Use sync_read_all_states to get pos/vel/torque in one go
+        t0 = time.perf_counter()
+        left_states = self.bus_left.sync_read_all_states()
+        timings["left_motors"] = (time.perf_counter() - t0) * 1000
         
         for motor in self.bus_left.motors:
-            obs_dict[f"left_{motor}.pos"] = positions_left.get(motor, 0.0)
-            obs_dict[f"left_{motor}.vel"] = velocities_left.get(motor, 0.0)
-            obs_dict[f"left_{motor}.torque"] = torques_left.get(motor, 0.0)
+            state = left_states.get(motor, {})
+            obs_dict[f"left_{motor}.pos"] = state.get("position", 0.0)
+            obs_dict[f"left_{motor}.vel"] = state.get("velocity", 0.0)
+            obs_dict[f"left_{motor}.torque"] = state.get("torque", 0.0)
         
-        dt_ms = (time.perf_counter() - start) * 1e3
-        logger.debug(f"{self} read state: {dt_ms:.1f}ms")
-        
-        # Capture images from cameras
+        # Capture images from cameras (with individual timing)
+        # Use async_read with very short timeout to avoid blocking on slow USB cameras
         for cam_key, cam in self.cameras.items():
-            start = time.perf_counter()
-            obs_dict[cam_key] = cam.async_read()
-            dt_ms = (time.perf_counter() - start) * 1e3
-            logger.debug(f"{self} read {cam_key}: {dt_ms:.1f}ms")
+            t0 = time.perf_counter()
+            try:
+                # Use 5ms timeout - if frame isn't ready, reuse last frame
+                frame = cam.async_read(timeout_ms=5)
+                self.camera_frame_cache[cam_key] = frame  # Update cache
+                obs_dict[cam_key] = frame
+            except TimeoutError:
+                # If no new frame available, reuse last valid frame from cache
+                # This prevents blocking the entire control loop on slow USB reads
+                if self.camera_frame_cache[cam_key] is not None:
+                    obs_dict[cam_key] = self.camera_frame_cache[cam_key]
+                    logger.debug(f"Camera {cam_key} timeout, reusing cached frame")
+
+            # Store timing with padded name to align output (e.g. "left_wrist    ")
+            timings[f"{cam_key:14s}"] = (time.perf_counter() - t0) * 1000
+        
+        # Log detailed timings (for debugging slow observations)
+        if logger.isEnabledFor(logging.DEBUG):
+            total_time = sum(timings.values())
+            breakdown = " | ".join([f"{k}: {v:.1f}ms" for k, v in timings.items()])
+            logger.debug(f"{self} get_observation: {total_time:.1f}ms total | {breakdown}")
+        
+        # Store timings in obs_dict for external profiling
+        obs_dict["_timing_breakdown"] = timings
         
         return obs_dict
 
-    def send_action(self, action: Dict[str, Any]) -> Dict[str, Any]:
+    def send_action(
+        self, 
+        action: Dict[str, Any], 
+        custom_kp: Optional[Dict[str, float]] = None,
+        custom_kd: Optional[Dict[str, float]] = None
+    ) -> Dict[str, Any]:
         """
         Send action command to robot.
         
@@ -334,6 +376,8 @@ class OpenArmsFollower(Robot):
         
         Args:
             action: Dictionary with motor positions (e.g., "right_joint_1.pos", "left_joint_2.pos")
+            custom_kp: Optional custom kp gains per motor (e.g., {"right_joint_1": 120.0, "left_joint_2": 150.0})
+            custom_kd: Optional custom kd gains per motor (e.g., {"right_joint_1": 1.5, "left_joint_2": 2.0})
             
         Returns:
             The action actually sent (potentially clipped)
@@ -355,6 +399,24 @@ class OpenArmsFollower(Robot):
                     # Remove "left_" prefix for bus access
                     goal_pos_left[motor_name.removeprefix("left_")] = val
         
+        # Apply joint limit clipping to right arm
+        for motor_name, position in goal_pos_right.items():
+            if motor_name in self.config.joint_limits_right:
+                min_limit, max_limit = self.config.joint_limits_right[motor_name]
+                clipped_position = max(min_limit, min(max_limit, position))
+                if clipped_position != position:
+                    logger.debug(f"Clipped right_{motor_name} from {position:.2f}° to {clipped_position:.2f}°")
+                goal_pos_right[motor_name] = clipped_position
+        
+        # Apply joint limit clipping to left arm
+        for motor_name, position in goal_pos_left.items():
+            if motor_name in self.config.joint_limits_left:
+                min_limit, max_limit = self.config.joint_limits_left[motor_name]
+                clipped_position = max(min_limit, min(max_limit, position))
+                if clipped_position != position:
+                    logger.debug(f"Clipped left_{motor_name} from {position:.2f}° to {clipped_position:.2f}°")
+                goal_pos_left[motor_name] = clipped_position
+        
         # Apply safety limits if configured
         if self.config.max_relative_target is not None:
             # Get current positions
@@ -395,39 +457,47 @@ class OpenArmsFollower(Robot):
             "gripper": 7,
         }
         
-        # Send MIT control commands to right arm
-        for motor_name, position_degrees in goal_pos_right.items():
-            # Get per-motor gains from config
-            idx = motor_index.get(motor_name, 0)
-            kp = self.config.position_kp[idx]
-            kd = self.config.position_kd[idx]
-            
-            # Send MIT control command (position is in degrees)
-            self.bus_right._mit_control(
-                motor_name,
-                kp=kp,
-                kd=kd,
-                position_degrees=position_degrees,
-                velocity_deg_per_sec=0.0,
-                torque=0.0
-            )
+        # Use batch MIT control for right arm (sends all commands, then collects responses)
+        if goal_pos_right:
+            commands_right = {}
+            for motor_name, position_degrees in goal_pos_right.items():
+                idx = motor_index.get(motor_name, 0)
+                
+                # Use custom gains if provided, otherwise use config defaults
+                full_motor_name = f"right_{motor_name}"
+                if custom_kp is not None and full_motor_name in custom_kp:
+                    kp = custom_kp[full_motor_name]
+                else:
+                    kp = self.config.position_kp[idx] if isinstance(self.config.position_kp, list) else self.config.position_kp
+                
+                if custom_kd is not None and full_motor_name in custom_kd:
+                    kd = custom_kd[full_motor_name]
+                else:
+                    kd = self.config.position_kd[idx] if isinstance(self.config.position_kd, list) else self.config.position_kd
+                
+                commands_right[motor_name] = (kp, kd, position_degrees, 0.0, 0.0)
+            self.bus_right._mit_control_batch(commands_right)
         
-        # Send MIT control commands to left arm
-        for motor_name, position_degrees in goal_pos_left.items():
-            # Get per-motor gains from config
-            idx = motor_index.get(motor_name, 0)
-            kp = self.config.position_kp[idx]
-            kd = self.config.position_kd[idx]
-            
-            # Send MIT control command (position is in degrees)
-            self.bus_left._mit_control(
-                motor_name,
-                kp=kp,
-                kd=kd,
-                position_degrees=position_degrees,
-                velocity_deg_per_sec=0.0,
-                torque=0.0
-            )
+        # Use batch MIT control for left arm (sends all commands, then collects responses)
+        if goal_pos_left:
+            commands_left = {}
+            for motor_name, position_degrees in goal_pos_left.items():
+                idx = motor_index.get(motor_name, 0)
+                
+                # Use custom gains if provided, otherwise use config defaults
+                full_motor_name = f"left_{motor_name}"
+                if custom_kp is not None and full_motor_name in custom_kp:
+                    kp = custom_kp[full_motor_name]
+                else:
+                    kp = self.config.position_kp[idx] if isinstance(self.config.position_kp, list) else self.config.position_kp
+                
+                if custom_kd is not None and full_motor_name in custom_kd:
+                    kd = custom_kd[full_motor_name]
+                else:
+                    kd = self.config.position_kd[idx] if isinstance(self.config.position_kd, list) else self.config.position_kd
+                
+                commands_left[motor_name] = (kp, kd, position_degrees, 0.0, 0.0)
+            self.bus_left._mit_control_batch(commands_left)
         
         # Return the actions that were actually sent
         result = {}
@@ -476,34 +546,153 @@ class OpenArmsFollower(Robot):
                 "Ensure urdf/openarms.urdf exists and is valid."
             )
         
-        # Build position vector in the order of motors (right arm, then left arm)
+        # Build position vector in the order of motors (left arm, then right arm)
+        # This order must match the URDF joint order
+        # URDF has: left_joint1-7, left_finger_joint1-2, right_joint1-7, right_finger_joint1-2
         q = np.zeros(self.pin_robot.model.nq)
         idx = 0
         
-        # Right arm motors
-        for motor_name in self.bus_right.motors:
-            full_name = f"right_{motor_name}"
-            q[idx] = q_rad.get(full_name, 0.0)
-            idx += 1
-        
-        # Left arm motors
+        # Left arm motors (first in URDF) - joints 1-7
         for motor_name in self.bus_left.motors:
+            if motor_name == "gripper":
+                continue  # Skip gripper, will be handled separately
             full_name = f"left_{motor_name}"
             q[idx] = q_rad.get(full_name, 0.0)
             idx += 1
         
+        # Skip left finger joints (leave as zeros)
+        idx += 2
+        
+        # Right arm motors (second in URDF) - joints 1-7
+        for motor_name in self.bus_right.motors:
+            if motor_name == "gripper":
+                continue  # Skip gripper, will be handled separately
+            full_name = f"right_{motor_name}"
+            q[idx] = q_rad.get(full_name, 0.0)
+            idx += 1
+        
+        # Skip right finger joints (leave as zeros)
+        idx += 2
+        
         # Compute generalized gravity vector
         g = pin.computeGeneralizedGravity(self.pin_robot.model, self.pin_robot.data, q)
         
-        # Map back to motor names
+        # Map back to motor names (only arm joints, not fingers)
         result = {}
         idx = 0
-        for motor_name in self.bus_right.motors:
-            result[f"right_{motor_name}"] = float(g[idx])
-            idx += 1
+        
+        # Left arm torques (joints 1-7)
         for motor_name in self.bus_left.motors:
+            if motor_name == "gripper":
+                result["left_gripper"] = 0.0  # No gravity compensation for gripper
+                continue
             result[f"left_{motor_name}"] = float(g[idx])
             idx += 1
         
+        # Skip left finger joint torques in output
+        idx += 2
+        
+        # Right arm torques (joints 1-7)
+        for motor_name in self.bus_right.motors:
+            if motor_name == "gripper":
+                result["right_gripper"] = 0.0  # No gravity compensation for gripper
+                continue
+            result[f"right_{motor_name}"] = float(g[idx])
+            idx += 1
+        
+        # Skip right finger joint torques in output
+        idx += 2
+        
         return result
     
+    def _friction_from_velocity(
+        self, 
+        velocity_rad_per_sec: Dict[str, float],
+        friction_scale: float = 1.0,
+        amp_tmp: float = 1.0,
+        coef_tmp: float = 0.1
+    ) -> Dict[str, float]:
+        """
+        Compute friction torques for all joints in the robot using tanh friction model.
+        
+        Args:
+            velocity_rad_per_sec: Dictionary mapping motor names (with arm prefix) to velocities in rad/s
+            friction_scale: Scale factor for friction compensation (default 1.0, use 0.3 for stability)
+            amp_tmp: Amplitude factor for tanh term (default 1.0)
+            coef_tmp: Coefficient for tanh steepness (default 0.1)
+            
+        Returns:
+            Dictionary mapping motor names to friction torques in N·m
+        """
+        # Motor name to index mapping
+        motor_name_to_index = {
+            "joint_1": 0,
+            "joint_2": 1,
+            "joint_3": 2,
+            "joint_4": 3,
+            "joint_5": 4,
+            "joint_6": 5,
+            "joint_7": 6,
+            "gripper": 7,
+        }
+        
+        result = {}
+        
+        # Process all motors (left and right)
+        for motor_full_name, velocity in velocity_rad_per_sec.items():
+            # Extract motor name without arm prefix
+            if motor_full_name.startswith("right_"):
+                motor_name = motor_full_name.removeprefix("right_")
+            elif motor_full_name.startswith("left_"):
+                motor_name = motor_full_name.removeprefix("left_")
+            else:
+                result[motor_full_name] = 0.0
+                continue
+            
+            # Get motor index for friction parameters
+            motor_index = motor_name_to_index.get(motor_name, 0)
+            
+            # Get friction parameters from config
+            Fc = self.config.friction_fc[motor_index]
+            k = self.config.friction_k[motor_index]
+            Fv = self.config.friction_fv[motor_index]
+            Fo = self.config.friction_fo[motor_index]
+            
+            # Friction model: τ_fric = amp * Fc * tanh(coef * k * ω) + Fv * ω + Fo
+            friction_torque = (
+                amp_tmp * Fc * np.tanh(coef_tmp * k * velocity) +
+                Fv * velocity +
+                Fo
+            )
+            
+            # Apply scale factor
+            friction_torque *= friction_scale
+            
+            result[motor_full_name] = float(friction_torque)
+        
+        return result
+    
+    def get_damping_kd(self, motor_name: str) -> float:
+        """
+        Get damping gain (Kd) for a specific motor.
+        
+        Args:
+            motor_name: Motor name without arm prefix (e.g., "joint_1", "gripper")
+            
+        Returns:
+            Damping gain value
+        """
+        motor_name_to_index = {
+            "joint_1": 0,
+            "joint_2": 1,
+            "joint_3": 2,
+            "joint_4": 3,
+            "joint_5": 4,
+            "joint_6": 5,
+            "joint_7": 6,
+            "gripper": 7,
+        }
+        
+        motor_index = motor_name_to_index.get(motor_name, 0)
+        return self.config.damping_kd[motor_index]
+    

src/lerobot/scratch.txt

@@ -0,0 +1,41 @@
+# Eun visualizer locally
+
+# login to hf an set your access token
+hf auth login
+# if not installed, install with: pip install huggingface_hub
+git clone https://github.com/huggingface/lerobot-dataset-visualizer.git
+cd lerobot-dataset-visualizer
+python -m lerobot_dataset_viz --repo-id lerobot-data-collection/repo-id-nez --episode-index 0
+git checkout feat/private_repo_viz
+npm install
+npm run dev
+# open http://localhost:3000 in your browser
+
+
+# ======================================================
+
+
+# default merge command; copy your list of datasets ids in repo_ids
+
+python -m lerobot.scripts.lerobot_edit_dataset \
+--repo_id lerobot-data-collection/repo-id-nez \
+--operation.type merge --push_to_hub true \
+--operation.repo_ids "[]"
+
+
+# merge test datasets into one
+
+python -m lerobot.scripts.lerobot_edit_dataset \
+--repo_id lerobot-data-collection/test-2025-11-03-merged \
+--operation.type merge --push_to_hub true \
+--operation.repo_ids "['lerobot-data-collection/test-2025-11-03-13-18', 'lerobot-data-collection/test-2025-11-03-13-19', 'lerobot-data-collection/test-2025-11-03-13-20', 'lerobot-data-collection/test-2025-11-03-13-21', 'lerobot-data-collection/test-2025-11-03-13-23', 'lerobot-data-collection/test-2025-11-03-13-24', 'lerobot-data-collection/test-2025-11-03-13-25', 'lerobot-data-collection/test-2025-11-03-13-26', 'lerobot-data-collection/test-2025-11-03-13-27', 'lerobot-data-collection/test-2025-11-03-13-29', 'lerobot-data-collection/test-2025-11-03-13-30', 'lerobot-data-collection/test-2025-11-03-13-31', 'lerobot-data-collection/test-2025-11-03-13-34', 'lerobot-data-collection/test-2025-11-03-13-41', 'lerobot-data-collection/test-2025-11-03-13-42', 'lerobot-data-collection/test-2025-11-03-13-43', 'lerobot-data-collection/test-2025-11-03-13-44', 'lerobot-data-collection/test-2025-11-03-13-45', 'lerobot-data-collection/test-2025-11-03-13-46', 'lerobot-data-collection/test-2025-11-03-13-47', 'lerobot-data-collection/test-2025-11-03-13-48', 'lerobot-data-collection/test-2025-11-03-13-49']"
+
+# RUN loop_dataset.py to get your repo_ids
+
+# ========================================================= Two folds datasets
+
+#merge
+python -m lerobot.scripts.lerobot_edit_dataset \
+--repo_id lerobot-data-collection/two-folds-dataset-full-11-04 \
+--operation.type merge --push_to_hub true \
+--operation.repo_ids "['lerobot-data-collection/two-folds-dataset-2025-11-04-15-06', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-08', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-10', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-11', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-12', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-14', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-16', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-18', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-20', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-22', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-24', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-25', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-27', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-28', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-29', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-33', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-34', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-35', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-36', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-52', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-53', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-54', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-55', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-56', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-57', 'lerobot-data-collection/two-folds-dataset-2025-11-04-15-59', 'lerobot-data-collection/two-folds-dataset-2025-11-04-16-00', 'lerobot-data-collection/two-folds-dataset-2025-11-04-16-01', 'lerobot-data-collection/two-folds-dataset-2025-11-04-16-02', 'lerobot-data-collection/two-folds-dataset-2025-11-04-16-03', 'lerobot-data-collection/two-folds-dataset-2025-11-04-16-04', 'lerobot-data-collection/two-folds-dataset-2025-11-04-16-05', 'lerobot-data-collection/two-folds-dataset-2025-11-04-16-06', 'lerobot-data-collection/two-folds-dataset-2025-11-04-16-07', 'lerobot-data-collection/two-folds-dataset-2025-11-04-16-08', 'lerobot-data-collection/two-folds-dataset-2025-11-04-16-09', 'lerobot-data-collection/two-folds-dataset-2025-11-04-16-26', 'lerobot-data-collection/two-folds-dataset-2025-11-04-16-28', 'lerobot-data-collection/two-folds-dataset-2025-11-04-16-29', 'lerobot-data-collection/two-folds-dataset-2025-11-04-16-30']"

src/lerobot/scripts/lerobot_setup_motors.py

@@ -42,6 +42,7 @@ from lerobot.teleoperators import (  # noqa: F401
     make_teleoperator_from_config,
     so100_leader,
     so101_leader,
+    openarms_mini
 )
 
 COMPATIBLE_DEVICES = [
@@ -52,6 +53,7 @@ COMPATIBLE_DEVICES = [
     "so101_follower",
     "so101_leader",
     "lekiwi",
+    "openarms_mini",
 ]
 
 

src/lerobot/teleoperators/openarms/config_openarms_leader.py

@@ -62,3 +62,19 @@ class OpenArmsLeaderConfig(TeleoperatorConfig):
     # Torque mode settings for manual control
     # When enabled, motors have torque disabled for manual movement
     manual_control: bool = True
+    
+    # MIT control parameters (used when manual_control=False for torque control)
+    # List of 8 values: [joint_1, joint_2, joint_3, joint_4, joint_5, joint_6, joint_7, gripper]
+    position_kp: list[float] = field(default_factory=lambda: [240.0, 240.0, 240.0, 240.0, 24.0, 31.0, 25.0, 16.0])
+    position_kd: list[float] = field(default_factory=lambda: [3.0, 3.0, 3.0, 3.0, 0.2, 0.2, 0.2, 0.2])
+    
+    # Damping gains for stability when applying torque compensation (gravity/friction)
+    # Used when kp=0 and only torque is applied
+    damping_kd: list[float] = field(default_factory=lambda: [0.5, 0.5, 0.5, 0.5, 0.1, 0.1, 0.1, 0.1])
+    
+    # Friction model parameters: τ_fric(ω) = Fo + Fv·ω + Fc·tanh(k·ω)
+    # From OpenArms config/leader.yaml (note: Fc[5] is slightly different: 0.083 vs 0.093)
+    friction_fc: list[float] = field(default_factory=lambda: [0.306, 0.306, 0.40, 0.166, 0.050, 0.083, 0.172, 0.0512])  # Coulomb friction [Nm]
+    friction_k: list[float] = field(default_factory=lambda: [28.417, 28.417, 29.065, 130.038, 151.771, 242.287, 7.888, 4.000])  # tanh steepness
+    friction_fv: list[float] = field(default_factory=lambda: [0.063, 0.0630, 0.604, 0.813, 0.029, 0.072, 0.084, 0.084])  # Viscous friction [Nm·s/rad]
+    friction_fo: list[float] = field(default_factory=lambda: [0.088, 0.088, 0.008, -0.058, 0.005, 0.009, -0.059, -0.050])  # Offset torque [Nm]

src/lerobot/teleoperators/openarms/openarms_leader.py

@@ -18,6 +18,9 @@ import logging
 import time
 from typing import Any, Dict
 
+import numpy as np
+import pinocchio as pin
+
 from lerobot.motors import Motor, MotorCalibration, MotorNormMode
 from lerobot.motors.damiao import DamiaoMotorsBus
 from lerobot.motors.damiao.tables import MotorType
@@ -84,20 +87,35 @@ class OpenArmsLeader(Teleoperator):
             data_bitrate=self.config.can_data_bitrate if self.config.use_can_fd else None,
         )
 
+        # Initialize Pinocchio robot model for dynamics (optional)
+        self.pin_robot = None
+        try:
+            # Load URDF - try external path first (with meshes), then repository
+            import os
+            from os.path import expanduser, dirname
+            
+            # Try external URDF with meshes first
+            external_urdf_path = expanduser("~/Documents/openarm_description/openarm_bimanual_pybullet.urdf")
+            if os.path.exists(external_urdf_path):
+                urdf_path = external_urdf_path
+                urdf_dir = dirname(urdf_path)
+            
+                self.pin_robot = pin.RobotWrapper.BuildFromURDF(urdf_path, urdf_dir)
+                self.pin_robot.data = self.pin_robot.model.createData()
+                logger.info(f"Loaded OpenArms URDF for dynamics computation from {urdf_path}")
+        except Exception as e:
+            logger.warning(f"Could not load URDF for dynamics: {e}. Gravity compensation will not be available.")
+
     @property
     def action_features(self) -> Dict[str, type]:
         """Features produced by this teleoperator."""
         features = {}
-        # Right arm motors
+        # Right arm motors - only positions stored in dataset
         for motor in self.bus_right.motors:
             features[f"right_{motor}.pos"] = float
-            features[f"right_{motor}.vel"] = float
-            features[f"right_{motor}.torque"] = float
-        # Left arm motors
+        # Left arm motors - only positions stored in dataset
         for motor in self.bus_left.motors:
             features[f"left_{motor}.pos"] = float
-            features[f"left_{motor}.vel"] = float
-            features[f"left_{motor}.torque"] = float
         return features
 
     @property
@@ -127,9 +145,9 @@ class OpenArmsLeader(Teleoperator):
         self.bus_left.connect()
         
         # Run calibration if needed
-        if not self.is_calibrated and calibrate:
+        if calibrate:
             logger.info(
-                "No calibration found or calibration mismatch. Running calibration..."
+                "No calibration found or overwriting calibration. Running calibration..."
             )
             self.calibrate()
         
@@ -254,32 +272,32 @@ class OpenArmsLeader(Teleoperator):
         
         This is the main method for teleoperators - it reads the current state
         of the leader arm and returns it as an action that can be sent to a follower.
+        
+        Reads all motor states (pos/vel/torque) in one CAN refresh cycle.
+        Note: Velocity and torque are read but not stored in dataset (only used for
+        gravity/friction compensation during recording).
         """
         if not self.is_connected:
             raise DeviceNotConnectedError(f"{self} is not connected.")
         
         action_dict = {}
-        
-        # Read motor positions, velocities, and torques from right arm
         start = time.perf_counter()
-        positions_right = self.bus_right.sync_read("Present_Position")
-        velocities_right = self.bus_right.sync_read("Present_Velocity")
-        torques_right = self.bus_right.sync_read("Present_Torque")
         
+        # OPTIMIZED: Use sync_read_all_states to get pos/vel/torque in one go
+        right_states = self.bus_right.sync_read_all_states()
         for motor in self.bus_right.motors:
-            action_dict[f"right_{motor}.pos"] = positions_right.get(motor, 0.0)
-            action_dict[f"right_{motor}.vel"] = velocities_right.get(motor, 0.0)
-            action_dict[f"right_{motor}.torque"] = torques_right.get(motor, 0.0)
-        
-        # Read motor positions, velocities, and torques from left arm
-        positions_left = self.bus_left.sync_read("Present_Position")
-        velocities_left = self.bus_left.sync_read("Present_Velocity")
-        torques_left = self.bus_left.sync_read("Present_Torque")
+            state = right_states.get(motor, {})
+            action_dict[f"right_{motor}.pos"] = state.get("position", 0.0)
+            action_dict[f"right_{motor}.vel"] = state.get("velocity", 0.0)
+            action_dict[f"right_{motor}.torque"] = state.get("torque", 0.0)
         
+        # OPTIMIZED: Use sync_read_all_states to get pos/vel/torque in one go
+        left_states = self.bus_left.sync_read_all_states()
         for motor in self.bus_left.motors:
-            action_dict[f"left_{motor}.pos"] = positions_left.get(motor, 0.0)
-            action_dict[f"left_{motor}.vel"] = velocities_left.get(motor, 0.0)
-            action_dict[f"left_{motor}.torque"] = torques_left.get(motor, 0.0)
+            state = left_states.get(motor, {})
+            action_dict[f"left_{motor}.pos"] = state.get("position", 0.0)
+            action_dict[f"left_{motor}.vel"] = state.get("velocity", 0.0)
+            action_dict[f"left_{motor}.torque"] = state.get("torque", 0.0)
         
         dt_ms = (time.perf_counter() - start) * 1e3
         logger.debug(f"{self} read state: {dt_ms:.1f}ms")
@@ -308,3 +326,178 @@ class OpenArmsLeader(Teleoperator):
         
         logger.info(f"{self} disconnected.")
 
+    def _deg_to_rad(self, deg: Dict[str, float | int]) -> Dict[str, float]:
+        """Convert degrees to radians for all motors."""
+        return {m: np.deg2rad(float(v)) for m, v in deg.items()}
+    
+    def _gravity_from_q(self, q_rad: Dict[str, float]) -> Dict[str, float]:
+        """
+        Compute g(q) [N·m] for all joints in the robot.
+        The order of joints in the URDF matches the concatenated motor lists (right then left).
+        
+        Args:
+            q_rad: Dictionary mapping motor names (with arm prefix) to positions in radians
+            
+        Returns:
+            Dictionary mapping motor names to gravity torques in N·m
+            
+        Raises:
+            RuntimeError: If URDF model is not loaded
+        """
+        if self.pin_robot is None:
+            raise RuntimeError(
+                "Cannot compute gravity: URDF model not loaded. "
+                "Ensure urdf/openarms.urdf exists and is valid."
+            )
+        
+        # Build position vector in the order of motors (left arm, then right arm)
+        # This order must match the URDF joint order
+        # URDF has: left_joint1-7, left_finger_joint1-2, right_joint1-7, right_finger_joint1-2
+        q = np.zeros(self.pin_robot.model.nq)
+        idx = 0
+        
+        # Left arm motors (first in URDF) - joints 1-7
+        for motor_name in self.bus_left.motors:
+            if motor_name == "gripper":
+                continue  # Skip gripper, will be handled separately
+            full_name = f"left_{motor_name}"
+            q[idx] = q_rad.get(full_name, 0.0)
+            idx += 1
+        
+        # Skip left finger joints (leave as zeros)
+        idx += 2
+        
+        # Right arm motors (second in URDF) - joints 1-7
+        for motor_name in self.bus_right.motors:
+            if motor_name == "gripper":
+                continue  # Skip gripper, will be handled separately
+            full_name = f"right_{motor_name}"
+            q[idx] = q_rad.get(full_name, 0.0)
+            idx += 1
+        
+        # Skip right finger joints (leave as zeros)
+        idx += 2
+        
+        # Compute generalized gravity vector
+        g = pin.computeGeneralizedGravity(self.pin_robot.model, self.pin_robot.data, q)
+        
+        # Map back to motor names (only arm joints, not fingers)
+        result = {}
+        idx = 0
+        
+        # Left arm torques (joints 1-7)
+        for motor_name in self.bus_left.motors:
+            if motor_name == "gripper":
+                result["left_gripper"] = 0.0  # No gravity compensation for gripper
+                continue
+            result[f"left_{motor_name}"] = float(g[idx])
+            idx += 1
+        
+        # Skip left finger joint torques in output
+        idx += 2
+        
+        # Right arm torques (joints 1-7)
+        for motor_name in self.bus_right.motors:
+            if motor_name == "gripper":
+                result["right_gripper"] = 0.0  # No gravity compensation for gripper
+                continue
+            result[f"right_{motor_name}"] = float(g[idx])
+            idx += 1
+        
+        # Skip right finger joint torques in output
+        idx += 2
+        
+        return result
+    
+    def _friction_from_velocity(
+        self, 
+        velocity_rad_per_sec: Dict[str, float],
+        friction_scale: float = 1.0,
+        amp_tmp: float = 1.0,
+        coef_tmp: float = 0.1
+    ) -> Dict[str, float]:
+        """
+        Compute friction torques for all joints in the robot using tanh friction model.
+        
+        Args:
+            velocity_rad_per_sec: Dictionary mapping motor names (with arm prefix) to velocities in rad/s
+            friction_scale: Scale factor for friction compensation (default 1.0, use 0.3 for stability)
+            amp_tmp: Amplitude factor for tanh term (default 1.0)
+            coef_tmp: Coefficient for tanh steepness (default 0.1)
+            
+        Returns:
+            Dictionary mapping motor names to friction torques in N·m
+        """
+        # Motor name to index mapping
+        motor_name_to_index = {
+            "joint_1": 0,
+            "joint_2": 1,
+            "joint_3": 2,
+            "joint_4": 3,
+            "joint_5": 4,
+            "joint_6": 5,
+            "joint_7": 6,
+            "gripper": 7,
+        }
+        
+        result = {}
+        
+        # Process all motors (left and right)
+        for motor_full_name, velocity in velocity_rad_per_sec.items():
+            # Extract motor name without arm prefix
+            if motor_full_name.startswith("right_"):
+                motor_name = motor_full_name.removeprefix("right_")
+            elif motor_full_name.startswith("left_"):
+                motor_name = motor_full_name.removeprefix("left_")
+            else:
+                result[motor_full_name] = 0.0
+                continue
+            
+            # Get motor index for friction parameters
+            motor_index = motor_name_to_index.get(motor_name, 0)
+            
+            # Get friction parameters from config
+            Fc = self.config.friction_fc[motor_index]
+            k = self.config.friction_k[motor_index]
+            Fv = self.config.friction_fv[motor_index]
+            Fo = self.config.friction_fo[motor_index]
+            
+            # Friction model: τ_fric = amp * Fc * tanh(coef * k * ω) + Fv * ω + Fo
+            friction_torque = (
+                amp_tmp * Fc * np.tanh(coef_tmp * k * velocity) +
+                Fv * velocity +
+                Fo
+            )
+            
+            # Apply scale factor
+            friction_torque *= friction_scale
+            
+            result[motor_full_name] = float(friction_torque)
+        
+        return result
+    
+    def get_damping_kd(self, motor_name: str) -> float:
+        """
+        Get damping gain (Kd) for a specific motor.
+        
+        Args:
+            motor_name: Motor name without arm prefix (e.g., "joint_1", "gripper")
+            
+        Returns:
+            Damping gain value
+        """
+        motor_name_to_index = {
+            "joint_1": 0,
+            "joint_2": 1,
+            "joint_3": 2,
+            "joint_4": 3,
+            "joint_5": 4,
+            "joint_6": 5,
+            "joint_7": 6,
+            "gripper": 7,
+        }
+        
+        motor_index = motor_name_to_index.get(motor_name, 0)
+        return self.config.damping_kd[motor_index]
+
+

src/lerobot/teleoperators/openarms_mini/__init__.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+
+# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .config_openarms_mini import OpenArmsMiniConfig
+from .openarms_mini import OpenArmsMini
+
+__all__ = ["OpenArmsMini", "OpenArmsMiniConfig"]
+

src/lerobot/teleoperators/openarms_mini/config_openarms_mini.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+
+# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass
+
+from ..teleoperator import TeleoperatorConfig
+
+
+@TeleoperatorConfig.register_subclass("openarms_mini")
+@dataclass
+class OpenArmsMiniConfig(TeleoperatorConfig):
+    """Configuration for OpenArms Mini teleoperator with Feetech motors (dual arms)."""
+    
+    # Serial ports for left and right arms
+    port_right: str = "/dev/ttyUSB0"  # Serial port for right arm
+    port_left: str = "/dev/ttyUSB1"   # Serial port for left arm
+    
+    # Whether to use degrees mode (True) or normalized mode (False)
+    use_degrees: bool = True
+

src/lerobot/teleoperators/openarms_mini/openarms_mini.py

@@ -0,0 +1,333 @@
+#!/usr/bin/env python
+
+# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import time
+
+from lerobot.motors import Motor, MotorCalibration, MotorNormMode
+from lerobot.motors.feetech import (
+    FeetechMotorsBus,
+    OperatingMode,
+)
+from lerobot.utils.errors import DeviceAlreadyConnectedError, DeviceNotConnectedError
+
+from ..teleoperator import Teleoperator
+from .config_openarms_mini import OpenArmsMiniConfig
+
+logger = logging.getLogger(__name__)
+
+
+class OpenArmsMini(Teleoperator):
+    """
+    OpenArms Mini Teleoperator with dual Feetech-based arms (8 motors per arm).
+    Each arm has 7 joints plus a gripper, using the same DOF as OpenArms.
+    """
+
+    config_class = OpenArmsMiniConfig
+    name = "openarms_mini"
+
+    def __init__(self, config: OpenArmsMiniConfig):
+        super().__init__(config)
+        self.config = config
+        
+        # Use degrees mode for all motors
+        norm_mode_body = MotorNormMode.DEGREES
+        
+        # Right arm motors (8 motors: joint_1 to joint_7 + gripper)
+        motors_right = {
+            "joint_1": Motor(1, "sts3215", norm_mode_body),
+            "joint_2": Motor(2, "sts3215", norm_mode_body),
+            "joint_3": Motor(3, "sts3215", norm_mode_body),
+            "joint_4": Motor(4, "sts3215", norm_mode_body),
+            "joint_5": Motor(5, "sts3215", norm_mode_body),
+            "joint_6": Motor(6, "sts3215", norm_mode_body),
+            "joint_7": Motor(7, "sts3215", norm_mode_body),
+            "gripper": Motor(8, "sts3215", MotorNormMode.RANGE_0_100),
+        }
+        
+        # Left arm motors (8 motors: joint_1 to joint_7 + gripper)
+        # Note: Left arm uses IDs 11-18 to avoid conflicts if on same bus
+        motors_left = {
+            "joint_1": Motor(1, "sts3215", norm_mode_body),
+            "joint_2": Motor(2, "sts3215", norm_mode_body),
+            "joint_3": Motor(3, "sts3215", norm_mode_body),
+            "joint_4": Motor(4, "sts3215", norm_mode_body),
+            "joint_5": Motor(5, "sts3215", norm_mode_body),
+            "joint_6": Motor(6, "sts3215", norm_mode_body),
+            "joint_7": Motor(7, "sts3215", norm_mode_body),
+            "gripper": Motor(8, "sts3215", MotorNormMode.RANGE_0_100),
+        }
+        
+        # Initialize Feetech motor buses for each arm
+        self.bus_right = FeetechMotorsBus(
+            port=self.config.port_right,
+            motors=motors_right,
+            calibration={k.replace("right_", ""): v for k, v in (self.calibration or {}).items() if k.startswith("right_")},
+        )
+        
+        self.bus_left = FeetechMotorsBus(
+            port=self.config.port_left,
+            motors=motors_left,
+            calibration={k.replace("left_", ""): v for k, v in (self.calibration or {}).items() if k.startswith("left_")},
+        )
+
+    @property
+    def action_features(self) -> dict[str, type]:
+        """Action features include positions for all motors (16 total: 8 per arm)."""
+        features = {}
+        # Right arm motors
+        for motor in self.bus_right.motors:
+            features[f"right_{motor}.pos"] = float
+        # Left arm motors
+        for motor in self.bus_left.motors:
+            features[f"left_{motor}.pos"] = float
+        return features
+
+    @property
+    def feedback_features(self) -> dict[str, type]:
+        """No feedback features for now."""
+        return {}
+
+    @property
+    def is_connected(self) -> bool:
+        """Check if both arms are connected."""
+        return self.bus_right.is_connected and self.bus_left.is_connected
+
+    def connect(self, calibrate: bool = True) -> None:
+        """Connect to both arms and optionally calibrate."""
+        if self.is_connected:
+            raise DeviceAlreadyConnectedError(f"{self} already connected")
+
+        # Connect to both buses
+        logger.info(f"Connecting right arm on {self.config.port_right}...")
+        self.bus_right.connect()
+        logger.info(f"Connecting left arm on {self.config.port_left}...")
+        self.bus_left.connect()
+        
+        # Calibrate if requested (always prompt user)
+        if calibrate:
+            self.calibrate()
+
+        # Configure motors
+        self.configure()
+        logger.info(f"{self} connected.")
+
+    @property
+    def is_calibrated(self) -> bool:
+        """Check if both arms are calibrated."""
+        return self.bus_right.is_calibrated and self.bus_left.is_calibrated
+
+    def calibrate(self) -> None:
+        """
+        Run calibration procedure for OpenArms Mini.
+        
+        The calibration procedure:
+        1. Disable torque
+        2. Ask user to position arms in hanging position with grippers closed
+        3. Set this as zero position
+        4. Set fixed range of -90° to +90° for all joints (0-100 for gripper)
+        5. Save calibration
+        """
+        if self.calibration:
+            # Ask user whether to use existing calibration
+            user_input = input(
+                f"Press ENTER to use existing calibration for {self.id}, "
+                f"or type 'c' and press ENTER to run new calibration: "
+            )
+            if user_input.strip().lower() != "c":
+                logger.info(f"Using existing calibration for {self.id}")
+                # Split calibration for each bus
+                cal_right = {k.replace("right_", ""): v for k, v in self.calibration.items() if k.startswith("right_")}
+                cal_left = {k.replace("left_", ""): v for k, v in self.calibration.items() if k.startswith("left_")}
+                self.bus_right.write_calibration(cal_right)
+                self.bus_left.write_calibration(cal_left)
+                return
+
+        logger.info(f"\nRunning calibration for {self}")
+        
+        # Calibrate each arm separately
+        self._calibrate_arm("right", self.bus_right)
+        self._calibrate_arm("left", self.bus_left)
+        
+        self._save_calibration()
+        print(f"\nCalibration complete and saved to {self.calibration_fpath}")
+
+    def _calibrate_arm(self, arm_name: str, bus: FeetechMotorsBus) -> None:
+        """Calibrate a single arm with Feetech motors."""
+        logger.info(f"\n=== Calibrating {arm_name.upper()} arm ===")
+        
+        # Disable torque for manual positioning
+        bus.disable_torque()
+        
+        # Set Phase to 12 for all motors
+        logger.info(f"Setting Phase to 12 for all motors in {arm_name.upper()} arm...")
+        for motor in bus.motors:
+            bus.write("Phase", motor, 12)
+        logger.info(f"Phase set to 12 for all motors in {arm_name.upper()} arm")
+        
+        # Set all motors to position mode
+        for motor in bus.motors:
+            bus.write("Operating_Mode", motor, OperatingMode.POSITION.value)
+        
+        # Step 1: Set zero position
+        input(
+            f"\nCalibration: Zero Position ({arm_name.upper()} arm)\n"
+            "Position the arm in the following configuration:\n"
+            "  - Arm hanging straight down\n"
+            "  - Gripper closed\n"
+            "Press ENTER when ready..."
+        )
+        
+        # Set current position as zero (half-turn homing)
+        homing_offsets = bus.set_half_turn_homings()
+        logger.info(f"{arm_name.capitalize()} arm zero position set.")
+        
+        # Step 2: Set ranges for joints and gripper
+        print(f"\nSetting motor ranges for {arm_name.upper()} arm\n")
+        
+        # Create calibration data with full motor ranges
+        if self.calibration is None:
+            self.calibration = {}
+        
+        # Get motor resolution
+        motor_resolution = bus.model_resolution_table[list(bus.motors.values())[0].model]
+        max_res = motor_resolution - 1
+        
+        for motor_name, motor in bus.motors.items():
+            # Prefix motor name with arm name for storage
+            prefixed_name = f"{arm_name}_{motor_name}"
+            
+            if motor_name == "gripper":
+                # Interactive calibration for gripper
+                input(
+                    f"\nGripper Calibration ({arm_name.upper()} arm)\n"
+                    f"Step 1: CLOSE the gripper fully\n"
+                    f"Press ENTER when gripper is closed..."
+                )
+                closed_pos = bus.read("Present_Position", motor_name, normalize=False)
+                logger.info(f"  Gripper closed position recorded: {closed_pos}")
+                
+                input(
+                    f"\nStep 2: OPEN the gripper fully\n"
+                    f"Press ENTER when gripper is fully open..."
+                )
+                open_pos = bus.read("Present_Position", motor_name, normalize=False)
+                logger.info(f"  Gripper open position recorded: {open_pos}")
+                
+                # For RANGE_0_100: range_min maps to 0 (closed), range_max maps to 100 (open)
+                # If gripper motor direction is reversed (closed > open), we need to swap and use drive_mode=1
+                if closed_pos < open_pos:
+                    # Normal direction: 0=closed, 100=open
+                    range_min = int(closed_pos)
+                    range_max = int(open_pos)
+                    drive_mode = 0
+                else:
+                    # Reversed direction: swap so min < max, and set drive_mode=1 to reverse
+                    range_min = int(open_pos)
+                    range_max = int(closed_pos)
+                    drive_mode = 1
+                
+                logger.info(f"  {prefixed_name}: range set to [{range_min}, {range_max}] (0=closed, 100=open, drive_mode={drive_mode})")
+            else:
+                # Use full motor range for joint motors (will use degrees normalization)
+                range_min = 0
+                range_max = max_res
+                drive_mode = 0  # Normal direction for non-gripper motors
+                logger.info(f"  {prefixed_name}: range set to [0, {max_res}] (full motor range)")
+            
+            self.calibration[prefixed_name] = MotorCalibration(
+                id=motor.id,
+                drive_mode=drive_mode,
+                homing_offset=homing_offsets[motor_name],
+                range_min=range_min,
+                range_max=range_max,
+            )
+        
+        # Write calibration to this arm's motors
+        cal_for_bus = {k.replace(f"{arm_name}_", ""): v for k, v in self.calibration.items() if k.startswith(f"{arm_name}_")}
+        bus.write_calibration(cal_for_bus)
+
+    def configure(self) -> None:
+        """Configure motors with appropriate settings."""
+        # Configure right arm
+        self.bus_right.disable_torque()
+        self.bus_right.configure_motors()
+        for motor in self.bus_right.motors:
+            self.bus_right.write("Operating_Mode", motor, OperatingMode.POSITION.value)
+        
+        # Configure left arm
+        self.bus_left.disable_torque()
+        self.bus_left.configure_motors()
+        for motor in self.bus_left.motors:
+            self.bus_left.write("Operating_Mode", motor, OperatingMode.POSITION.value)
+
+    def setup_motors(self) -> None:
+        """Setup motor IDs for both arms."""
+        print("\nSetting up RIGHT arm motors...")
+        for motor in reversed(self.bus_right.motors):
+            input(f"Connect the controller board to the RIGHT '{motor}' motor only and press enter.")
+            self.bus_right.setup_motor(motor)
+            print(f"RIGHT '{motor}' motor id set to {self.bus_right.motors[motor].id}")
+        
+        print("\nSetting up LEFT arm motors...")
+        for motor in reversed(self.bus_left.motors):
+            input(f"Connect the controller board to the LEFT '{motor}' motor only and press enter.")
+            self.bus_left.setup_motor(motor)
+            print(f"LEFT '{motor}' motor id set to {self.bus_left.motors[motor].id}")
+
+    def get_action(self) -> dict[str, float]:
+        """Get current action from both arms (read positions from all motors)."""
+        start = time.perf_counter()
+        
+        # Motors to flip (invert direction) - different for each arm
+        right_motors_to_flip = ["joint_1", "joint_2", "joint_3", "joint_4", "joint_5"]
+        left_motors_to_flip = ["joint_1", "joint_3", "joint_4", "joint_5", "joint_6", "joint_7"]
+        
+        # Read positions from both arms
+        right_positions = self.bus_right.sync_read("Present_Position")
+        left_positions = self.bus_left.sync_read("Present_Position")
+        
+        # Combine into single action dict with arm prefixes and flip specified motors
+        action = {}
+        for motor, val in right_positions.items():
+            if motor in right_motors_to_flip:
+                action[f"right_{motor}.pos"] = -val
+            else:
+                action[f"right_{motor}.pos"] = val
+        for motor, val in left_positions.items():
+            if motor in left_motors_to_flip:
+                action[f"left_{motor}.pos"] = -val
+            else:
+                action[f"left_{motor}.pos"] = val
+        
+        dt_ms = (time.perf_counter() - start) * 1e3
+        logger.debug(f"{self} read action: {dt_ms:.1f}ms")
+        return action
+
+    def send_feedback(self, feedback: dict[str, float]) -> None:
+        """Send feedback to teleoperator (not implemented)."""
+        raise NotImplementedError
+
+    def disconnect(self) -> None:
+        """Disconnect from both arms."""
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+
+        # Disconnect both buses
+        self.bus_right.disconnect()
+        self.bus_left.disconnect()
+        logger.info(f"{self} disconnected.")
+

src/lerobot/teleoperators/utils.py

@@ -77,6 +77,10 @@ def make_teleoperator_from_config(config: TeleoperatorConfig) -> Teleoperator:
         from .reachy2_teleoperator import Reachy2Teleoperator
 
         return Reachy2Teleoperator(config)
+    elif config.type == "openarms_mini":
+        from .openarms_mini import OpenArmsMini
+
+        return OpenArmsMini(config)
     else:
         try:
             return cast(Teleoperator, make_device_from_device_class(config))